git_compound 0.0.9

data/lib/git_compound/manifest.rb

@@ -0,0 +1,39 @@
+require 'digest'
+
+module GitCompound
+  # Manifest
+  #
+  class Manifest < Node
+    attr_accessor :name, :components, :tasks
+
+    FILENAMES = %w(Compoundfile .gitcompound)
+
+    def initialize(contents, parent = nil)
+      @contents   = contents
+      @parent     = parent
+      @name       = ''
+      @components = {}
+      @tasks      = {}
+      DSL::ManifestDSL.new(self, contents) if contents
+    end
+
+    def process(*workers)
+      workers.each { |worker| worker.visit_manifest(self) }
+      components.each_value { |component| component.process(*workers) }
+      tasks.each_value { |task| workers.each { |worker| worker.visit_task(task) } }
+    end
+
+    def ==(other)
+      return false unless other.instance_of? Manifest
+      md5sum == other.md5sum
+    end
+
+    def exists?
+      @contents ? true : false
+    end
+
+    def md5sum
+      Digest::MD5.hexdigest(@contents) if exists?
+    end
+  end
+end

data/lib/git_compound/node.rb

@@ -0,0 +1,17 @@
+module GitCompound
+  # Abstract node class
+  #
+  class Node
+    attr_reader :parent
+
+    def process(*_workers)
+      raise NotImplementedError
+    end
+
+    def ancestors
+      return [] if @parent.nil? || @parent.parent.nil?
+      ancestor = @parent.parent
+      ancestor.ancestors.dup << ancestor
+    end
+  end
+end

data/lib/git_compound/repository/git_command.rb

@@ -0,0 +1,33 @@
+require 'English'
+
+module GitCompound
+  module Repository
+    # Execute git command
+    #
+    class GitCommand
+      attr_reader :output, :status, :command
+
+      def initialize(cmd, args, workdir = nil)
+        @command = "git #{cmd} #{args} 2>&1"
+        @workdir = workdir
+      end
+
+      def execute!
+        path = @workdir ? @workdir : Dir.pwd
+        Dir.chdir(path) { @output = `#{@command}` }
+        @status = $CHILD_STATUS.exitstatus
+        @output.sub!(/\n\Z/, '')
+      end
+
+      def execute
+        execute!
+        raise GitCommandError, @output unless valid?
+        @output
+      end
+
+      def valid?
+        @status == 0
+      end
+    end
+  end
+end

data/lib/git_compound/repository/git_repository.rb

@@ -0,0 +1,79 @@
+module GitCompound
+  module Repository
+    # Git repository base class
+    #
+    class GitRepository
+      def initialize(source)
+        @source = source
+      end
+
+      def clone(destination, options = nil, source = @source)
+        args = "#{source} #{destination}"
+        args.prepend(options + ' ') if options
+        GitCommand.new(:clone, args).execute
+      end
+
+      def versions
+        git_versions = tags.map { |tag, sha| GitVersion.new(tag, sha) }
+        git_versions.select(&:valid?)
+      end
+
+      def refs
+        @refs ||= GitCommand.new('ls-remote', @source).execute
+        @refs.scan(%r{^(\b[0-9a-f]{5,40}\b)\srefs\/(heads|tags)\/(.+)})
+      rescue GitCommandError => e
+        raise RepositoryUnreachableError, "Could not reach repository: #{e.message}"
+      end
+
+      def branches
+        refs_select('heads')
+      end
+
+      def tags
+        all = refs_select('tags')
+        annotated = all.select { |tag, _| tag =~ /\^\{\}$/ }
+        annotated.each_pair do |annotated_tag, annotated_tag_sha|
+          tag = annotated_tag.sub(/\^\{\}$/, '')
+          all.delete(annotated_tag)
+          all[tag] = annotated_tag_sha
+        end
+        all
+      end
+
+      def ref_exists?(ref)
+        matching = refs.select { |refs_a| refs_a.include?(ref.to_s) }
+        matching.any?
+      end
+
+      # Returns contents of first file found
+      #
+      def files_contents(files, ref)
+        files.each do |file|
+          begin
+            return file_contents(file, ref)
+          rescue FileNotFoundError
+            next
+          end
+        end
+        raise FileNotFoundError,
+              "Couldn't find any of #{files} files"
+      end
+
+      def file_contents(_file, _ref)
+        raise NotImplementedError
+      end
+
+      def file_exists?(_file, _ref)
+        raise NotImplementedError
+      end
+
+      private
+
+      def refs_select(name)
+        selected_refs = refs.select { |ref| ref[1] == name }
+        selected_refs.collect! { |r| [r.last, r.first] }
+        Hash[selected_refs]
+      end
+    end
+  end
+end

data/lib/git_compound/repository/git_version.rb

@@ -0,0 +1,43 @@
+module GitCompound
+  module Repository
+    # GitVersion represents tagged version inside Git repository
+    #
+    class GitVersion
+      attr_reader :tag, :sha, :version
+
+      def initialize(tag, sha)
+        @tag = tag
+        @sha = sha
+        @version = tag.sub(/^v/, '')
+      end
+
+      def to_gem_version
+        Gem::Version.new(@version)
+      end
+
+      def valid?
+        @tag.match(/^v?#{Gem::Version::VERSION_PATTERN}$/)
+      end
+
+      def matches?(requirement)
+        dependency = Gem::Dependency.new('component', requirement)
+        dependency.match?('component', to_gem_version, true)
+      end
+
+      def <=>(other)
+        to_gem_version <=> other.to_gem_version
+      end
+
+      def ==(other)
+        case other
+        when String
+          version == other
+        when GitVersion
+          version == other.version
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/repository/remote_file/git_archive_strategy.rb

@@ -0,0 +1,30 @@
+module GitCompound
+  module Repository
+    class RemoteFile
+      # Git archive strategy
+      #
+      class GitArchiveStrategy < RemoteFileStrategy
+        def initialize(source, ref, file)
+          super
+          opts = "--format=tar --remote=#{@source} #{@ref} -- #{@file} | tar -O -xf -"
+          @command = GitCommand.new(:archive, opts)
+          @command.execute!
+        end
+
+        def contents
+          raise FileUnreachableError unless reachable?
+          raise FileNotFoundError unless exists?
+          @command.output
+        end
+
+        def reachable?
+          @command.valid? || @command.output.include?('did not match any files')
+        end
+
+        def exists?
+          @command.valid?
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/repository/remote_file/github_strategy.rb

@@ -0,0 +1,54 @@
+require 'net/http'
+require 'uri'
+
+module GitCompound
+  module Repository
+    class RemoteFile
+      # Git archive strategy
+      #
+      class GithubStrategy < RemoteFileStrategy
+        GITHUB_URI     = 'https://raw.githubusercontent.com'
+        GITHUB_PATTERN = 'git@github.com:|https:\/\/github.com'
+
+        def initialize(source, ref, file)
+          super
+          @uri = github_uri
+        end
+
+        def contents
+          raise FileUnreachableError unless reachable?
+          raise FileNotFoundError unless exists?
+          @response.body
+        end
+
+        def reachable?
+          @source.match(/#{GITHUB_PATTERN}/) ? true : false
+        end
+
+        def exists?
+          @response ||= http_response(@uri)
+          @response.code == 200.to_s
+        end
+
+        private
+
+        def github_uri
+          github_location = @source.sub(/^#{GITHUB_PATTERN}/, '')
+          github_location.gsub!(%r{^/|/$}, '')
+          file_uri = "#{GITHUB_URI}/#{github_location}/#{@ref}/#{@file}"
+          URI.parse(file_uri)
+        end
+
+        def http_response(uri)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.open_timeout = 4
+          http.read_timeout = 4
+          params = { 'User-Agent' => 'git_compound' }
+          req = Net::HTTP::Get.new(uri.request_uri, params)
+          http.request(req)
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/repository/remote_file/remote_file_strategy.rb

@@ -0,0 +1,27 @@
+module GitCompound
+  module Repository
+    class RemoteFile
+      # Base interface for strategies
+      #
+      class RemoteFileStrategy
+        def initialize(source, ref, file)
+          @source = source
+          @ref    = ref
+          @file   = file
+        end
+
+        def contents
+          raise NotImplementedError
+        end
+
+        def reachable?
+          raise NotImplementedError
+        end
+
+        def exists?
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/repository/remote_file.rb

@@ -0,0 +1,34 @@
+module GitCompound
+  module Repository
+    # Remote file loader based on strategies
+    #
+    class RemoteFile
+      def initialize(source, ref, file, strategies = nil)
+        @source     = source
+        @ref        = ref
+        @file       = file
+        @strategies = strategies
+      end
+
+      def contents
+        @strategies ||= strategies_available
+        @strategies.each do |remote_file_strategy|
+          remote_file = remote_file_strategy.new(@source, @ref, @file)
+          next unless remote_file.reachable?
+          return remote_file.contents
+        end
+        raise FileUnreachableError,
+              "Couldn't reach file #{@file} after trying #{@strategies.count} stategies"
+      end
+
+      def strategies_available
+        # Strategies ordered by #reachable? method overhead
+        # More general strategies should be placed at lower positions,
+        # but this also depends on #reachable? overhead.
+        #
+        [GithubStrategy,
+         GitArchiveStrategy]
+      end
+    end
+  end
+end

data/lib/git_compound/repository/repository_local.rb

@@ -0,0 +1,81 @@
+module GitCompound
+  module Repository
+    # Local git repository implementation
+    #
+    class RepositoryLocal < GitRepository
+      def initialize(source)
+        super
+        raise RepositoryUnreachableError unless
+        File.directory?("#{@source}/.git")
+      end
+
+      def clone(destination, options = nil)
+        # Prefer ^file:/// instead of ^/ as latter does not work with --depth
+        source = @source.sub(%r{^\/}, 'file:///')
+        super(destination, options, source)
+      end
+
+      def checkout(ref)
+        GitCommand.new(:checkout, ref, @source).execute
+      end
+
+      def fetch
+        GitCommand.new(:fetch, '', @source).execute
+        GitCommand.new(:fetch, '--tags', @source).execute
+      end
+
+      def merge(mergeable = 'FETCH_HEAD')
+        GitCommand.new(:merge, mergeable, @source).execute
+      end
+
+      def file_exists?(file, ref)
+        cmd = GitCommand.new(:show, "#{ref}:#{file}", @source)
+        cmd.execute!
+        cmd.valid?
+      end
+
+      def file_contents(file, ref)
+        raise FileNotFoundError unless file_exists?(file, ref)
+        GitCommand.new(:show, "#{ref}:#{file}", @source).execute
+      end
+
+      def origin_remote
+        origin = GitCommand.new(:remote, '-v', @source).execute.match(/origin\t(.*?)\s/)
+        origin.captures.first if origin
+      end
+
+      def untracked_files?(exclude = nil)
+        untracked =
+          GitCommand.new('ls-files', '--exclude-standard --others', @source).execute
+        return (untracked.length > 0) unless exclude
+
+        untracked = untracked.split("\n")
+        untracked.delete_if do |file|
+          exclude.include?(file) || exclude.include?(file.split(File::SEPARATOR).first)
+        end
+
+        untracked.any?
+      end
+
+      def uncommited_changes?
+        GitCommand.new('update-index', '-q --refresh', @source).execute
+        unstaged = GitCommand.new('diff-files', '--quiet', @source)
+        uncommited = GitCommand.new('diff-index', '--cached --quiet HEAD', @source)
+
+        [unstaged, uncommited].any? do |cmd|
+          cmd.execute!
+          !cmd.valid?
+        end
+      end
+
+      def unpushed_commits?
+        unpushed = GitCommand.new('rev-list', '@{u}..', @source)
+        unpushed.execute.length > 0
+      end
+
+      def head_sha
+        GitCommand.new('rev-parse', 'HEAD', @source).execute
+      end
+    end
+  end
+end

data/lib/git_compound/repository/repository_remote.rb

@@ -0,0 +1,12 @@
+module GitCompound
+  module Repository
+    # Remote git repository implementation
+    #
+    class RepositoryRemote < GitRepository
+      def file_contents(file, ref)
+        remote_file = RemoteFile.new(@source, ref, file)
+        remote_file.contents
+      end
+    end
+  end
+end

data/lib/git_compound/repository.rb

@@ -0,0 +1,19 @@
+module GitCompound
+  # Git repositories module, also repository factory
+  #
+  module Repository
+    extend self
+
+    def factory(source)
+      if local?(source)
+        RepositoryLocal.new(source)
+      else
+        RepositoryRemote.new(remote = source) # rubocop:disable Lint/UselessAssignment
+      end
+    end
+
+    def local?(source)
+      source.match(%r{(^\/|file:\/\/).*})
+    end
+  end
+end

data/lib/git_compound/task/task.rb

@@ -0,0 +1,28 @@
+module GitCompound
+  module Task
+    # Base abstract class for task
+    #
+    class Task
+      attr_reader :name
+
+      def initialize(name, manifest, &block)
+        raise GitCompoundError,
+              "Block not given for task `#{name}`" unless block
+
+        @name       = name
+        @manifest   = manifest
+        @block      = block
+      end
+
+      def execute
+        raise NotImplementedError
+      end
+
+      private
+
+      def execute_on(directory, component)
+        @block.call(directory, component)
+      end
+    end
+  end
+end

data/lib/git_compound/task/task_all.rb

@@ -0,0 +1,27 @@
+module GitCompound
+  module Task
+    # Task for all descendant components in manifest
+    #
+    class TaskAll < Task
+      def initialize(name, manifest, &block)
+        super
+        @components = components_collect!
+      end
+
+      def execute
+        @components.each_value do |component|
+          execute_on(component.destination_path, component)
+        end
+      end
+
+      private
+
+      def components_collect!
+        components = {}
+        @manifest.process(Worker::CircularDependencyChecker.new,
+                          Worker::ComponentsCollector.new(components))
+        components
+      end
+    end
+  end
+end

data/lib/git_compound/task/task_each.rb

@@ -0,0 +1,18 @@
+module GitCompound
+  module Task
+    # Task for each component defined in manifest
+    #
+    class TaskEach < Task
+      def initialize(name, manifest, &block)
+        super
+        @components = manifest.components
+      end
+
+      def execute
+        @components.each_value do |component|
+          execute_on(component.destination_path, component)
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/task/task_single.rb

@@ -0,0 +1,21 @@
+module GitCompound
+  module Task
+    # Single task for single component
+    #
+    class TaskSingle < Task
+      def initialize(name, manifest, &block)
+        super
+        @component = @manifest.parent
+      end
+
+      def execute
+        if @component
+          execute_on(@component.destination_path, @component.manifest)
+        else
+          # Root manifest without parent
+          execute_on(Dir.pwd, @manifest)
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/task.rb

@@ -0,0 +1,22 @@
+module GitCompound
+  # Task module and factory
+  #
+  module Task
+    extend self
+
+    def factory(name, type, manifest, &block)
+      case
+      # manifest task
+      when type.nil? || type == :manfiest then task_class = TaskSingle
+      # task for each component defined in manifest
+      when type == :each                  then task_class = TaskEach
+      # task for all descendant components of manifest
+      when type == :all                   then task_class = TaskAll
+      else
+        raise GitCompoundError, "Unrecognized task type `#{type}`"
+      end
+
+      task_class.new(name, manifest, &block)
+    end
+  end
+end

data/lib/git_compound/version.rb

@@ -0,0 +1,5 @@
+# GitCompound
+#
+module GitCompound
+  VERSION = '0.0.9'
+end

data/lib/git_compound/worker/circular_dependency_checker.rb

@@ -0,0 +1,31 @@
+module GitCompound
+  module Worker
+    # Worker that checks if unwanted circular dependency exists
+    #
+    class CircularDependencyChecker < Worker
+      def visit_component(component)
+        @element = component
+        raise_error if circular_dependency_exists?
+      end
+
+      def visit_manifest(manifest)
+        @element = manifest
+        raise_error if circular_dependency_exists?
+      end
+
+      private
+
+      def circular_dependency_exists?
+        @element.ancestors.include?(@element)
+      end
+
+      def raise_error
+        name = @element.name
+        type = @element.class.name.downcase
+
+        raise CircularDependencyError,
+              "Circular dependency detected in #{type} `#{name}`!"
+      end
+    end
+  end
+end

data/lib/git_compound/worker/component_builder.rb

@@ -0,0 +1,30 @@
+module GitCompound
+  module Worker
+    # Worker that builds components
+    #
+    class ComponentBuilder < Worker
+      def initialize(lock = nil)
+        @lock  = lock
+        @print = PrettyPrint.new
+      end
+
+      def visit_component(component)
+        raise GitCompoundError,
+              "Destination directory `#{component.destination_path}` " \
+              'already exists !' if component.destination_exists?
+
+        Logger.inline 'Building:  '
+        @print.visit_component(component)
+
+        component.build
+
+        raise GitCompoundError,
+              "Destination  `#{component.destination_path}` " \
+              'verification failed !' unless component.destination_exists?
+
+        return unless @lock
+        @lock.lock_component(component) unless @lock.find(component)
+      end
+    end
+  end
+end

data/lib/git_compound/worker/component_replacer.rb

@@ -0,0 +1,25 @@
+module GitCompound
+  module Worker
+    # Worker that replaces components if necessary
+    #
+    class ComponentReplacer < Worker
+      def initialize(lock)
+        @lock  = lock
+        @print = PrettyPrint.new
+      end
+
+      def visit_component(component)
+        raise "Component `#{component.name}` is not built !" unless
+          component.destination_exists?
+
+        Logger.inline 'Replacing: '
+        @print.visit_component(component)
+
+        component.remove!
+        component.build
+
+        @lock.lock_component(component)
+      end
+    end
+  end
+end