Пример #1
0
        private void BuildTargetFrameworksAndConfigurations(JsonObject projectJsonObject,
                                                            ICollection <ICompilationMessage> diagnostics)
        {
            // Get the shared compilationOptions
            _defaultCompilerOptions = GetCompilationOptions(projectJsonObject) ?? new CompilerOptions();

            _defaultTargetFrameworkConfiguration = new TargetFrameworkInformation
            {
                Dependencies = new List <LibraryDependency>()
            };

            // Add default configurations
            _configurations["Debug"] = new CompilerOptions
            {
                Defines  = new[] { "DEBUG", "TRACE" },
                Optimize = false
            };

            _configurations["Release"] = new CompilerOptions
            {
                Defines  = new[] { "RELEASE", "TRACE" },
                Optimize = true
            };

            // The configuration node has things like debug/release compiler settings

            /*
             *  {
             *      "configurations": {
             *          "Debug": {
             *          },
             *          "Release": {
             *          }
             *      }
             *  }
             */

            var configurations = projectJsonObject.ValueAsJsonObject("configurations");

            if (configurations != null)
            {
                foreach (var configKey in configurations.Keys)
                {
                    var compilerOptions = GetCompilationOptions(configurations.ValueAsJsonObject(configKey));

                    // Only use this as a configuration if it's not a target framework
                    _configurations[configKey] = compilerOptions;
                }
            }

            // The frameworks node is where target frameworks go

            /*
             *  {
             *      "frameworks": {
             *          "net45": {
             *          },
             *          "k10": {
             *          }
             *      }
             *  }
             */

            var frameworks = projectJsonObject.ValueAsJsonObject("frameworks");

            if (frameworks != null)
            {
                foreach (var frameworkKey in frameworks.Keys)
                {
                    try
                    {
                        var frameworkToken = frameworks.ValueAsJsonObject(frameworkKey);
                        var success        = BuildTargetFrameworkNode(frameworkKey, frameworkToken);
                        if (!success)
                        {
                            diagnostics?.Add(
                                new FileFormatMessage(
                                    $"\"{frameworkKey}\" is an unsupported framework",
                                    ProjectFilePath,
                                    CompilationMessageSeverity.Error,
                                    frameworkToken));
                        }
                    }
                    catch (Exception ex)
                    {
                        throw FileFormatException.Create(ex, frameworks.Value(frameworkKey), ProjectFilePath);
                    }
                }
            }
        }
Пример #2
0
        internal static Project GetProjectFromStream(Stream stream, string projectName, string projectPath, ICollection <ICompilationMessage> diagnostics = null)
        {
            var project = new Project();

            var reader     = new StreamReader(stream);
            var rawProject = JsonDeserializer.Deserialize(reader) as JsonObject;

            if (rawProject == null)
            {
                throw FileFormatException.Create(
                          "The JSON file can't be deserialized to a JSON object.",
                          projectPath);
            }

            // Meta-data properties
            project.Name            = projectName;
            project.ProjectFilePath = Path.GetFullPath(projectPath);

            var version = rawProject.Value("version") as JsonString;

            if (version == null)
            {
                project.Version = new SemanticVersion("1.0.0");
            }
            else
            {
                try
                {
                    var buildVersion = Environment.GetEnvironmentVariable("DNX_BUILD_VERSION");
                    project.Version = SpecifySnapshot(version, buildVersion);
                }
                catch (Exception ex)
                {
                    throw FileFormatException.Create(ex, version, project.ProjectFilePath);
                }
            }

            var fileVersion = Environment.GetEnvironmentVariable("DNX_ASSEMBLY_FILE_VERSION");

            if (string.IsNullOrWhiteSpace(fileVersion))
            {
                project.AssemblyFileVersion = project.Version.Version;
            }
            else
            {
                try
                {
                    var simpleVersion = project.Version.Version;
                    project.AssemblyFileVersion = new Version(simpleVersion.Major,
                                                              simpleVersion.Minor,
                                                              simpleVersion.Build,
                                                              int.Parse(fileVersion));
                }
                catch (FormatException ex)
                {
                    throw new FormatException("The assembly file version is invalid: " + fileVersion, ex);
                }
            }

            project.Description = rawProject.ValueAsString("description");
            project.Summary     = rawProject.ValueAsString("summary");
            project.Copyright   = rawProject.ValueAsString("copyright");
            project.Title       = rawProject.ValueAsString("title");
            project.WebRoot     = rawProject.ValueAsString("webroot");
            project.EntryPoint  = rawProject.ValueAsString("entryPoint");
            project.ProjectUrl  = rawProject.ValueAsString("projectUrl");
            project.LicenseUrl  = rawProject.ValueAsString("licenseUrl");
            project.IconUrl     = rawProject.ValueAsString("iconUrl");

            project.Authors = rawProject.ValueAsStringArray("authors") ?? new string[] { };
            project.Owners  = rawProject.ValueAsStringArray("owners") ?? new string[] { };
            project.Tags    = rawProject.ValueAsStringArray("tags") ?? new string[] { };

            project.Language     = rawProject.ValueAsString("language");
            project.ReleaseNotes = rawProject.ValueAsString("releaseNotes");

            project.RequireLicenseAcceptance = rawProject.ValueAsBoolean("requireLicenseAcceptance", defaultValue: false);
            project.IsLoadable = rawProject.ValueAsBoolean("loadable", defaultValue: true);
            // TODO: Move this to the dependencies node
            project.EmbedInteropTypes = rawProject.ValueAsBoolean("embedInteropTypes", defaultValue: false);

            project.Dependencies = new List <LibraryDependency>();

            // Project files
            project.Files = new ProjectFilesCollection(rawProject,
                                                       project.ProjectDirectory,
                                                       project.ProjectFilePath,
                                                       diagnostics);

            var compilerInfo = rawProject.ValueAsJsonObject("compiler");

            if (compilerInfo != null)
            {
                var languageName     = compilerInfo.ValueAsString("name") ?? "C#";
                var compilerAssembly = compilerInfo.ValueAsString("compilerAssembly");
                var compilerType     = compilerInfo.ValueAsString("compilerType");

                var compiler = new TypeInformation(compilerAssembly, compilerType);
                project.CompilerServices = new CompilerServices(languageName, compiler);
            }

            var commands = rawProject.Value("commands") as JsonObject;

            if (commands != null)
            {
                foreach (var key in commands.Keys)
                {
                    var value = commands.ValueAsString(key);
                    if (value != null)
                    {
                        project.Commands[key] = value;
                    }
                }
            }

            var scripts = rawProject.Value("scripts") as JsonObject;

            if (scripts != null)
            {
                foreach (var key in scripts.Keys)
                {
                    var stringValue = scripts.ValueAsString(key);
                    if (stringValue != null)
                    {
                        project.Scripts[key] = new string[] { stringValue };
                        continue;
                    }

                    var arrayValue = scripts.ValueAsStringArray(key);
                    if (arrayValue != null)
                    {
                        project.Scripts[key] = arrayValue;
                        continue;
                    }

                    throw FileFormatException.Create(
                              string.Format("The value of a script in {0} can only be a string or an array of strings", ProjectFileName),
                              scripts.Value(key),
                              project.ProjectFilePath);
                }
            }

            var repository = rawProject.Value("repository") as JsonObject;

            if (repository != null)
            {
                project.Repository = repository
                                     .Keys
                                     .ToDictionary(
                    key => key,
                    key => repository.ValueAsString(key).Value);
            }

            project.BuildTargetFrameworksAndConfigurations(rawProject, diagnostics);

            PopulateDependencies(
                project.ProjectFilePath,
                project.Dependencies,
                rawProject,
                "dependencies",
                isGacOrFrameworkReference: false);

            return(project);
        }
Пример #3
0
        private static void PopulateDependencies(
            string projectPath,
            IList <LibraryDependency> results,
            JsonObject settings,
            string propertyName,
            bool isGacOrFrameworkReference)
        {
            var dependencies = settings.ValueAsJsonObject(propertyName);

            if (dependencies != null)
            {
                foreach (var dependencyKey in dependencies.Keys)
                {
                    if (string.IsNullOrEmpty(dependencyKey))
                    {
                        throw FileFormatException.Create(
                                  "Unable to resolve dependency ''.",
                                  dependencies.Value(dependencyKey),
                                  projectPath);
                    }

                    var        dependencyValue           = dependencies.Value(dependencyKey);
                    var        dependencyTypeValue       = LibraryDependencyType.Default;
                    JsonString dependencyVersionAsString = null;

                    if (dependencyValue is JsonObject)
                    {
                        // "dependencies" : { "Name" : { "version": "1.0", "type": "build" } }
                        var dependencyValueAsObject = (JsonObject)dependencyValue;
                        dependencyVersionAsString = dependencyValueAsObject.ValueAsString("version");

                        IEnumerable <string> strings;
                        if (TryGetStringEnumerable(dependencyValueAsObject, "type", out strings))
                        {
                            dependencyTypeValue = LibraryDependencyType.Parse(strings);
                        }
                    }
                    else if (dependencyValue is JsonString)
                    {
                        // "dependencies" : { "Name" : "1.0" }
                        dependencyVersionAsString = (JsonString)dependencyValue;
                    }
                    else
                    {
                        throw FileFormatException.Create(
                                  string.Format("Invalid dependency version: {0}. The format is not recognizable.", dependencyKey),
                                  dependencyValue,
                                  projectPath);
                    }

                    SemanticVersionRange dependencyVersionRange = null;
                    if (!string.IsNullOrEmpty(dependencyVersionAsString?.Value))
                    {
                        try
                        {
                            dependencyVersionRange = VersionUtility.ParseVersionRange(dependencyVersionAsString.Value);
                        }
                        catch (Exception ex)
                        {
                            throw FileFormatException.Create(
                                      ex,
                                      dependencyValue,
                                      projectPath);
                        }
                    }

                    results.Add(new LibraryDependency
                    {
                        LibraryRange = new LibraryRange(dependencyKey, isGacOrFrameworkReference)
                        {
                            VersionRange = dependencyVersionRange,
                            FileName     = projectPath,
                            Line         = dependencyValue.Line,
                            Column       = dependencyValue.Column
                        },
                        Type = dependencyTypeValue
                    });
                }
            }
        }
Пример #4
0
        private void BuildTargetFrameworksAndConfigurations(JObject rawProject)
        {
            // Get the shared compilationOptions
            _defaultCompilerOptions = GetCompilationOptions(rawProject) ?? _emptyOptions;

            _defaultTargetFrameworkConfiguration = new TargetFrameworkInformation
            {
                Dependencies = new List <LibraryDependency>()
            };

            // Add default configurations
            _configurations["Debug"] = new CompilerOptions
            {
                Defines  = new[] { "DEBUG", "TRACE" },
                Optimize = false
            };

            _configurations["Release"] = new CompilerOptions
            {
                Defines  = new[] { "RELEASE", "TRACE" },
                Optimize = true
            };

            // The configuration node has things like debug/release compiler settings

            /*
             *  {
             *      "configurations": {
             *          "Debug": {
             *          },
             *          "Release": {
             *          }
             *      }
             *  }
             */
            var configurations = rawProject["configurations"] as JObject;

            if (configurations != null)
            {
                foreach (var configuration in configurations)
                {
                    var compilerOptions = GetCompilationOptions(configuration.Value);

                    // Only use this as a configuration if it's not a target framework
                    _configurations[configuration.Key] = compilerOptions;
                }
            }

            // The frameworks node is where target frameworks go

            /*
             *  {
             *      "frameworks": {
             *          "net45": {
             *          },
             *          "k10": {
             *          }
             *      }
             *  }
             */

            var frameworks = rawProject["frameworks"] as JObject;

            if (frameworks != null)
            {
                foreach (var framework in frameworks)
                {
                    try
                    {
                        BuildTargetFrameworkNode(framework);
                    }
                    catch (Exception ex)
                    {
                        throw FileFormatException.Create(ex, framework.Value, ProjectFilePath);
                    }
                }
            }
        }
Пример #5
0
        private static void PopulateDependencies(
            string projectPath,
            IList <LibraryDependency> results,
            JObject settings,
            string propertyName,
            bool isGacOrFrameworkReference)
        {
            var dependencies = settings[propertyName] as JObject;

            if (dependencies != null)
            {
                foreach (var dependency in dependencies.Properties())
                {
                    if (string.IsNullOrEmpty(dependency.Name))
                    {
                        throw FileFormatException.Create(
                                  "Unable to resolve dependency ''.",
                                  dependency,
                                  projectPath);
                    }

                    // Support
                    // "dependencies" : {
                    //    "Name" : "1.0"
                    // }

                    var dependencyValue     = dependency.Value;
                    var dependencyTypeValue = LibraryDependencyType.Default;

                    string dependencyVersionValue = null;
                    JToken dependencyVersionToken = dependencyValue;

                    if (dependencyValue.Type == JTokenType.String)
                    {
                        dependencyVersionValue = dependencyValue.Value <string>();
                    }
                    else
                    {
                        if (dependencyValue.Type == JTokenType.Object)
                        {
                            dependencyVersionToken = dependencyValue["version"];
                            if (dependencyVersionToken != null && dependencyVersionToken.Type == JTokenType.String)
                            {
                                dependencyVersionValue = dependencyVersionToken.Value <string>();
                            }
                        }

                        IEnumerable <string> strings;
                        if (TryGetStringEnumerable(dependencyValue["type"], out strings))
                        {
                            dependencyTypeValue = LibraryDependencyType.Parse(strings);
                        }
                    }

                    SemanticVersionRange dependencyVersionRange = null;

                    if (!string.IsNullOrEmpty(dependencyVersionValue))
                    {
                        try
                        {
                            dependencyVersionRange = VersionUtility.ParseVersionRange(dependencyVersionValue);
                        }
                        catch (Exception ex)
                        {
                            throw FileFormatException.Create(
                                      ex,
                                      dependencyVersionToken,
                                      projectPath);
                        }
                    }

                    var dependencyLineInfo = (IJsonLineInfo)dependency;

                    results.Add(new LibraryDependency
                    {
                        LibraryRange = new LibraryRange
                        {
                            Name         = dependency.Name,
                            VersionRange = dependencyVersionRange,
                            IsGacOrFrameworkReference = isGacOrFrameworkReference,
                            FileName = projectPath,
                            Line     = dependencyLineInfo.LineNumber,
                            Column   = dependencyLineInfo.LinePosition
                        },
                        Type = dependencyTypeValue
                    });
                }
            }
        }
Пример #6
0
        internal static Project GetProjectFromStream(Stream stream, string projectName, string projectPath, ICollection <ICompilationMessage> diagnostics = null)
        {
            var project = new Project();

            var reader     = new JsonTextReader(new StreamReader(stream));
            var rawProject = JObject.Load(reader);

            // Meta-data properties
            var version      = rawProject["version"];
            var authors      = rawProject["authors"];
            var owners       = rawProject["owners"];
            var tags         = rawProject["tags"];
            var buildVersion = Environment.GetEnvironmentVariable("DNX_BUILD_VERSION");

            project.Name            = projectName;
            project.ProjectFilePath = Path.GetFullPath(projectPath);

            if (version == null)
            {
                project.Version = new SemanticVersion("1.0.0");
            }
            else
            {
                try
                {
                    project.Version = SpecifySnapshot(version.Value <string>(), buildVersion);
                }
                catch (Exception ex)
                {
                    var lineInfo = (IJsonLineInfo)version;

                    throw FileFormatException.Create(ex, version, project.ProjectFilePath);
                }
            }

            var fileVersion = Environment.GetEnvironmentVariable("DNX_ASSEMBLY_FILE_VERSION");

            if (string.IsNullOrWhiteSpace(fileVersion))
            {
                project.AssemblyFileVersion = project.Version.Version;
            }
            else
            {
                try
                {
                    var simpleVersion = project.Version.Version;
                    project.AssemblyFileVersion = new Version(simpleVersion.Major,
                                                              simpleVersion.Minor,
                                                              simpleVersion.Build,
                                                              int.Parse(fileVersion));
                }
                catch (FormatException ex)
                {
                    throw new FormatException("The assembly file version is invalid: " + fileVersion, ex);
                }
            }

            project.Description              = rawProject.GetValue <string>("description");
            project.Summary                  = rawProject.GetValue <string>("summary");
            project.Copyright                = rawProject.GetValue <string>("copyright");
            project.Title                    = rawProject.GetValue <string>("title");
            project.Authors                  = authors == null ? new string[] { } : authors.ValueAsArray <string>();
            project.Owners                   = owners == null ? new string[] { } : owners.ValueAsArray <string>();
            project.Dependencies             = new List <LibraryDependency>();
            project.WebRoot                  = rawProject.GetValue <string>("webroot");
            project.EntryPoint               = rawProject.GetValue <string>("entryPoint");
            project.ProjectUrl               = rawProject.GetValue <string>("projectUrl");
            project.LicenseUrl               = rawProject.GetValue <string>("licenseUrl");
            project.IconUrl                  = rawProject.GetValue <string>("iconUrl");
            project.RequireLicenseAcceptance = rawProject.GetValue <bool?>("requireLicenseAcceptance") ?? false;
            project.Tags       = tags == null ? new string[] { } : tags.ValueAsArray <string>();
            project.IsLoadable = rawProject.GetValue <bool?>("loadable") ?? true;

            // TODO: Move this to the dependencies node
            project.EmbedInteropTypes = rawProject.GetValue <bool>("embedInteropTypes");

            // Project files
            project.Files = new ProjectFilesCollection(rawProject, project.ProjectDirectory, project.ProjectFilePath, diagnostics);

            var languageInfo = rawProject["language"] as JObject;

            if (languageInfo != null)
            {
                var languageName                 = languageInfo.GetValue <string>("name") ?? "C#";
                var languageServicesAssembly     = languageInfo.GetValue <string>("assembly");
                var projectReferenceProviderType = languageInfo.GetValue <string>("projectReferenceProviderType");

                var libraryExporter = new TypeInformation(languageServicesAssembly, projectReferenceProviderType);
                project.LanguageServices = new LanguageServices(languageName, libraryExporter);
            }

            var commands = rawProject["commands"] as JObject;

            if (commands != null)
            {
                foreach (var command in commands)
                {
                    project.Commands[command.Key] = command.Value.Value <string>();
                }
            }

            var scripts = rawProject["scripts"] as JObject;

            if (scripts != null)
            {
                foreach (var script in scripts)
                {
                    var value = script.Value;
                    if (value.Type == JTokenType.String)
                    {
                        project.Scripts[script.Key] = new string[] { value.Value <string>() };
                    }
                    else if (value.Type == JTokenType.Array)
                    {
                        project.Scripts[script.Key] = script.Value.ValueAsArray <string>();
                    }
                    else
                    {
                        throw FileFormatException.Create(
                                  string.Format("The value of a script in {0} can only be a string or an array of strings", ProjectFileName),
                                  value,
                                  project.ProjectFilePath);
                    }
                }
            }

            project.BuildTargetFrameworksAndConfigurations(rawProject);

            PopulateDependencies(
                project.ProjectFilePath,
                project.Dependencies,
                rawProject,
                "dependencies",
                isGacOrFrameworkReference: false);

            return(project);
        }
Пример #7
0
        public static Project GetProject(Stream stream, string projectName, string projectPath)
        {
            var project = new Project();

            var reader     = new JsonTextReader(new StreamReader(stream));
            var rawProject = JObject.Load(reader);

            // Metadata properties
            var version      = rawProject["version"];
            var authors      = rawProject["authors"];
            var tags         = rawProject["tags"];
            var buildVersion = Environment.GetEnvironmentVariable("K_BUILD_VERSION");

            project.Name            = projectName;
            project.ProjectFilePath = Path.GetFullPath(projectPath);

            if (version == null)
            {
                project.Version = new SemanticVersion("1.0.0");
            }
            else
            {
                try
                {
                    project.Version = SpecifySnapshot(version.Value <string>(), buildVersion);
                }
                catch (Exception ex)
                {
                    var lineInfo = (IJsonLineInfo)version;

                    throw FileFormatException.Create(ex, version, project.ProjectFilePath);
                }
            }

            project.Description              = GetValue <string>(rawProject, "description");
            project.Authors                  = authors == null ? new string[] { } : authors.ToObject <string[]>();
            project.Dependencies             = new List <LibraryDependency>();
            project.WebRoot                  = GetValue <string>(rawProject, "webroot");
            project.EntryPoint               = GetValue <string>(rawProject, "entryPoint");
            project.ProjectUrl               = GetValue <string>(rawProject, "projectUrl");
            project.RequireLicenseAcceptance = GetValue <bool?>(rawProject, "requireLicenseAcceptance") ?? false;
            project.Tags       = tags == null ? new string[] { } : tags.ToObject <string[]>();
            project.IsLoadable = GetValue <bool?>(rawProject, "loadable") ?? true;

            // TODO: Move this to the dependencies node
            project.EmbedInteropTypes = GetValue <bool>(rawProject, "embedInteropTypes");

            // Source file patterns
            project.SourcePatterns        = GetSourcePattern(project, rawProject, "code", _defaultSourcePatterns);
            project.ExcludePatterns       = GetSourcePattern(project, rawProject, "exclude", _defaultExcludePatterns);
            project.BundleExcludePatterns = GetSourcePattern(project, rawProject, "bundleExclude", _defaultBundleExcludePatterns);
            project.PreprocessPatterns    = GetSourcePattern(project, rawProject, "preprocess", _defaultPreprocessPatterns);
            project.SharedPatterns        = GetSourcePattern(project, rawProject, "shared", _defaultSharedPatterns);
            project.ResourcesPatterns     = GetSourcePattern(project, rawProject, "resources", _defaultResourcesPatterns);
            project.ContentsPatterns      = GetSourcePattern(project, rawProject, "files", _defaultContentsPatterns);

            // Set the default loader information for projects
            var languageServicesAssembly     = DefaultLanguageServicesAssembly;
            var projectReferenceProviderType = DefaultProjectReferenceProviderType;
            var languageName = "C#";

            var languageInfo = rawProject["language"] as JObject;

            if (languageInfo != null)
            {
                languageName                 = GetValue <string>(languageInfo, "name");
                languageServicesAssembly     = GetValue <string>(languageInfo, "assembly");
                projectReferenceProviderType = GetValue <string>(languageInfo, "projectReferenceProviderType");
            }

            var libraryExporter = new TypeInformation(languageServicesAssembly, projectReferenceProviderType);

            project.LanguageServices = new LanguageServices(languageName, libraryExporter);

            var commands = rawProject["commands"] as JObject;

            if (commands != null)
            {
                foreach (var command in commands)
                {
                    project.Commands[command.Key] = command.Value.ToObject <string>();
                }
            }

            var scripts = rawProject["scripts"] as JObject;

            if (scripts != null)
            {
                foreach (var script in scripts)
                {
                    var value = script.Value;
                    if (value.Type == JTokenType.String)
                    {
                        project.Scripts[script.Key] = new string[] { value.ToObject <string>() };
                    }
                    else if (value.Type == JTokenType.Array)
                    {
                        project.Scripts[script.Key] = script.Value.ToObject <string[]>();
                    }
                    else
                    {
                        throw FileFormatException.Create(
                                  string.Format("The value of a script in {0} can only be a string or an array of strings", ProjectFileName),
                                  value,
                                  project.ProjectFilePath);
                    }
                }
            }

            project.BuildTargetFrameworksAndConfigurations(rawProject);

            PopulateDependencies(
                project.ProjectFilePath,
                project.Dependencies,
                rawProject,
                "dependencies",
                isGacOrFrameworkReference: false);

            return(project);
        }
Пример #8
0
        public static bool TryGetGlobalSettings(string path, out GlobalSettings globalSettings)
        {
            globalSettings = null;

            string globalJsonPath = null;

            if (Path.GetFileName(path) == GlobalFileName)
            {
                globalJsonPath = path;
                path           = Path.GetDirectoryName(path);
            }
            else if (!HasGlobalFile(path))
            {
                return(false);
            }
            else
            {
                globalJsonPath = Path.Combine(path, GlobalFileName);
            }

            globalSettings = new GlobalSettings();

            string  json     = File.ReadAllText(globalJsonPath);
            JObject settings = null;

            try
            {
                settings = JObject.Parse(json);
            }
            catch (JsonReaderException ex)
            {
                throw FileFormatException.Create(ex, globalJsonPath);
            }

            // TODO: Remove sources
            var projectSearchPaths = settings["projects"] ?? settings["sources"];
            var dependencies       = settings["dependencies"] as JObject;

            globalSettings.ProjectSearchPaths = projectSearchPaths == null ? new string[] { } : projectSearchPaths.ToObject <string[]>();
            globalSettings.PackagesPath       = settings.Value <string>("packages");
            globalSettings.PackageHashes      = new Dictionary <Library, string>();
            globalSettings.FilePath           = globalJsonPath;

            if (dependencies != null)
            {
                foreach (var property in dependencies.Properties())
                {
                    var dependencyValue = dependencies[property.Name] as JObject;
                    if (dependencyValue == null)
                    {
                        throw FileFormatException.Create(string.Format(
                                                             "The value of '{0}' in {1} must be an object", property.Name, GlobalFileName), property, globalJsonPath);
                    }

                    var versionToken = dependencyValue["version"];
                    var versionValue = versionToken?.ToString();

                    SemanticVersion version;
                    if (!SemanticVersion.TryParse(versionValue, out version))
                    {
                        throw FileFormatException.Create(string.Format(
                                                             "The dependency '{0}' in {1} doesn't have valid version information",
                                                             property.Name, GlobalFileName), versionToken, globalJsonPath);
                    }

                    var library = new Library()
                    {
                        Name    = property.Name,
                        Version = version
                    };

                    var shaToken = dependencyValue["sha"];
                    var shaValue = shaToken?.ToString();

                    if (string.IsNullOrEmpty(shaValue))
                    {
                        throw FileFormatException.Create(string.Format(
                                                             "The dependency '{0}' in {1} doesn't have a valid SHA value",
                                                             property.Name, GlobalFileName), shaToken, globalJsonPath);
                    }

                    globalSettings.PackageHashes[library] = shaValue;
                }
            }

            return(true);
        }