public string Generate()

in src/Json.Schema.ToDotNet/DataModelGenerator.cs [50:128]
62 lines of code
11 McCabe index (conditional complexity)

        public string Generate(JsonSchema rootSchema)
        {
            _additionalTypesRequiredList.Clear();

            if (_settings.GenerateCloningCode)
            {
                _kindEnumName = _settings.SchemaName + "NodeKind" + _settings.TypeNameSuffix;
                _nodeInterfaceName = "I" + _settings.SchemaName + "Node" + _settings.TypeNameSuffix;
            }

            _rootSchema = JsonSchema.Collapse(rootSchema);

            if (_fileSystem.DirectoryExists(_settings.OutputDirectory) && !_settings.ForceOverwrite)
            {
                throw Error.CreateException(Resources.ErrorOutputDirectoryExists, _settings.OutputDirectory);
            }

            _fileSystem.CreateDirectory(_settings.OutputDirectory);

            SchemaType rootSchemaType = _rootSchema.SafeGetType();
            if (rootSchemaType != SchemaType.Object)
            {
                throw Error.CreateException(Resources.ErrorNotAnObject, rootSchemaType.ToString().ToLowerInvariant());
            }

            string rootFileText = GenerateClass(_settings.RootClassName, _rootSchema);

            if (_settings.GenerateEqualityComparers)
            {
                GenerateEqualityComparer(_settings.RootClassName, _rootSchema);
            }

            if (_rootSchema.Definitions != null)
            {
                List<KeyValuePair<string, JsonSchema>> typeDefinitions = _rootSchema.Definitions.Where(ShouldGenerateType).ToList();
                GenerateClassesForDefinitions(typeDefinitions);

                if (_settings.GenerateEqualityComparers)
                {
                    GenerateEqualityComparers(typeDefinitions);
                }
            }

            foreach (AdditionalTypeRequiredInfo additionalTypeRequiredInfo in _additionalTypesRequiredList)
            {
                GenerateAdditionalType(additionalTypeRequiredInfo.Hint, additionalTypeRequiredInfo.Schema);
            }

            if (_settings.GenerateCloningCode)
            {
                _pathToFileContentsDictionary[_nodeInterfaceName + _settings.TypeNameSuffix] =
                    GenerateSyntaxInterface(_settings.SchemaName, _kindEnumName, _nodeInterfaceName);

                _pathToFileContentsDictionary[_kindEnumName + _settings.TypeNameSuffix] =
                    GenerateKindEnum(_kindEnumName);

                string rewritingVisitorClassName = _settings.SchemaName + "RewritingVisitor" + _settings.TypeNameSuffix;
                _pathToFileContentsDictionary[rewritingVisitorClassName] =
                    new RewritingVisitorGenerator(
                        _classInfoDictionary,
                        _settings.CopyrightNotice,
                        _settings.SuffixedNamespaceName,
                        rewritingVisitorClassName,
                        _settings.SchemaName,
                        _kindEnumName,
                        _nodeInterfaceName,
                        _generatedClassNames)
                        .GenerateRewritingVisitor();
            }

            foreach (KeyValuePair<string, string> entry in _pathToFileContentsDictionary)
            {
                _fileSystem.WriteAllText(Path.Combine(_settings.OutputDirectory, entry.Key + ".cs"), entry.Value);
            }

            // Returning the text of the file generated from the root schema allows this method
            // to be more easily unit tested.
            return rootFileText;
        }