git_compound 0.0.9

data/lib/git_compound/component/destination.rb

@@ -0,0 +1,45 @@
+require 'pathname'
+
+module GitCompound
+  class Component
+    # Component destination
+    #
+    class Destination
+      attr_reader :path
+
+      def initialize(path, component)
+        raise CompoundSyntaxError, 'Destination cannot be empty' if
+          path.nil? || path.empty?
+
+        raise CompoundSyntaxError,
+              'Destination should contain at least one directory' unless
+          Pathname.new(path).each_filename.count > 0
+
+        @path      = path
+        @component = component
+      end
+
+      def expanded_path
+        pathname = Pathname.new(@path)
+
+        unless pathname.absolute?
+          ancestor_paths = @component.ancestors.map(&:destination_path)
+          pathname = Pathname.new('.').join(*ancestor_paths) + pathname
+        end
+
+        Pathname.new("./#{pathname}").cleanpath.to_s + '/'
+      end
+
+      def exists?
+        FileTest.exist?(expanded_path)
+      end
+
+      def repository
+        destination_repository =
+          Repository::RepositoryLocal.new(expanded_path)
+        yield destination_repository if block_given?
+        destination_repository
+      end
+    end
+  end
+end

data/lib/git_compound/component/source.rb

@@ -0,0 +1,53 @@
+require 'forwardable'
+
+module GitCompound
+  class Component
+    # Component source
+    #
+    class Source
+      extend Forwardable
+      delegate [:sha, :ref] => :@version
+      attr_reader :origin, :repository, :version, :options
+
+      def initialize(origin, version, strategy, options, component)
+        raise CompoundSyntaxError, 'Source cannot be empty' if
+          origin.nil? || origin.empty?
+
+        @origin     = origin
+        @strategy   = strategy
+        @options    = options
+        @component  = component
+        @repository = Repository.factory(@origin)
+        @version    = strategy.new(@repository, version)
+      end
+
+      # Loads manifest from source repository
+      #
+      def manifest
+        raise DependencyError,
+              "Version #{@version} unreachable" unless @version.reachable?
+
+        contents = @repository.files_contents(Manifest::FILENAMES, @version.ref)
+        Manifest.new(contents, @component)
+      rescue FileNotFoundError
+        Manifest.new(nil, @component)
+      end
+
+      def clone(destination)
+        @repository.clone(destination, clone_args)
+      end
+
+      private
+
+      def clone_args
+        raise CompoundSyntaxError,
+              '`shallow` keyword not available for sha version strategy' if
+          @options.include?(:shallow) && @strategy == Component::Version::SHA
+
+        opts = []
+        opts << "--branch '#{@version.ref}' --depth 1" if @options.include? :shallow
+        opts.join(' ')
+      end
+    end
+  end
+end

data/lib/git_compound/component/version/branch.rb

@@ -0,0 +1,30 @@
+module GitCompound
+  class Component
+    module Version
+      # Component version indicated by branch (head of branch)
+      #
+      class Branch < VersionStrategy
+        def initialize(repository, branch)
+          @repository = repository
+          @branch     = branch
+        end
+
+        def ref
+          @branch
+        end
+
+        def sha
+          @repository.branches[@branch]
+        end
+
+        def reachable?
+          @repository.branches.key?(@branch)
+        end
+
+        def to_s
+          "branch: #{@branch}"
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/component/version/gem_version.rb

@@ -0,0 +1,45 @@
+module GitCompound
+  class Component
+    module Version
+      # Component Gem-like version
+      #
+      class GemVersion < VersionStrategy
+        attr_reader :requirement
+
+        def initialize(repository, requirement)
+          raise CompoundSyntaxError, 'Malformed version requirement string' unless
+            requirement =~ Gem::Requirement::PATTERN
+
+          @repository  = repository
+          @requirement = requirement
+        end
+
+        def lastest_version
+          matches.first
+        end
+
+        def ref
+          lastest_version.tag
+        end
+
+        def sha
+          lastest_version.sha
+        end
+
+        def matches
+          versions = @repository.versions
+          versions.select! { |version| version.matches?(@requirement) }
+          versions.sort.reverse
+        end
+
+        def reachable?
+          matches.any?
+        end
+
+        def to_s
+          "gem version: #{@requirement}"
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/component/version/sha.rb

@@ -0,0 +1,33 @@
+module GitCompound
+  class Component
+    module Version
+      # Component version indicated by SHA hash
+      #
+      class SHA < VersionStrategy
+        def initialize(repository, sha)
+          @repository = repository
+          @sha = sha
+        end
+
+        def ref
+          @sha
+        end
+
+        def sha # rubocop:disable Style/TrivialAccessors
+          @sha
+        end
+
+        def reachable?
+          # We assume that SHA is always available as we do not want
+          # to clone repository and check it -- this probably needs
+          # to be changed, so -- TODO
+          true
+        end
+
+        def to_s
+          "sha: #{@sha[0..7]}"
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/component/version/tag.rb

@@ -0,0 +1,30 @@
+module GitCompound
+  class Component
+    module Version
+      # Component version as tag
+      #
+      class Tag < VersionStrategy
+        def initialize(repository, tag)
+          @repository = repository
+          @tag        = tag
+        end
+
+        def ref
+          @tag
+        end
+
+        def sha
+          @repository.tags[@tag]
+        end
+
+        def reachable?
+          @repository.tags.key?(@tag)
+        end
+
+        def to_s
+          "tag: #{@tag}"
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/component/version/version_strategy.rb

@@ -0,0 +1,45 @@
+module GitCompound
+  class Component
+    module Version
+      # Abstraction for component versions like
+      #   gem version, sha and branch
+      #
+      class VersionStrategy
+        def initialize
+          raise NotImplementedError
+        end
+
+        # Should return git reference (ex branch, tag or sha)
+        # This should not raise exception if unreachable
+        #
+        def ref
+          raise NotImplementedError
+        end
+
+        # Should return sha for specified reference
+        #   (ex tagged commit sha or head of specified branch)
+        #
+        def sha
+          raise NotImplementedError
+        end
+
+        # Should return true if this reference in source repository
+        #   is reachable
+        #
+        def reachable?
+          raise NotImplementedError
+        end
+
+        # String representation of this version strategy
+        #
+        def to_s
+          raise NotImplementedError
+        end
+
+        def ==(other)
+          to_s == other.to_s
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/component.rb

@@ -0,0 +1,78 @@
+require 'forwardable'
+require 'fileutils'
+
+module GitCompound
+  # Component
+  #
+  class Component < Node
+    extend Forwardable
+
+    attr_reader :name
+    attr_accessor :source, :destination
+
+    def initialize(name, parent = nil, &block)
+      @name   = name
+      @parent = parent
+      DSL::ComponentDSL.new(self, &block) if block
+      raise CompoundSyntaxError, "No block given for component `#{@name}`" unless block
+      raise GitCompoundError, "Component `#{@name}` invalid" unless valid?
+    end
+
+    def valid?
+      [@name, @source, @destination].all?
+    end
+
+    def process(*workers)
+      workers.each { |worker| worker.visit_component(self) }
+      @manifest.process(*workers) if manifest
+    end
+
+    def manifest
+      @manifest ||= @source.manifest
+    end
+
+    def build
+      @source.clone(destination_path)
+      @destination.repository do |repo|
+        repo.checkout(@source.ref)
+      end
+    end
+
+    def update
+      @destination.repository do |repo|
+        repo.fetch
+        repo.checkout(@source.ref)
+        repo.merge
+      end
+    end
+
+    def remove!
+      path = destination_path
+      raise GitCompoundError, 'Risky directory !' if
+        path.start_with?('/') || path.include?('..')
+      raise GitCompoundError, 'Not a directory !' unless
+        File.directory?(path)
+
+      FileUtils.remove_entry_secure(path)
+    end
+
+    def ==(other)
+      origin == other.origin || manifest == other.manifest
+    end
+
+    def to_hash
+      { name: @name,
+        sha:  @source.sha,
+        source: @source.origin,
+        destination: @destination.expanded_path
+      }
+    end
+
+    # delegators
+
+    delegate [:sha, :origin, :repository, :version] => :@source
+    def_delegator :@destination, :expanded_path, :destination_path
+    def_delegator :@destination, :exists?,       :destination_exists?
+    def_delegator :@destination, :repository,    :destination_repository
+  end
+end

data/lib/git_compound/dsl/component_dsl.rb

@@ -0,0 +1,60 @@
+module GitCompound
+  # Compound Domain Specific Language
+  #
+  module DSL
+    # DSL for Component
+    #
+    class ComponentDSL
+      def initialize(component, &block)
+        @component = component
+        instance_eval(&block)
+      end
+
+      # Custom version strategy, also available via DSL
+      #
+      def version_strategy(version, strategy)
+        raise CompoundSyntaxError,
+              'Version strategy already set !' if @version_strategy
+
+        @version = version
+        @version_strategy = strategy
+      end
+
+      def version(component_version)
+        version_strategy(component_version, Component::Version::GemVersion)
+      end
+
+      def branch(component_branch)
+        version_strategy(component_branch, Component::Version::Branch)
+      end
+
+      def tag(component_tag)
+        version_strategy(component_tag, Component::Version::Tag)
+      end
+
+      def sha(component_sha)
+        raise CompoundSyntaxError, 'Invalid SHA1 format' unless
+          component_sha.match(/[0-9a-f]{5,40}/)
+
+        version_strategy(component_sha, Component::Version::SHA)
+      end
+
+      def source(component_source, *source_options)
+        raise CompoundSyntaxError,
+              'Version/branch/tag/sha needed first' unless @version
+
+        @component.source =
+          Component::Source.new(component_source,
+                                @version,
+                                @version_strategy,
+                                source_options,
+                                @component)
+      end
+
+      def destination(component_path)
+        @component.destination =
+          Component::Destination.new(component_path, @component)
+      end
+    end
+  end
+end

data/lib/git_compound/dsl/manifest_dsl.rb

@@ -0,0 +1,27 @@
+module GitCompound
+  # Compound Domain Specific Language
+  #
+  module DSL
+    # DSL for Manifest
+    #
+    class ManifestDSL
+      def initialize(manifest, contents)
+        @manifest = manifest
+        instance_eval(contents)
+      end
+
+      def name(component_name)
+        @manifest.name = component_name.to_sym
+      end
+
+      def component(name, &block)
+        @manifest.components.store(name.to_sym, Component.new(name, @manifest, &block))
+      end
+
+      def task(name, type = nil, &block)
+        new_task = Task.factory(name, type, @manifest, &block)
+        @manifest.tasks.store(name.to_sym, new_task) if new_task
+      end
+    end
+  end
+end

data/lib/git_compound/exceptions.rb

@@ -0,0 +1,16 @@
+module GitCompound
+  class GitCompoundError < StandardError; end
+
+  class CompoundLoadError < GitCompoundError; end
+  class CompoundSyntaxError < GitCompoundError; end
+  class FileNotFoundError < GitCompoundError; end
+  class FileUnreachableError < GitCompoundError; end
+  class RepositoryUnreachableError < GitCompoundError; end
+  class GitCommandError < GitCompoundError; end
+  class LocalRepositoryNotFoundError < GitCompoundError; end
+  class DependencyError < GitCompoundError; end
+  class CircularDependencyError < GitCompoundError; end
+  class ConflictingDependencyError < GitCompoundError; end
+  class NameConstraintError < GitCompoundError; end
+  class LocalChangesError < GitCompoundError; end
+end

data/lib/git_compound/lock.rb

@@ -0,0 +1,64 @@
+require 'yaml'
+
+module GitCompound
+  # Class that represents lock file
+  #
+  class Lock
+    FILENAME = '.gitcompound.lock'
+
+    def self.exist?
+      File.exist?(FILENAME)
+    end
+
+    def initialize(file = FILENAME)
+      @file   = file
+      @locked = YAML.load(File.read(file)) if File.exist?(file)
+      clean unless @locked.is_a? Hash
+    end
+
+    def clean
+      @locked = { manifest: '', components: [] }
+      self
+    end
+
+    def lock_manifest(manifest)
+      @locked[:manifest] = manifest.md5sum
+    end
+
+    def lock_component(component)
+      @locked[:components] << component.to_hash
+    end
+
+    def manifest
+      @locked[:manifest]
+    end
+
+    def components
+      @locked[:components].to_a.map do |locked|
+        Component.new(locked[:name].to_sym) do
+          sha locked[:sha]
+          source locked[:source]
+          destination locked[:destination]
+        end
+      end
+    end
+
+    def contents
+      @locked
+    end
+
+    def find(component)
+      components.find do |locked_component|
+        locked_component.destination_path == component.destination_path
+      end
+    end
+
+    def process(worker)
+      components.each { |component| worker.visit_component(component) }
+    end
+
+    def write
+      File.open(@file, 'w') { |f| f.puts @locked.to_yaml }
+    end
+  end
+end

data/lib/git_compound/logger/colors.rb

@@ -0,0 +1,123 @@
+module GitCompound
+  module Logger
+    # Colors module
+    #
+    module Colors
+      def self.included(parent_class)
+        parent_class.extend ClassMethods
+        parent_class.class_eval { create_color_methods }
+      end
+
+      def colorize(params)
+        return self if colors_unavailable?
+        scan_colors.inject('') do |str, match|
+          set_colors(match, params)
+          str << "\033[#{match[0]};#{match[1]};#{match[2]}m#{match[3]}\033[0m"
+        end
+      end
+
+      private
+
+      def colors_unavailable?
+        self.class.disable_colors || RUBY_VERSION < '2.0.0' || RUBY_PLATFORM =~ /win32/
+      end
+
+      def scan_colors
+        scan(/\033\[([0-9;]+)m(.+?)\033\[0m|([^\033]+)/m).map do |match|
+          colors = (match[0] || '').split(';')
+          Array.new(4).tap do |array|
+            array[0], array[1], array[2] = colors if colors.length == 3
+            array[3] = match[1] || match[2]
+          end
+        end
+      end
+
+      def set_colors(match, params)
+        default_colors(match)
+
+        mode = mode(params[:mode])
+        color = color(params[:color])
+        bgcolor = bgcolor(params[:bgcolor])
+
+        match[0] = mode    if mode
+        match[1] = color   if color
+        match[2] = bgcolor if bgcolor
+      end
+
+      def default_colors(match)
+        match[0] ||= mode(:default)
+        match[1] ||= color(:default)
+        match[2] ||= bgcolor(:default)
+      end
+
+      def color(color)
+        self.class.colors[color] + 30 if self.class.colors[color]
+      end
+
+      def bgcolor(color)
+        self.class.colors[color] + 40 if self.class.colors[color]
+      end
+
+      def mode(mode)
+        self.class.modes[mode] if self.class.modes[mode]
+      end
+    end
+
+    # Class methods core ext for String
+    #
+    module ClassMethods
+      def disable_colors=(value)
+        @disable_colors = value && true
+      end
+
+      def disable_colors
+        @disable_colors ||= false
+      end
+
+      def colors
+        {
+          black:   0,
+          red:     1,
+          green:   2,
+          yellow:  3,
+          blue:    4,
+          magenta: 5,
+          cyan:    6,
+          white:   7,
+          default: 9
+        }
+      end
+
+      def modes
+        {
+          default: 0,
+          bold:    1
+        }
+      end
+
+      private
+
+      def create_color_methods
+        colors.keys.each do |key|
+          next if key == :default
+
+          define_method key do
+            colorize(color: key)
+          end
+
+          define_method "on_#{key}" do
+            colorize(bgcolor: key)
+          end
+        end
+
+        modes.keys.each do |key|
+          next if key == :default
+
+          define_method key do
+            colorize(mode: key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/logger/core_ext/string.rb

@@ -0,0 +1,5 @@
+# rubocop:disable Style/Documentation
+class String
+  include GitCompound::Logger::Colors
+end
+# rubocop:enable Style/Documentation

data/lib/git_compound/logger.rb

@@ -0,0 +1,43 @@
+module GitCompound
+  # Logger class
+  #
+  module Logger
+    extend self
+
+    def verbose=(value)
+      @verbose = value && true
+    end
+
+    def verbose
+      @verbose ||= false
+    end
+
+    def inline(inline_message)
+      print inline_message
+      inline_message
+    end
+
+    def debug(debug_message, *params)
+      log(debug_message.cyan, *params) if verbose
+    end
+
+    def info(information_message, *params)
+      log(information_message, *params)
+    end
+
+    def warn(warning_message, *params)
+      log(warning_message.red.bold, *params)
+    end
+
+    def error(error_message, *params)
+      log(error_message.on_red.white.bold, *params)
+    end
+
+    private
+
+    def log(message, *params)
+      puts message unless params.include?(:quiet)
+      message
+    end
+  end
+end