vendorificator 0.5.git.v0.4.0.63.g8e9d54d → 0.5.0

data/lib/vendorificator/segment/vendor.rb

@@ -0,0 +1,115 @@
+require 'tmpdir'
+
+module Vendorificator
+  class Segment::Vendor < Segment
+    attr_reader :overlay, :vendor
+
+    def initialize(options)
+      @vendor = options.delete(:vendor)
+      @overlay = options.delete(:overlay)
+      super
+    end
+
+    def name
+      @vendor.name
+    end
+
+    def group
+      @vendor.group
+    end
+
+    def version
+      @vendor.version
+    end
+
+    def branch_name
+      if overlay
+        _join overlay.branch_name, group, name
+      else
+        super
+      end
+    end
+
+    def compute_dependencies!
+      @vendor.compute_dependencies!
+    end
+
+    # Public: Conjures the vendor module without merging back.
+    #
+    # options - available options: :metadata - Hash with metadata information
+    #
+    # Returns nothing.
+    def conjure(options = {})
+      shell.padding += 1
+      @vendor.before_conjure!
+      Dir.mktmpdir "vendorificator-#{name}" do |tmpdir|
+        in_branch(branch_name, clean: true) do |tmpgit|
+          begin
+            @git = tmpgit
+            @vendor.git = tmpgit
+
+            Dir.chdir tmpdir do
+              @vendor.conjure!
+
+              subdir = @vendor.args[:subdirectory]
+              make_subdir_root subdir if subdir && !subdir.empty?
+            end
+
+            FileUtils.mkdir_p work_dir
+            tmpdir_entries = (Dir.entries(tmpdir) - %w'. ..').
+              map { |e| File.join(tmpdir, e) }
+            FileUtils.mv tmpdir_entries, work_dir
+            commit_and_annotate(options[:metadata] || {})
+          ensure
+            @git = nil
+            @vendor.git = nil
+          end
+        end
+      end
+    ensure
+      shell.padding -= 1
+    end
+
+    # Public: Merges back to the original branch (usually master).
+    #
+    # commit - git ref/branch to merge, defaults to segment branch
+    #
+    # Returns nothing.
+    def merge_back(commit = branch_name)
+      git.capturing.merge({no_edit: true, no_ff: true}, commit) unless config.fake_mode?
+      @vendor.postprocess! if @vendor.respond_to? :postprocess!
+      @vendor.compute_dependencies!
+    end
+
+    private
+
+    def update(options = {})
+      shell.padding += 1
+      conjure options
+      merge_back
+    ensure
+      shell.padding -= 1
+    end
+
+    def environment
+      @vendor.environment
+    end
+
+    def path
+      if overlay
+        _join overlay.path, group, name
+      else
+        @vendor.args[:path] || _join(group, name)
+      end
+    end
+
+    def work_subdir
+      if overlay
+        _join overlay.path
+      else
+        _join config[:basedir], path
+      end
+    end
+
+  end
+end

data/lib/vendorificator/vendor.rb

@@ -19,7 +19,8 @@ module Vendorificator
       end
     end
 
-    attr_reader :environment, :name, :args, :block
+    attr_reader :environment, :name, :args, :block, :segment
+    attr_accessor :git
     arg_reader :version
 
     def initialize(environment, name, args = {}, &block)
@@ -27,231 +28,35 @@ module Vendorificator
       @name = name
       @block = block
       @metadata = {
-        :module_name => @name,
         :unparsed_args => args.clone
       }
       @metadata[:parsed_args] = @args = parse_initialize_args(args)
       @metadata[:module_annotations] = @args[:annotate] if @args[:annotate]
 
-      @environment.vendor_instances << self
+      @segment = Segment::Vendor.new(vendor: self, overlay: config.overlay_instance)
+      if config.overlay_instance
+        config.overlay_instance.segments << @segment
+      else
+        @environment.segments << @segment
+      end
     end
 
     def ===(other)
-      other === self.name or File.expand_path(other.to_s) == self.work_dir
-    end
-
-    def path
-      args[:path] || _join(group, name)
-    end
-
-    def shell
-      @environment.shell
-    end
-
-    def say(verb_level= :default, &block)
-      output = yield
-      @environment.say verb_level, output
-    end
-
-    def say_status(*args, &block)
-      @environment.say_status(*args, &block)
+      other === name || File.expand_path(other.to_s) == work_dir
     end
 
     def group
       defined?(@group) ? @group : self.class.group
     end
 
-    def branch_name
-      _join(config[:branch_prefix], group, name)
-    end
-
-    def to_s
-      _join(name, version)
-    end
-
     def inspect
       "#<#{self.class} #{self}>"
     end
 
-    def work_subdir
-      _join(config[:basedir], path)
-    end
-
-    def work_dir
-      _join(git.git_work_tree, environment.relative_root_dir, work_subdir)
-    end
-
-    def head
-      git.capturing.rev_parse({:verify => true, :quiet => true}, "refs/heads/#{branch_name}").strip
-    rescue MiniGit::GitError
-      nil
-    end
-
-    def tag_name
-      _join(tag_name_base, version)
-    end
-
-    def merged
-      unless @_has_merged
-        if ( head = self.head )
-          merged = git.capturing.merge_base(head, 'HEAD').strip
-          @merged = merged unless merged.empty?
-        end
-        @_has_merged = true
-      end
-      @merged
-    rescue MiniGit::GitError
-      @_has_merged = true
-      @merged = nil
-    end
-
-    def merged_tag
-      unless @_has_merged_tag
-        if merged
-          tag = git.capturing.describe( {
-              :exact_match => true,
-              :match => _join(tag_name_base, '*') },
-            merged).strip
-          @merged_tag = tag unless tag.empty?
-        end
-        @_has_merged_tag = true
-      end
-      @merged_tag
-    end
-
-    def merged_version
-      merged_tag && merged_tag[(1+tag_name_base.length)..-1]
-    end
-
-    # Public: Get git vendor notes of the merged commit.
-    #
-    # Returns the Hash of git vendor notes.
-    def merged_notes
-      Commit.new(merged, git).notes?
-    end
-
     def version
-      @args[:version] || (!config[:use_upstream_version] && merged_version) || upstream_version
-    end
-
-    def upstream_version
-      # To be overriden
-    end
-
-    def updatable?
-      return nil if self.status == :up_to_date
-      return false if !head
-      return false if head && merged == head
-      git.describe({:abbrev => 0, :always => true}, branch_name)
-    end
-
-    def status
-      # If there's no branch yet, it's a completely new module
-      return :new unless head
-
-      # If there's a branch but no tag, it's a known module that's not
-      # been updated for the new definition yet.
-      return :outdated unless tagged_sha1
-
-      # Well, this is awkward: branch is in config and exists, but is
-      # not merged into current branch at all.
-      return :unmerged unless merged
-
-      # Merge base is tagged with our tag. We're good.
-      return :up_to_date if tagged_sha1 == merged
-
-      return :unpulled if environment.fast_forwardable?(tagged_sha1, merged)
-
-      return :unknown
-    end
-
-    def needed?
-      return self.status != :up_to_date
-    end
-
-    def in_branch(options={}, &block)
-      branch_exists = !!self.head
-      notes_exist = begin
-                      git.capturing.rev_parse({verify: true, quiet: true}, 'refs/notes/vendor')
-                    rescue MiniGit::GitError
-                      nil
-                    end
-      Dir.mktmpdir("vendor-#{group}-#{name}") do |tmpdir|
-        clone_opts = {:shared => true, :no_checkout => true}
-        clone_opts[:branch] = branch_name if branch_exists
-        say { MiniGit::Capturing.git(:clone, clone_opts, git.git_dir, tmpdir) }
-        tmpgit = MiniGit.new(tmpdir)
-        #TODO: Silence/handle the stderr output from git-checkout
-        tmpgit.capturing.checkout({orphan: true}, branch_name) unless branch_exists
-        tmpgit.fetch(git.git_dir, "refs/notes/vendor:refs/notes/vendor") if notes_exist
-        if options[:clean] || !branch_exists
-          tmpgit.rm({ :r => true, :f => true, :q => true, :ignore_unmatch => true }, '.')
-        end
-
-        begin
-          @git = tmpgit
-          Dir.chdir(tmpdir) do
-            yield
-          end
-        ensure
-          @git = nil
-        end
-
-        #TODO: Silence/handle the stderr output from git-fetch
-        git.fetch(tmpdir)
-        git.fetch({tags: true}, tmpdir)
-        git.fetch(tmpdir,
-          "refs/heads/#{branch_name}:refs/heads/#{branch_name}",
-          "refs/notes/vendor:refs/notes/vendor")
-      end
-    end
-
-    def run!(options = {})
-      case status
-
-      when :up_to_date
-        say_status :default, 'up to date', self.to_s
-
-      when :unpulled, :unmerged
-        say_status :default, 'merging', self.to_s, :yellow
-        git.merge({:no_edit => true, :no_ff => true}, tagged_sha1)
-        postprocess! if self.respond_to? :postprocess!
-        compute_dependencies!
-
-      when :outdated, :new
-        say_status :default, 'fetching', self.to_s, :yellow
-        begin
-          shell.padding += 1
-          before_conjure!
-          in_branch(:clean => true) do
-            FileUtils::mkdir_p work_dir
-
-            # Actually fill the directory with the wanted content
-            Dir::chdir work_dir do
-              begin
-                shell.padding += 1
-                self.conjure!
-              ensure
-                shell.padding -= 1
-              end
-
-              subdir = args[:subdirectory]
-              make_subdir_root subdir if subdir && !subdir.empty?
-            end
-
-            commit_and_annotate(options[:metadata])
-          end
-          # Merge back to the original branch
-          git.capturing.merge( {:no_edit => true, :no_ff => true}, branch_name )
-          postprocess! if self.respond_to? :postprocess!
-          compute_dependencies!
-        ensure
-          shell.padding -= 1
-        end
-
-      else
-        say_status :quiet, self.status, "I'm unsure what to do.", :red
-      end
+      @args[:version] ||
+        (!config[:use_upstream_version] && segment.merged_version) ||
+        upstream_version
     end
 
     def conjure!
@@ -262,27 +67,19 @@ module Vendorificator
     def git_add_extra_paths ; [] ; end
     def before_conjure! ; end
     def compute_dependencies! ; end
-
-    def pushable_refs
-      created_tags.unshift("refs/heads/#{branch_name}")
-    end
+    def upstream_version ; end
 
     def metadata
       default = {
+        :module_name => @name,
         :module_version => version,
         :module_group => @group,
       }
       default.merge @metadata
     end
 
-    def included_in_list?(module_list)
-      modpaths = module_list.map { |m| File.expand_path(m) }
-
-      module_list.include?(name) ||
-        module_list.include?("#{group}/#{name}") ||
-        modpaths.include?(File.expand_path(work_dir)) ||
-        module_list.include?(merged) ||
-        module_list.include?(branch_name)
+    def conjure_commit_message
+      "Conjured vendor module #{name} version #{version}"
     end
 
     private
@@ -305,31 +102,6 @@ module Vendorificator
       args
     end
 
-    def tag_name_base
-      _join('vendor', group, name)
-    end
-
-    def conjure_commit_message
-      "Conjured vendor module #{name} version #{version}"
-    end
-
-    def tag_message
-      conjure_commit_message
-    end
-
-    def tagged_sha1
-      @tagged_sha1 ||= git.capturing.rev_parse(
-        {:verify => true, :quiet => true}, "refs/tags/#{tag_name}^{commit}"
-      ).strip
-    rescue MiniGit::GitError
-      nil
-    end
-
-    def created_tags
-      git.capturing.show_ref.lines.map{ |line| line.split(' ')[1] }.
-        select{ |ref| ref =~ /\Arefs\/tags\/#{tag_name_base}\// }
-    end
-
     def git
       @git || environment.git
     end
@@ -338,47 +110,21 @@ module Vendorificator
       environment.config
     end
 
-    def _join(*parts)
-      parts.compact.map(&:to_s).join('/')
+    def work_dir
+      segment.work_dir
     end
 
-    def make_subdir_root(subdir_path)
-      curdir = Pathname.pwd
-      tmpdir = Pathname.pwd.dirname.join("#{Pathname.pwd.basename}.tmp")
-      subdir = Pathname.pwd.join(subdir_path)
-
-      Dir.chdir('..')
-
-      subdir.rename(tmpdir.to_s)
-      curdir.rmtree
-      tmpdir.rename(curdir.to_s)
-    ensure
-      Dir.chdir(curdir.to_s) if curdir.exist?
+    def shell
+      environment.shell
     end
 
-    # Private: Commits and annotates the conjured module.
-    #
-    # environment_metadata - Hash with environment metadata where vendor was run
-    #
-    # Returns nothing.
-    def commit_and_annotate(environment_metadata = {})
-      git.capturing.add work_dir, *git_add_extra_paths
-      git.capturing.commit :m => conjure_commit_message
-      git.capturing.notes({:ref => 'vendor'}, 'add', {:m => conjure_note(environment_metadata)}, 'HEAD')
-      git.capturing.tag( { :a => true, :m => tag_message }, tag_name )
-      say_status :default, :tag, tag_name
+    def say(verb_level= :default, &block)
+      output = yield
+      environment.say verb_level, output
     end
 
-    # Private: Merges all the data we use for the commit note.
-    #
-    # environment_metadata - Hash with environment metadata where vendor was run
-    #
-    # Returns: The note in the YAML format.
-    def conjure_note(environment_metadata = {})
-      config.metadata.
-        merge(environment_metadata).
-        merge(metadata).
-        to_yaml
+    def say_status(*args, &block)
+      environment.say_status(*args, &block)
     end
   end