elm_install 0.3.1 → 1.0.0

data/lib/elm_install/populator.rb

@@ -1,100 +1,79 @@
 module ElmInstall
-  # This class is responsible for populating the `elm-stuff` directory.
-  class Populator
-    # Initializes a new populator.
+  # Populator for 'elm-stuff' directory
+  class Populator < Base
+    Contract ArrayOf[Dependency] => Populator
+    # Initializes a new populator
     #
-    # @param git_resolver [GitResolver] The git resolver to use.
-    def initialize(git_resolver)
-      @git_resolver = git_resolver
-    end
-
-    # Populates `elm-stuff` from the given solution.
-    #
-    # @param solution [Hash] The solution.
-    #
-    # @return [void]
-    def populate(solution)
-      solution.each do |package, version|
-        resolve_package package, version
-      end
-
-      write_exact_dependencies(solution)
-    end
-
-    # Resolves and copies a package and it's version to `elm-stuff/packages`
-    # directory.
-    #
-    # :reek:TooManyStatements { max_statements: 9 }
+    # @param dependencies [Array] The dependencies to populate
     #
-    # @param package [String] The package
-    # @param version_str [String] The resolved version
-    #
-    # @return [void]
-    def resolve_package(package, version_str)
-      version, ref = self.class.version_and_ref(version_str)
-
-      package_name, package_path = Utils.package_version_path package, version
-
-      @git_resolver.repository(package).checkout(ref)
-
-      Logger.dot "#{package_name.bold} - #{version.bold} (#{ref})"
-
-      FileUtils.rm_rf(package_path) if Dir.exist?(package_path)
-
-      copy_package package, package_path
+    # @return Populator The populator instance
+    def initialize(dependencies)
+      @dependencies = dependencies
+      self
     end
 
-    # Copies the given package from it's repository to the given path.
+    Contract None => NilClass
+    # Populates 'elm-stuff' directory and writes
+    # 'elm-stuff/exact-dependencies.json'.
     #
-    # @param package [String] The package to copy
-    # @param package_path [String] The destination
-    #
-    # @return [void]
-    def copy_package(package, package_path)
-      repository_path = File.join(@git_resolver.repository_path(package), '.')
-
-      FileUtils.mkdir_p(package_path)
-      FileUtils.cp_r(repository_path, package_path)
-      FileUtils.rm_rf(File.join(package_path, '.git'))
+    # @return nil
+    def populate
+      copy_dependencies
+      write_exact_dependencies
     end
 
-    # Writes the `elm-stuff/exact-dependencies.json` file.
-    #
-    # @param solution [Hash] The solution
+    Contract None => NilClass
+    # Writes the 'elm-stuff/exact-dependencies.json'
     #
-    # @return [void]
-    def write_exact_dependencies(solution)
+    # @return nil
+    def write_exact_dependencies
       File.binwrite(
         File.join('elm-stuff', 'exact-dependencies.json'),
-        JSON.pretty_generate(self.class.exact_dependencies(solution))
+        JSON.pretty_generate(exact_dependencies)
       )
+      nil
     end
 
-    # Returns the exact dependencies from the solution.
+    Contract None => HashOf[String => String]
+    # Returns the contents for 'elm-stuff/exact-dependencies.json'
     #
-    # @param solution [Hash] The solution
+    # @return [Hash] The dependencies
+    def exact_dependencies
+      @dependencies.each_with_object({}) do |dependency, memo|
+        memo[dependency.name] = dependency.version.to_simple
+      end
+    end
+
+    Contract None => NilClass
+    # Copies dependencies to 'elm-stuff/packages/package/version' directory
     #
-    # @return [void]
-    def self.exact_dependencies(solution)
-      solution.each_with_object({}) do |(key, value), memo|
-        version, = version_and_ref value
+    # @return nil
+    def copy_dependencies
+      @dependencies.each do |dependency|
+        path =
+          File.join('elm-stuff', 'packages', dependency.name,
+                    dependency.version.to_simple)
 
-        memo[GitCloneUrl.parse(key).path.sub(%r{^/}, '')] = version
+        log_dependency dependency
+
+        dependency.source.copy_to(dependency.version, Pathname.new(path))
       end
+      nil
     end
 
-    # Retruns the version and the ref from the given string.
+    Contract Dependency => NilClass
+    # Logs the dependency with a dot
     #
-    # @param value [String] The input
+    # @param dependency [Dependency] The dependency
     #
-    # @return [Array] The version and the ref as an array
-    def self.version_and_ref(value)
-      match = value.match(/(.+)\+(.+)/)
-
-      version = match ? match[1] : value
-      ref = match ? match[2] : value
-
-      [version, ref]
+    # @return nil
+    def log_dependency(dependency)
+      log = "#{dependency.name} - "
+      log += dependency.source.to_log.to_s
+      log += " (#{dependency.version.to_simple})"
+
+      Logger.dot log
+      nil
     end
   end
 end

data/lib/elm_install/repository.rb

@@ -0,0 +1,82 @@
+module ElmInstall
+  # Handles git repositories.
+  class Repository < Base
+    extend Forwardable
+
+    # The url of the git repository
+    # @return [String]
+    attr_reader :url
+
+    # The path to the directory where the repository lives
+    # @return [String]
+    attr_reader :path
+
+    def_delegators :repo, :fetch
+
+    Contract String, String => Repository
+    # Initializes a repository.
+    #
+    # @param url [String] The url
+    # @param path [String] The path
+    #
+    # @return [Repository] The repository instance
+    def initialize(url, path)
+      @path = path
+      @url = url
+      self
+    end
+
+    Contract String => Dir
+    # Checks out the version and returns it's directory
+    #
+    # @param ref [String] The reference to checkout
+    #
+    # @return [Dir] The directory
+    def checkout(ref)
+      repo.checkout ref
+      directory
+    end
+
+    Contract None => Dir
+    # Returns the directory of the repository
+    #
+    # @return [Dir] The directory
+    def directory
+      # This removes the .git from filename
+      Dir.new(File.dirname(repo.repo.path))
+    end
+
+    Contract None => ArrayOf[Semverse::Version]
+    # Returns the versions of the repository
+    #
+    # @return [Array<Semverse::Version>] The versions
+    def versions
+      repo
+        .tags
+        .map(&:name)
+        .map { |tag| Semverse::Version.try_new tag }
+        .compact
+    end
+
+    Contract None => Git::Base
+    # Returns the existing repository or clones it if it does not exists.
+    #
+    # @return [Git::Base]
+    def repo
+      clone unless Dir.exist?(path)
+      @repo ||= Git.open path
+      @repo.reset_hard
+      @repo
+    end
+
+    Contract None => Git::Base
+    # Clones the repository
+    #
+    # @return [Git::Base]
+    def clone
+      Logger.arrow "Package: #{url.bold} not found in cache, cloning..."
+      FileUtils.mkdir_p path
+      @repo = Git.clone(url, path)
+    end
+  end
+end

data/lib/elm_install/resolver.rb

@@ -1,145 +1,75 @@
-require_relative './cache'
-require_relative './utils'
-
 module ElmInstall
-  # Resolves git dependencies into the cache.
-  class Resolver
-    # @return [Array] The constraints
-    attr_reader :constraints
-
-    # Initializes a resolver with a chace and git resolver.
-    #
-    # @param cache [Cache] The cache
-    # @param git_resolver [GitResolver] The git resolver
-    def initialize(cache, git_resolver)
-      @git_resolver = git_resolver
-      @constraints = []
-      @cache = cache
-    end
+  # Resolves dependencies
+  class Resolver < Base
+    # @return [Array<Dependency>] The dependencies
+    attr_reader :dependencies
 
-    # Add constraints, usually from the `elm-package.json`.
+    Contract Identifier => Resolver
+    # Initializes a resolver
     #
-    # @param constraints [Hash] The constraints
+    # @param identifier [Identifier] The identifier
     #
-    # @return [void]
-    def add_constraints(constraints)
-      @constraints = add_dependencies(constraints) do |package, constraint|
-        [package, constraint]
-      end
+    # @return [Resolver]
+    def initialize(identifier)
+      @graph = Solve::Graph.new
+      @identifier = identifier
+      @dependencies = {}
+      self
     end
 
-    # Adds dependencies, usually from any `elm-package.json` file.
-    #
-    # :reek:NestedIterators { max_allowed_nesting: 2 }
+    Contract None => Solve::Graph
+    # Resolves the constraints for a version
     #
-    # @param dependencies [Hash] The dependencies
-    #
-    # @yieldreturn [Array] A constraint
-    # @return [void]
-    def add_dependencies(dependencies)
-      dependencies.flat_map do |package, constraint|
-        add_package(package)
-
-        constraints = Utils.transform_constraint(constraint)
-        next add_ref_dependency(package, constraint) if constraints.empty?
-
-        constraints.map do |dependency|
-          yield package, dependency
-        end
+    # @return [Solve::Graph] Returns the graph
+    def resolve
+      @identifier.initial_dependencies.each do |dependency|
+        resolve_dependency dependency
       end
-    end
 
-    # Adds a dependency by git reference.
-    #
-    # @param package [String] The package
-    # @param ref [String] The reference
-    #
-    # @return [void]
-    def add_ref_dependency(package, ref)
-      @git_resolver.repository(package).checkout(ref)
-      pkg_version = elm_package(package)['version']
-      version = "#{pkg_version}+#{ref}"
-      @cache.ensure_version(package, version)
-      add_package_dependencies(package, version)
-      [[package, "= #{version}"]]
+      @graph
     end
 
-    # Adds a package to the cache, the following things happens:
-    # * If there is no local repository it will be cloned
-    # * Getting all the tags and adding the valid ones to the cache
-    # * Checking out and getting the `elm-package.json` for each version
-    #   and adding them recursivly
+    Contract Dependency => NilClass
+    # Resolves the dependencies of a dependency
     #
-    # @param package [String] The package
+    # @param dependency [Dependency] The dependency
     #
-    # @return [void]
-    def add_package(package)
-      return if @git_resolver.package?(package) && @cache.key?(package)
+    # @return nil
+    def resolve_dependency(dependency)
+      return if @dependencies[dependency.name]
+
+      @dependencies[dependency.name] ||= dependency
 
-      @git_resolver
-        .repository(package)
-        .tags
-        .map(&:name)
+      dependency
+        .source
+        .versions(dependency.constraints)
         .each do |version|
-          @cache.ensure_version(package, version)
-          add_version(package, version)
+          resolve_dependencies(dependency, version)
         end
-    end
 
-    # Adds a package's dependencies to the cache.
-    #
-    # @param package [String] The package
-    # @param version [String] The version
-    #
-    # @return [void]
-    def add_package_dependencies(package, version)
-      add_dependencies(elm_dependencies(package)) do |dep_package, constraint|
-        add_package(dep_package)
-        @cache.dependency(package, version, [dep_package, constraint])
-      end
+      nil
     end
 
-    # Adds a version and it's dependencies to the cache.
+    Contract Dependency, Semverse::Version => NilClass
+    # Resolves the dependencies of a dependency and version
     #
-    # @param package [String] The package
-    # @param version [String] The version
+    # @param main [Dependency] The dependency
+    # @param version [Semverse::Version] The version
     #
-    # @return [void]
-    def add_version(package, version)
-      @git_resolver
-        .repository(package)
-        .checkout(version)
-
-      add_package_dependencies(package, version)
-    end
+    # @return nil
+    def resolve_dependencies(main, version)
+      dependencies = @identifier.identify(main.source.fetch(version))
+      artifact = @graph.artifact main.name, version
 
-    # Gets the `elm-package.json` for a package.
-    #
-    # @param package [String] The package
-    #
-    # @return [Hash] The dependencies
-    def elm_dependencies(package)
-      ElmPackage.dependencies elm_package_path(package)
-    rescue
-      {}
-    end
+      dependencies.each do |dependency|
+        dependency.constraints.each do |constraint|
+          artifact.depends dependency.name, constraint
+        end
 
-    # Retruns the contents of the `elm-pacakge.json` of the given package.
-    #
-    # @param package [String] The package
-    #
-    # @return [Hash] The contents
-    def elm_package(package)
-      ElmPackage.read elm_package_path(package)
-    end
+        resolve_dependency dependency
+      end
 
-    # Retruns the path of the `elm-pacakge.json` of the given package.
-    #
-    # @param package [String] The package
-    #
-    # @return [String] The path
-    def elm_package_path(package)
-      File.join(@git_resolver.repository_path(package), 'elm-package.json')
+      nil
     end
   end
 end

data/lib/elm_install/source.rb

@@ -0,0 +1,18 @@
+module ElmInstall
+  # Abstract class for a source
+  class Source < Base
+    # @overload identifier
+    #   @return [Identifier] The identifier
+    # @overload identifier=(value)
+    #   Sets the identifier
+    #   @param [Identifier] The identifier
+    attr_accessor :identifier
+
+    # @overload options
+    #   @return [Hash] The options
+    # @overload options=(value)
+    #   Sets the options
+    #   @param [Hash] The options
+    attr_accessor :options
+  end
+end