minimart 0.0.1

data/lib/minimart/error.rb

@@ -0,0 +1,32 @@
+module Minimart
+  # The collection of Minimart specific errors.
+  module Error
+    class BaseError < StandardError; end
+
+    # Raised when a dependency cannot be met.
+    class UnresolvedDependency < BaseError; end
+
+    # Raised when there is an error parsing the inventory file.
+    class InvalidInventoryError < BaseError; end
+
+    # Raised when a source does not respond to '/universe' correctly.
+    class UniverseNotFoundError < BaseError; end
+
+    # Raised when none of the available sources have a given cookbook.
+    class CookbookNotFound < BaseError; end
+
+    # Raised when there is a conflict between different versions of the same cookbook.
+    class BrokenDependency < BaseError; end
+
+    # Raised when Minimart encounters a cookbook with a location type that it can't handle
+    class UnknownLocationType < BaseError; end
+
+    # Gracefully handle any errors raised by Minimart, and exit with a failure
+    # status code.
+    # @param [Minimart::Error::BaseError] ex
+    def self.handle_exception(ex)
+      Configuration.output.puts_red(ex.message)
+      exit false
+    end
+  end
+end

data/lib/minimart/inventory_requirement/base_requirement.rb

@@ -0,0 +1,81 @@
+module Minimart
+  module InventoryRequirement
+
+    # BaseRequirement represents a single cookbook entry as listed in the inventory.
+    # BaseRequirement is a generic interface for other inventory requirements.
+    class BaseRequirement
+
+      # @return [String] The name of the cookbook
+      attr_reader :name
+
+      # @return [String] The SemVer requirement for the cookbook
+      attr_reader :version_requirement
+
+      # @return [Minimart::Cookbook] The resolved cookbook
+      attr_reader :cookbook
+
+      # @param [String] name The name of the cookbook
+      # @param [Hash] opts
+      # @option opts [String] :version_requirement The SemVer requirement for the cookbook
+      def initialize(name, opts)
+        @name = name
+        @version_requirement = opts[:version_requirement]
+      end
+
+      # Determine whether or not this is a requirement which explicitly defines
+      # it's location (e.g. Git repo). Defaults to FALSE.
+      # @return [Boolean]
+      def explicit_location?
+        false
+      end
+
+      # The requirements to download this cookbook.
+      # @return [Hash]
+      def requirements
+        # if this cookbook has it's location specified, we instead return it's
+        # dependencies as we don't need to resolve them elsewhere
+        explicit_location? ? cookbook.dependencies : {name => version_requirement}
+      end
+
+      # Download a cookbook that has it's location explicitly defined (see #explicit_location?)
+      # @yield [Minimart::Cookbook]
+      def fetch_cookbook(&block)
+        return unless explicit_location?
+
+        download_cookbook do |cookbook|
+          @cookbook = cookbook
+          block.call(cookbook) if block
+        end
+      end
+
+      # Determine whether or not a version requirement was defined for the given
+      # cookbook.
+      # @return [Boolean]
+      def version_requirement?
+        !!version_requirement
+      end
+
+      # Convert the requirement to a Hash.
+      # @return [Hash]
+      def to_hash
+        {}
+      end
+
+      # Determine if a cookbook in the inventory has metadata matching this requirement
+      # @param [Minimart::Mirror::DownloadMetadata] metadata The download metadata for a cookbook
+      #   in the inventory.
+      # @return [Boolean] Defaults to true
+      def matching_source?(metadata)
+        return true
+      end
+
+      private
+
+      # This method must be overridden by any subclasses.
+      def download_cookbook(&block)
+        nil
+      end
+
+    end
+  end
+end

data/lib/minimart/inventory_requirement/git_requirement.rb

@@ -0,0 +1,87 @@
+require 'minimart/download/git_repository'
+
+module Minimart
+  module InventoryRequirement
+
+    # A single Git requirement for a cookbook as specified in the inventory.
+    # This represents a single brach, ref, or tag for a cookbook.
+    class GitRequirement < BaseRequirement
+
+      # @return [String] the location to fetch this cookbook from.
+      attr_reader :location
+
+      # @return [String] the branch to checkout once this cookbook has been fetched.
+      attr_reader :branch
+
+      # @return [String] the SHA of the Git commit to checkout once this cookbook has been fetched.
+      attr_reader :ref
+
+      # @return [String] the tag to checkout once this cookbook has been fetched
+      attr_reader :tag
+
+      # @param [String] name The name of the cookbook defined by this requirement.
+      # @param [Hash] opts
+      # @option opts [String] branch The branch to checkout once this cookbook has been fetched.
+      # @option opts [String] tag The tag to checkout once this cookbook has been fetched
+      # @option opts [String] ref The SHA of the Git commit to checkout once this cookbook has been fetched.
+      def initialize(name, opts)
+        super
+        @branch   = opts[:branch]
+        @ref      = opts[:ref]
+        @tag      = opts[:tag]
+        @location = opts[:location]
+      end
+
+      # Git requirements explicitly define their location, so this method will return true.
+      # @return [Boolean] TRUE
+      def explicit_location?
+        true
+      end
+
+      # Convert this requirement to a hash
+      # @return [Hash]
+      def to_hash
+        result = super
+        result[:source_type]    = :git
+        result[:location]       = location
+        result[:commitish_type] = commitish_type
+        result[:commitish]      = commitish
+        result
+      end
+
+      # Determine if a Git cookbook in the inventory has metadata matching this requirement.
+      # This method will return true if the metadata has the same commit information
+      # as this requirement.
+      # @param [Minimart::Mirror::DownloadMetadata] metadata The download metadata for a cookbook
+      #   in the inventory.
+      # @return [Boolean] Defaults to true
+      def matching_source?(metadata)
+        metadata['source_type'] == 'git' &&
+          metadata['commitish_type'] == commitish_type.to_s &&
+          (metadata['commitish_type'] == 'ref' ? true : metadata['commitish'] == commitish.to_s)
+      end
+
+      private
+
+      def download_cookbook(&block)
+        Configuration.output.puts "-- Fetching '#{name}[#{commitish}]' from '#{location}'"
+
+        downloader = Download::GitRepository.new(location)
+        downloader.fetch(commitish) do |path_to_cookbook|
+          block.call(Minimart::Cookbook.from_path(path_to_cookbook))
+        end
+      end
+
+      def commitish
+        ref || branch || tag
+      end
+
+      def commitish_type
+        return :ref if ref
+        return :branch if branch
+        return :tag if tag
+      end
+
+    end
+  end
+end

data/lib/minimart/inventory_requirement/git_requirements_builder.rb

@@ -0,0 +1,101 @@
+require 'minimart/inventory_requirement/git_requirement'
+
+module Minimart
+  module InventoryRequirement
+    # This class is used to parse any Git requirements specified in the inventory
+    # and build Minimart::Inventory::GitRequirements from them.
+    class GitRequirementsBuilder
+
+      # @return [String] the name of the cookbook defined by this requirement.
+      attr_reader :name
+
+      # @return [String] the location to fetch this cookbook from.
+      attr_reader :location
+
+      # @return [Array<String>] a listing of branches to checkout when fetching this cookbook.
+      attr_reader :branches
+
+      # @return [Array<String>] a listing of tags to checkout when fetching this cookbook.
+      attr_reader :tags
+
+      # @return [Array<String>] a listing of refs to checkout when fetching this cookbook.
+      attr_reader :refs
+
+      # @param [String] name The name of the cookbook defined by this requirement.
+      # @param [Hash] reqs
+      #   * 'git' [Hash] The git specific requirements for this cookbook
+      #     * 'branches' [Array<String>] A listing of branches to checkout when fetching this cookbook.
+      #     * 'branch' [String] A single branch to checkout when fetching this cookbook.
+      #     * 'tags' [Array<String>] A listing of tags to checkout when fetching this cookbook.
+      #     * 'tag' [String] A single tag to checkout when fetching this cookbook.
+      #     * 'refs' [Array<String>] A listing of ref to checkout when fetching this cookbook.
+      #     * 'ref' [String] A single ref to checkout when fetching this cookbook.
+      def initialize(name, reqs)
+        @name     = name
+        git_reqs  = reqs.fetch('git', {})
+
+        @location = git_reqs['location']
+        @branches = raw_location_type_requirement(%w[branches branch], git_reqs)
+        @tags     = raw_location_type_requirement(%w[tags tag], git_reqs)
+        @refs     = raw_location_type_requirement(%w[refs ref], git_reqs)
+
+        validate_requirements(git_reqs)
+      end
+
+      # Build the git requirements.
+      # @return [Array<Minimart::InventoryRequirement::GitRequirement>]
+      def build
+        from_branches + from_tags + from_refs
+      end
+
+      private
+
+      def from_branches
+        branches.map { |b| build_requirement(:branch, b) }
+      end
+
+      def from_tags
+        tags.map { |t| build_requirement(:tag, t) }
+      end
+
+      def from_refs
+        refs.map { |r| build_requirement(:ref, r) }
+      end
+
+      def build_requirement(type, value)
+        InventoryRequirement::GitRequirement.new(name, {type => value}.merge(location: location))
+      end
+
+      def raw_location_type_requirement(location_types, requirements)
+        location_types.inject([]) do |memo, type|
+          if requirements[type]
+            req = requirements[type]
+            req = [req] if req.is_a?(String)
+            memo.concat(req)
+          end
+          memo
+        end
+      end
+
+      def validate_requirements(reqs)
+        return if reqs.nil? || reqs.empty?
+
+        validate_location
+        validate_commitish
+      end
+
+      def validate_location
+        return unless location.nil? || location.empty?
+        raise Minimart::Error::InvalidInventoryError,
+          "'#{name}' specifies Git requirements, but does not have a location."
+      end
+
+      def validate_commitish
+        return unless branches.empty? && tags.empty? && refs.empty?
+        raise Minimart::Error::InvalidInventoryError,
+          "'#{name}' specified Git requirements, but does not provide a branch|tag|ref"
+      end
+
+    end
+  end
+end

data/lib/minimart/inventory_requirement/local_path_requirement.rb

@@ -0,0 +1,45 @@
+module Minimart
+  module InventoryRequirement
+
+    # A requirement to a cookbook found in the local file system
+    class LocalPathRequirement < BaseRequirement
+
+      # @return [String] the path to the cookbook
+      attr_reader :path
+
+      # @param [String] name The name of the cookbook
+      # @param [Hash] opts
+      # @option opts [String] path The path to the cookbook
+      def initialize(name, opts)
+        super
+        @path = opts[:path]
+      end
+
+      # Local path requirements explicitly define their location, so this method will return true.
+      # @return [Boolean] TRUE
+      def explicit_location?
+        true
+      end
+
+      # Convert this requirement to a hash
+      # @return [Hash]
+      def to_hash
+        result = super
+        result[:source_type] = :local_path
+        result
+      end
+
+      def matching_source?(metadata)
+        metadata['source_type'] == 'local_path'
+      end
+
+      private
+
+      def download_cookbook(&block)
+        Configuration.output.puts "-- Fetching '#{name}' from path '#{path}'"
+        block.call(Minimart::Cookbook.from_path(path))
+      end
+
+    end
+  end
+end

data/lib/minimart/inventory_requirement/local_requirements_builder.rb

@@ -0,0 +1,31 @@
+require 'minimart/inventory_requirement/local_path_requirement'
+
+module Minimart
+  module InventoryRequirement
+    # This class is used to parse any local path requirements specified in the inventory
+    # and build Minimart::Inventory::LocalPathRequirements from them.
+    class LocalRequirementsBuilder
+
+      # @return [String] the name of the cookbook defined by this requirement.
+      attr_reader :name
+
+      # @return [String] the path to the cookbook
+      attr_reader :path
+
+      # @param [String] name The name of the cookbook defined by this requirement.
+      # @param [Hash] reqs
+      # @option reqs [String] 'path' The path to the cookbook
+      def initialize(name, reqs)
+        @name = name
+        @path = reqs['path']
+      end
+
+      # Build the local path requirements.
+      # @return [Array<Minimart::InventoryRequirement::LocalPathRequirement>]
+      def build
+        return [] if path.nil? || path.empty?
+        [InventoryRequirement::LocalPathRequirement.new(name, path: path)]
+      end
+    end
+  end
+end

data/lib/minimart/inventory_requirement/supermarket_requirements_builder.rb

@@ -0,0 +1,35 @@
+require 'minimart/inventory_requirement/base_requirement'
+
+module Minimart
+  module InventoryRequirement
+
+    # This class is used to parse any Supermarket requirements specified in the inventory
+    # and build Minimart::Inventory::BaseRequirements from them.
+    class SupermarketRequirementsBuilder
+
+      # @return [String] the name of the cookbook
+      attr_reader :name
+
+      # @return [Array<String>] an array of versions to fetch for this cookbook
+      attr_reader :versions
+
+      # @param [String] name The name of the cookbook
+      # @param [Hash] reqs
+      #   * 'versions' [Array<String>] A listing of versions to fetch.
+      #   * 'version' [String] A single version to fetch.
+      def initialize(name, reqs)
+        @name     = name
+        @versions = reqs['versions'] || reqs['version'] || []
+        @versions = [@versions] if @versions.is_a? String
+      end
+
+      # Build the Supemarket requirements.
+      # @return [Array<Minimart::InventoryRequirement::BaseRequirement>]
+      def build
+        versions.map do |v|
+          InventoryRequirement::BaseRequirement.new(name, version_requirement: v)
+        end
+      end
+    end
+  end
+end

data/lib/minimart/mirror.rb

@@ -0,0 +1,12 @@
+module Minimart
+  # The Mirror namespace is used to build the local cookbook inventory.
+  module Mirror
+    require 'minimart/mirror/dependency_graph'
+    require 'minimart/mirror/inventory_builder'
+    require 'minimart/mirror/inventory_configuration'
+    require 'minimart/mirror/local_store'
+    require 'minimart/mirror/source_cookbook'
+    require 'minimart/mirror/source'
+    require 'minimart/mirror/sources'
+  end
+end

data/lib/minimart/mirror/dependency_graph.rb

@@ -0,0 +1,73 @@
+require 'solve'
+
+module Minimart
+  module Mirror
+
+    # A dependency graph for managing any remote cookbooks and their dependencies.
+    # This can be used to resolve any requirements found in the inventory file.
+    class DependencyGraph
+
+
+      attr_reader :graph
+      attr_reader :inventory_requirements
+
+      def initialize
+        @graph = Solve::Graph.new
+        @inventory_requirements = []
+      end
+
+      # Add an artifact (cookbook), and its dependencies to the graph.
+      # @param [Minimart::Mirror::SourceCookbook] cookbook
+      def add_artifact(cookbook)
+        return if source_cookbook_added?(cookbook.name, cookbook.version)
+
+        graph.artifact(cookbook.name, cookbook.version).tap do |artifact|
+          cookbook.dependencies.each do |dependency|
+            name, requirements = dependency
+            artifact.depends(name, requirements)
+          end
+        end
+      end
+
+      # Determine whether or not the graph has a given cookbook.
+      # @param [String]  name The name of the cookbook
+      # @param [String]  version The version of the cookbook
+      # @return [Boolean]
+      def source_cookbook_added?(name, version)
+        graph.artifact?(name, version)
+      end
+
+      # Get a cookbook out of the graph.
+      # @param [Minimart::Mirror::SourceCookbook] cookbook The cookbook to fetch.
+      # @return [Solve::Artifact]
+      def find_graph_artifact(cookbook)
+        graph.find(cookbook.name, cookbook.version)
+      end
+
+      # Add a new requirement to be resolved by the graph
+      # @param [Hash] requirements (ex. { 'minimart' => '> 0.0.1' })
+      def add_requirement(requirements = {})
+        inventory_requirements.concat(requirements.to_a)
+      end
+
+      # Resolve any requirements against the graph
+      # @return [Array] The requirements as resolved by the graph (ex. [['minimart', '0.0.5']])
+      # @raise [Minimart::Error::UnresolvedDependency] Raised when a dependency cannot be resolved
+      def resolved_requirements
+        inventory_requirements.inject([]) do |result, requirement|
+          result.concat(resolve_requirement(requirement).to_a)
+        end
+      end
+
+      private
+
+      def resolve_requirement(requirement)
+        Solve.it!(graph, [requirement])
+
+      rescue Solve::Errors::NoSolutionError => e
+        raise Error::UnresolvedDependency, e.message
+      end
+
+    end
+  end
+end