elm_install 0.3.1 → 1.0.0

data/lib/elm_install/directory_source.rb

@@ -0,0 +1,66 @@
+module ElmInstall
+  # This clas handles sources that point to a local directory.
+  class DirectorySource < Source
+    # @return [Dir] The directory
+    attr_reader :dir
+
+    Contract Pathname => DirectorySource
+    # Initializes a directory source with the given directory.
+    #
+    # @param dir [Dir] The directory
+    #
+    # @return [DirectorySource] The directory source instance
+    def initialize(dir)
+      @dir = dir
+      self
+    end
+
+    Contract Or[String, Semverse::Version] => Dir
+    # Returns the directory
+    #
+    # @param _ [String] The version
+    #
+    # @return [Dir] The directory
+    def fetch(_)
+      Dir.new(@dir.expand_path)
+    end
+
+    Contract Semverse::Version, Pathname => nil
+    # Copies the directory to the given other directory
+    #
+    # @param _ [Semverse::Version] The version
+    # @param directory [Pathname] The pathname
+    #
+    # @return nil
+    def copy_to(_, directory)
+      # Delete the directory to make sure no pervious version remains
+      FileUtils.rm_rf(directory) if directory.exist?
+
+      # Create parent directory
+      FileUtils.mkdir_p(directory.parent)
+
+      # Create symlink
+      FileUtils.ln_s(@dir.expand_path, directory)
+
+      nil
+    end
+
+    Contract ArrayOf[Solve::Constraint] => ArrayOf[Semverse::Version]
+    # Returns the available versions for a repository
+    #
+    # @param _ [Array] The constraints
+    #
+    # @return [Array] The versions
+    def versions(_)
+      [identifier.version(fetch(''))]
+    end
+
+    Contract None => String
+    # Returns the log format
+    #
+    # @return [String]
+    def to_log
+      @dir.expand_path.to_s
+    end
+  end
+end

data/lib/elm_install/ext.rb

@@ -0,0 +1,23 @@
+# Extensions for the semvese module
+module Semverse
+  # Added utility functions
+  class Version
+    # Returns the simple string representation of a version
+    #
+    # @return [String]
+    def to_simple
+      "#{major}.#{minor}.#{patch}"
+    end
+
+    # Tries to parse a version, falling back to nil if fails.
+    #
+    # @param version [String] The version to parse
+    #
+    # @return [Semverse::Version]
+    def self.try_new(version)
+      new version
+    rescue
+      nil
+    end
+  end
+end

data/lib/elm_install/git_source.rb

@@ -0,0 +1,173 @@
+module ElmInstall
+  # Git Source
+  class GitSource < Source
+    # @return [Uri] The uri
+    attr_reader :uri
+
+    # @return [Branch] The branch
+    attr_reader :branch
+
+    Contract Uri, Branch => GitSource
+    # Initializes a git source by URI and branch
+    #
+    # @param uri [Uri] The uri
+    # @param branch [Branch] The branch
+    #
+    # @return [GitSource]
+    def initialize(uri, branch)
+      @branch = branch
+      @uri = uri
+      self
+    end
+
+    Contract Or[String, Semverse::Version] => Dir
+    # Downloads the version into a temporary directory
+    #
+    # @param version [Semverse::Version] The version to fetch
+    #
+    # @return [Dir] The directory for the source of the version
+    def fetch(version)
+      # Get the reference from the branch
+      ref =
+        case @branch
+        when Branch::Just
+          @branch.ref
+        when Branch::Nothing
+          version.to_simple
+        end
+
+      repository.checkout ref
+    end
+
+    Contract Semverse::Version, Pathname => nil
+    # Copies the version into the given directory
+    #
+    # @param version [Semverse::Version] The version
+    # @param directory [Pathname] The pathname
+    #
+    # @return nil
+    def copy_to(version, directory)
+      # Delete the directory to make sure no pervious version remains if
+      # we are using a branch or symlink if using Dir.
+      FileUtils.rm_rf(directory) if directory.exist?
+
+      # Create directory if not exists
+      FileUtils.mkdir_p directory
+
+      # Copy hole repository
+      FileUtils.cp_r("#{fetch(version).path}/.", directory)
+
+      # Remove .git directory
+      FileUtils.rm_rf(File.join(directory, '.git'))
+
+      nil
+    end
+
+    Contract ArrayOf[Solve::Constraint] => ArrayOf[Semverse::Version]
+    # Returns the available versions for a repository
+    #
+    # @param constraints [Array] The constraints
+    #
+    # @return [Array] The versions
+    def versions(constraints)
+      case @branch
+      when Branch::Just
+        [identifier.version(fetch(@branch.ref))]
+      when Branch::Nothing
+        matches = matching_versions constraints
+        return matches if matches.any?
+        Logger.arrow(
+          "Could not find matching versions for: #{package_name.bold}"\
+          ' in cache. Fetching updates.'
+        )
+        repository.fetch
+        matching_versions constraints
+      end
+    end
+
+    Contract ArrayOf[Solve::Constraint] => ArrayOf[Semverse::Version]
+    # Returns the matchign versions for a repository for the given constraints
+    #
+    # @param constraints [Array] The constraints
+    #
+    # @return [Array] The versions
+    def matching_versions(constraints)
+      repository
+        .versions
+        .select do |version|
+          constraints.all? { |constraint| constraint.satisfies?(version) }
+        end
+    end
+
+    Contract None => String
+    # Returns the url for the repository
+    #
+    # @return [String] The url
+    def url
+      @uri.to_s
+    end
+
+    Contract None => String
+    # Returns the temporary path for the repository
+    #
+    # @return [String] The path
+    def path
+      File.join(options[:cache_directory].to_s, host, package_name)
+    end
+
+    Contract None => String
+    # Returns the host for the repository
+    #
+    # @return [String] The host
+    def host
+      case @uri
+      when Uri::Github
+        'github.com'
+      else
+        @uri.uri.host
+      end
+    end
+
+    Contract None => String
+    # Returns the package name for the repository
+    #
+    # @return [String] The name
+    def package_name
+      case @uri
+      when Uri::Github
+        @uri.name
+      else
+        @uri.uri.path.sub(%r{^/}, '')
+      end
+    end
+
+    Contract None => Repository
+    # Returns the local repository
+    #
+    # @return [Repository] The repository
+    def repository
+      @repository ||= Repository.new url, path
+    end
+
+    Contract None => Or[String, NilClass]
+    # Returns the log format
+    #
+    # @return [String]
+    def to_log
+      case @uri
+      when Uri::Ssh, Uri::Http
+        case @branch
+        when Branch::Just
+          "#{url} at #{@branch.ref}"
+        else
+          # NOTE: Cannot happen
+          # :nocov:
+          url
+          # :nocov:
+        end
+      else
+        url
+      end
+    end
+  end
+end

data/lib/elm_install/identifier.rb

@@ -0,0 +1,133 @@
+module ElmInstall
+  # Identifies dependencies
+  class Identifier < Base
+    # @return [Array<Dependency>] The initial dependencies
+    attr_reader :initial_dependencies
+
+    # @return [Hash] The options
+    attr_reader :options
+
+    Contract Dir, Hash => Identifier
+    # Initialize a new identifier.
+    #
+    # @param directory [Dir] The initial directory
+    # @param options [Hash] The options
+    #
+    # @return [Indentifier] The identifier instance
+    def initialize(directory, options = {})
+      @options = options
+      @dependency_sources = dependency_sources directory
+      @initial_dependencies = identify directory
+      self
+    end
+
+    Contract Dir => HashOf[String => Any]
+    # Returns the dependency sources for the given directory.
+    #
+    # @param directory [Dir] The directory
+    #
+    # @return [Hash] The directory sources
+    def dependency_sources(directory)
+      json(directory)['dependency-sources'].to_h
+    end
+
+    Contract Dir => Semverse::Version
+    # Returns the version of a package in the given directory.
+    #
+    # @param directory [Dir] The directory
+    #
+    # @return [Semverse::Version] The version
+    def version(directory)
+      Semverse::Version.new(json(directory)['version'])
+    end
+
+    Contract Dir => ArrayOf[Dependency]
+    # Identifies dependencies from a directory
+    #
+    # @param directory [Dir] The directory
+    #
+    # @return [Array] The dependencies
+    def identify(directory)
+      raw = json(directory)
+
+      dependencies = raw['dependencies'].to_h
+
+      dependency_sources =
+        raw['dependency-sources']
+        .to_h
+        .merge(@dependency_sources)
+
+      dependencies.map do |package, constraint|
+        constraints = Utils.transform_constraint constraint
+
+        type =
+          if dependency_sources.key?(package)
+            source = dependency_sources[package]
+            case source
+            when Hash
+              uri_type source['url'], Branch::Just(source['ref'])
+            when String
+              if File.exist?(source)
+                Type::Directory(Pathname.new(source))
+              else
+                uri_type source, Branch::Just('master')
+              end
+            end
+          else
+            Type::Git(Uri::Github(package), Branch::Nothing())
+          end
+
+        type.source.identifier = self
+        type.source.options = @options
+
+        Dependency.new(package, type.source, constraints)
+      end
+    end
+
+    Contract String, Branch => Type
+    # Returns the type from the given arguments.
+    #
+    # @param url [String] The base url
+    # @param branch [Branch] The branch
+    #
+    # @return [Type] The type
+    def uri_type(url, branch)
+      uri = GitCloneUrl.parse(url)
+      case uri
+      when URI::SshGit::Generic
+        Type::Git(Uri::Ssh(uri), branch)
+      when URI::HTTP
+        Type::Git(Uri::Http(uri), branch)
+      end
+    end
+
+    Contract Dir => HashOf[String => Any]
+    # Returns the contents of the 'elm-package.json' for the given directory.
+    #
+    # @param directory [Dir] The directory
+    #
+    # @return [Hash] The contents
+    def json(directory)
+      path = File.join(directory, 'elm-package.json')
+      JSON.parse(File.read(path))
+    rescue JSON::ParserError
+      exit "Invalid JSON in file: #{path.bold}"
+      {}
+    rescue Errno::ENOENT
+      exit "Could not find file: #{path.bold}"
+      {}
+    end
+
+    Contract String => NilClass
+    # Exits the current process and logs a given message.
+    #
+    # @param message [String] The message
+    #
+    # @return nil
+    def exit(message)
+      Logger.arrow message
+      Process.exit
+      nil
+    end
+  end
+end

data/lib/elm_install/installer.rb

@@ -1,118 +1,60 @@
-require_relative './resolver'
-require_relative './elm_package'
-require_relative './git_resolver'
-require_relative './graph_builder'
-require_relative './populator'
-
 module ElmInstall
-  # This class is responsible getting a solution for the `elm-package.json`
-  # file and populating the `elm-stuff` directory with the packages and
-  # writing the `elm-stuff/exact-dependencies.json`.
-  class Installer
-    # Initializes a new installer with the given options.
+  # Installer class
+  class Installer < Base
+    Contract KeywordArgs[cache_directory: Or[String, NilClass],
+                         verbose: Or[Bool, NilClass]] => Installer
+    # Initializes an installer with the given options
     #
     # @param options [Hash] The options
-    def initialize(options)
-      init_options options
-      @git_resolver = GitResolver.new directory: cache_directory
-      @cache = Cache.new directory: cache_directory
-      @populator = Populator.new @git_resolver
-      @options = options
-    end
-
-    # Initializes the options setting default values.
     #
-    # @param options [Hash] The options
-    #
-    # @return [Hash] The options
-    def init_options(options = { verbose: false })
-      options[:cache_directory] ||= File.join(Dir.home, '.elm-install')
-      @options = options
+    # @return [Installer] The installer instance
+    def initialize(options = {})
+      @identifier = Identifier.new Dir.new(Dir.pwd), options
+      @resolver = Resolver.new @identifier
+      self
     end
 
-    # Returns the path to the cache directory
+    Contract None => NilClass
+    # Installs packages
     #
-    # @return [String] The path
-    def cache_directory
-      @options[:cache_directory]
-    end
-
-    # Executes the installation
-    #
-    # :reek:TooManyStatements { max_statements: 7 }
-    #
-    # @return [void]
+    # @return nil
     def install
       puts 'Resolving packages...'
-      resolver.add_constraints dependencies
+      @graph = @resolver.resolve
 
       puts 'Solving dependencies...'
-      populate_elm_stuff
-    rescue
-      retry_install
-    end
-
-    # Saves the caches
-    #
-    # @return [void]
-    def save
-      puts 'Saving package cache...'
-      @git_resolver.save
-      @cache.save
-    end
+      (Populator.new results).populate
 
-    # Clears the reference cache and retries installation.
-    #
-    # @return [void]
-    def retry_install
-      Logger.arrow(
-        'Could not find a solution in local cache, refreshing packages...'
-      )
-
-      @git_resolver.clear
-      resolver.add_constraints dependencies
-
-      populate_elm_stuff
-    rescue Solve::Errors::NoSolutionError => error
-      puts 'Could not find a solution:'
-      puts error.to_s.indent(2)
-    end
-
-    private
-
-    # Populates the `elm-stuff` directory with the packages from
-    # the solution.
-    #
-    # @return [void]
-    def populate_elm_stuff
-      save
-      @populator.populate calculate_solution
       puts 'Packages configured successfully!'
+      nil
+    rescue Solve::Errors::NoSolutionError => error
+      Logger.arrow "No solution found: #{error}"
     end
 
-    # Returns the resolver to calculate the solution.
-    #
-    # @return [Resolver] The resolver
-    def resolver
-      @resolver ||= Resolver.new @cache, @git_resolver
-    end
-
-    # Returns the solution for the given `elm-package.json` file.
+    Contract None => ArrayOf[Dependency]
+    # Returns the results of solving
     #
-    # @return [Hash] The solution
-    def calculate_solution
-      Solve.it!(
-        GraphBuilder.graph_from_cache(@cache, @options),
-        resolver.constraints
-      )
+    # @return [Array] Array of dependencies
+    def results
+      Solve
+        .it!(@graph, initial_solve_constraints)
+        .map do |name, version|
+          dep = @resolver.dependencies[name]
+          dep.version = Semverse::Version.new(version)
+          dep
+        end
     end
 
-    # Returns the dependencies form `elm-package.json`.
+    Contract None => Array
+    # Returns the inital constraints
     #
-    # @return [Hash] The dependencies
-    def dependencies
-      @dependencies ||= ElmPackage.dependencies 'elm-package.json',
-                                                silent: false
+    # @return [Array] Array of dependency names and constraints
+    def initial_solve_constraints
+      @identifier.initial_dependencies.flat_map do |dependency|
+        dependency.constraints.map do |constraint|
+          [dependency.name, constraint]
+        end
+      end
     end
   end
 end