step-up 0.1.0 → 0.2.0

data/lib/step-up/driver/git.rb

@@ -1,26 +1,33 @@
 module StepUp
   module Driver
     class Git
+      VERSION_MESSAGE_FILE_PATH = ".git/TAG_EDITMSG"
+      
       include GitExtensions::Notes
       attr_reader :mask
       def initialize
-        @mask = Parser::VersionMask.new(CONFIG["versioning"]["version_mask"])
+        @mask = Parser::VersionMask.new(CONFIG.versioning.version_mask)
       end
 
-      def self.last_version(commit_base = nil)
-        @driver ||= new
-        @driver.last_version_tag(commit_base) || "%s%s" % [@driver.mask.blank, '+']
+      def self.last_version
+        new.last_version_tag
       end
 
-      def self.unversioned_notes(commit_base = nil, clean = false)
-        options = {:mode => :with_objects}
-        options.delete :mode if clean
-        new.all_objects_with_notes(commit_base).unversioned_only.to_changelog(options)
+      def commit_history(commit_base, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        top = args.shift
+        top = "-n#{ top }" unless top.nil?
+        commits = `git log --pretty=oneline --no-color --no-notes #{ top } #{ commit_base }`
+        if options[:with_messages]
+          commits.split(/\n/).map{ |commit| commit =~ /^(\w+)\s+(.*)$/ ? [$1, $2] : nil }
+        else
+          commits.gsub(/^(\w+)\s.*$/, '\1').split(/\n/)
+        end
       end
 
-      def commit_history(commit_base, top = nil)
-        top = "-n#{ top }" unless top.nil?
-        `git log --pretty=oneline --no-color --no-notes #{ top } #{ commit_base }`.gsub(/^(\w+)\s.*$/, '\1').split("\n")
+      def commits_between(first_commit, last_commit = "HEAD", *args)
+        commit_base = first_commit.nil? ? last_commit : "#{ first_commit }..#{ last_commit }"
+        commit_history(commit_base, *args)
       end
 
       def all_tags
@@ -31,21 +38,6 @@ module StepUp
         `git notes --ref=#{ ref } list`.gsub(/^\w+\s(\w+)$/, '\1').split(/\n/)
       end
 
-      def all_objects_with_notes(commit_base = nil)
-        objects = commit_history(commit_base)
-        objects_with_notes = {}.extend GitExtensions::NotesTransformation
-        objects_with_notes.driver = self
-        notes_sections.each do |section|
-          obj = objects_with_notes_of(section)
-          obj = obj.collect { |object|
-            pos = objects.index(object)
-            pos.nil? ? nil : [pos, object]
-          }.compact.sort.reverse
-          objects_with_notes[section] = obj.collect{ |o| o.last }
-        end
-        objects_with_notes
-      end
-
       def note_message(ref, commit)
         `git notes --ref=#{ ref } show #{ commit }`
       end
@@ -58,25 +50,60 @@ module StepUp
         @version_tags ||= all_tags.map{ |tag| mask.parse(tag) }.compact.sort.map{ |tag| mask.format(tag) }.reverse
       end
 
-      def increase_version_tag(part, commit_base = nil)
-        commands = []
+      def version_tag_info(tag)
+        full_message = `git show #{ tag }`
+        tag_message = full_message[/\A.*?\n\n(.*)\n\ncommit\s\w{40}\n/m, 1]
+        tagger = full_message[/\A.*?\nTagger:\s(.*?)\s</m, 1]
+        date = Time.parse(full_message[/\A.*?\nDate:\s+(.*?)\n/m, 1])
+        {:message => tag_message, :tagger => tagger, :date => date}
+      end
+
+      def steps_to_increase_version(level, commit_base = "HEAD", message = nil)
         tag = last_version_tag(commit_base)
         tag = tag.sub(/\+$/, '')
-        tag = mask.increase_version(tag, part)
-        message = all_objects_with_notes(commit_base)
+        new_tag = mask.increase_version(tag, level)
+        notes = RangedNotes.new(self, tag, commit_base).notes.as_hash
+        commands = []
         commands << "git fetch"
-        commands << "git tag -a -m \"#{ message.to_changelog }\" #{ tag }"
+        commands << "git tag -a -m \"#{ (message || notes.to_changelog).gsub(/([\$\\"])/, '\\\\\1') }\" #{ new_tag }"
         commands << "git push --tags"
-        commands + steps_for_archiving_notes(message, tag)
+        commands + steps_for_archiving_notes(notes, new_tag)
       end
 
-      def last_version_tag(commit_base = nil)
-        objects = commit_history(commit_base)
-        all_version_tags.each do |tag|
-          index = objects.index(commit_history(tag, 1).first)
-          return "#{ tag }#{ '+' unless index.zero? }" unless index.nil?
+      def last_version_tag(commit_base = "HEAD", count_commits = false)
+        all_versions = all_version_tags
+        unless all_versions.empty?
+          commits = commit_history(commit_base)
+          all_versions.each do |tag|
+            commit_under_the_tag = commit_history(tag, 1).first
+            index = commits.index(commit_under_the_tag)
+            unless index.nil?
+              unless index.zero?
+                count = count_commits == true ? commits_between(tag, commit_base).size : 0
+                tag = "#{ tag }+#{ count unless count.zero? }"
+              end
+              return tag
+            end
+          end
+          no_tag_version_in_commit_history = nil
+        else
+          zero_version(commit_base, count_commits)
         end
-        nil
+      end
+
+      def fetched_remotes(refs_type = 'heads')
+        config = `git config --get-regexp 'remote'`.split(/\n/)
+        config.collect{ |line|
+          $1 if line =~ /^remote\.(\w+)\.fetch\s\+refs\/#{ refs_type }/
+        }.compact.uniq.sort
+      end
+
+      def editor_name
+        ENV["EDITOR"] || `git config core.editor`.chomp
+      end
+
+      def zero_version(commit_base = "HEAD", count_commits = false)
+        "%s+%s" % [mask.blank, "#{ commit_history(commit_base).size if count_commits }"]
       end
     end
   end

data/lib/step-up/git_extensions.rb

@@ -7,87 +7,29 @@ module StepUp
 
     module Notes
       def steps_for_archiving_notes(objects_with_notes, tag)
-        strategy = notes_after_versioned["strategy"]
+        strategy = CONFIG.notes.after_versioned.strategy
         raise ArgumentError, "unknown strategy: #{ strategy }" unless NOTES_STRATEGIES.include?(strategy)
         NOTES_STRATEGIES[strategy].steps_for_archiving_notes(objects_with_notes, tag, self)
       end
 
-      private
-
-      def notes_sections
-        CONFIG["notes"]["sections"]
-      end
-
-      def notes_after_versioned
-        CONFIG["notes"]["after_versioned"]
-      end
-    end
-
-    module NotesTransformation
-      def self.extend_object(base)
-        super
-        class << base
-          attr_writer :driver, :parent, :kept_notes
-          def []=(p1, p2)
-            super
-            sections << p1 unless sections.include?(p1)
-          end
-        end
-      end
-
-      def driver
-        @driver ||= parent.driver
-      end
-
-      def sections
-        @sections ||= parent != self && parent.sections && parent.sections.dup || []
-      end
-
-      def parent
-        @parent ||= self
-      end
-
-      def kept_notes
-        @kept_notes ||= driver.objects_with_notes_of(kept_notes_section)
+      def steps_for_add_notes(section, message, commit_base = nil)
+        commands = []
+        commands << "git fetch"
+        commands << "git notes --ref=#{ section } add -m \"#{ message.gsub(/([\$"])/, '\\\\\1') }\" #{ commit_base }"
+        commands << "git push #{ notes_remote } refs/notes/#{ section }"
+        commands
       end
 
-      def kept_notes_section
-        driver.send(:notes_after_versioned)["section"]
+      def steps_to_remove_notes(section, commit_base)
+        commands = []
+        commands << "git fetch"
+        commands << "git notes --ref=#{ section } remove #{ commit_base }"
+        commands << "git push #{ notes_remote } refs/notes/#{ section }"
+        commands
       end
 
-      def unversioned_only
-        notes = {}.extend NotesTransformation
-        notes.driver = driver
-        notes.kept_notes = kept_notes
-        sections.each do |section|
-          notes[section] = (parent[section] || []).select{ |commit| not kept_notes.include?(commit) }
-        end
-        notes
-      end
-
-      def messages
-        unless defined? @messages
-          notes = {}.extend NotesTransformation
-          notes.parent = self
-          sections.each do |section|
-            notes[section] = (parent[section] || []).map{ |commit| driver.note_message(section, commit) }
-          end
-          @messages = notes
-        end
-        @messages
-      end
-
-      def to_changelog(options = {})
-        changelog = []
-        sections.each_with_index do |section, index|
-          changelog << "#{ section.capitalize.gsub(/_/, ' ') }:\n" unless index.zero? || messages[section].empty?
-          messages[section].each_with_index do |note, index|
-            note = note.sub(/$/, " (#{ parent[section][index] })") if options[:mode] == :with_objects
-            changelog += note.split(/\n+/).collect{ |line| line.sub(/^(\s*)/, '\1  - ') }
-          end
-          changelog << "" unless messages[section].empty?
-        end
-        changelog.join("\n")
+      def notes_remote
+        fetched_remotes('notes').first
       end
     end
 
@@ -95,11 +37,17 @@ module StepUp
       class RemoveNotes
         def steps_for_archiving_notes(objects_with_notes, tag, driver)
           commands = []
-          objects_with_notes.sections.each do |section|
+          CONFIG.notes_sections.names.each do |section|
+            next unless objects_with_notes.has_key?(section)
+            removed_notes = []
             objects_with_notes[section].each do |object|
-              commands << "git notes --ref=#{ section } remove #{ object }"
+              next if object[2] == RangedNotes::COMMIT_NOTE
+              removed_notes << "git notes --ref=#{ section } remove #{ object[0] }"
+            end
+            unless removed_notes.empty?
+              commands += removed_notes
+              commands << "git push #{ driver.notes_remote } refs/notes/#{ section }"
             end
-            commands << "git push origin refs/notes/#{ section }" unless objects_with_notes[section].empty?
           end
           commands
         end
@@ -109,17 +57,19 @@ module StepUp
         def steps_for_archiving_notes(objects_with_notes, tag, driver)
           commands = []
           objects = []
-          changelog_message = driver.notes_after_versioned["changelog_message"]
-          objects_with_notes.sections.each do |section|
+          changelog_message = CONFIG.notes.after_versioned.changelog_message
+          CONFIG.notes_sections.names.each do |section|
+            next unless objects_with_notes.has_key?(section)
             objects_with_notes[section].each do |object|
-              unless objects.include?(object)
-                objects << object
+              next if object[2] == RangedNotes::COMMIT_NOTE
+              unless objects.include?(object[0])
+                objects << object[0]
                 kept_message = changelog_message.gsub(/\{version\}/, tag)
-                commands << "git notes --ref=#{ driver.notes_after_versioned["section"] } add -m \"#{ kept_message }\" #{ object }"
+                commands << "git notes --ref=#{ CONFIG.notes.after_versioned.section } add -m \"#{ kept_message.gsub(/([\$\\"])/, '\\\\\1') }\" #{ object[0] }"
               end
             end
           end
-          commands << "git push origin refs/notes/#{ driver.notes_after_versioned["section"] }" unless objects.empty?
+          commands << "git push #{ driver.notes_remote } refs/notes/#{ CONFIG.notes.after_versioned.section }" unless objects.empty?
           commands
         end
       end

data/lib/step-up/parser/version_mask.rb

@@ -11,6 +11,14 @@ module StepUp
         end
       end
 
+      def to_regex
+        re = []
+        mask.each_with_index do |level, index|
+          re << "(?:#{ iterator[index].source })#{ '?' if level.end_with?('9') }"
+        end
+        re.join
+      end
+
       def parse(version)
         return unless version.is_a?(String)
         i = 0
@@ -42,19 +50,20 @@ module StepUp
         raise ArgumentError unless version.is_a?(Array) && version.size == mask.size
         v = []
         iterator.each_with_index do |pattern, index|
-          raise ArgumentError unless version[index].is_a?(Fixnum)
-          unless version[index].zero? && mask[index] =~ /9$/
-            v << mask[index].sub(/[09]$/, version[index].to_s)
+          level = version[index] || 0
+          raise ArgumentError unless level.is_a?(Fixnum)
+          unless level.zero? && mask[index] =~ /9$/
+            v << mask[index].sub(/[09]$/, level.to_s)
           end
         end
         v.join
       end
 
-      def increase_version(version, part)
+      def increase_version(version, level)
         v = parse version
-        part = version_parts.index(part)
-        (v.size-part).times do |index|
-          v[part+index] = (index.zero? ? v[part+index]+1 : 0)
+        level = version_levels.index(level)
+        (v.size-level).times do |index|
+          v[level+index] = (index.zero? ? (v[level+index] || 0) + 1 : nil)
         end
         format v
       end
@@ -65,8 +74,8 @@ module StepUp
 
       private
 
-      def version_parts
-        CONFIG["versioning"]["version_parts"]
+      def version_levels
+        CONFIG["versioning"]["version_levels"]
       end
     end
   end

data/lib/step-up/ranged_notes.rb

@@ -0,0 +1,166 @@
+module StepUp
+  class RangedNotes
+    COMMIT_NOTE = 0
+    NOTE = 1
+
+    attr_reader :driver, :first_commit, :last_commit
+
+    def initialize(driver, first_commit = nil, last_commit = "HEAD")
+      @driver = driver
+      @last_commit = driver.commit_history(last_commit, 1).first
+      first_commit = driver.commit_history(first_commit, 1).first unless first_commit.nil?
+      raise ArgumentError, "The object #{ first_commit.inspect } was not found" unless first_commit.nil? || all_commits.include?(first_commit)
+      @first_commit = first_commit
+    end
+
+    def notes
+      (visible_detached_notes + scoped_commit_notes).sort.reverse.extend NotesArray
+    end
+
+    def all_notes
+      (visible_detached_notes + scoped_attached_notes + scoped_commit_notes).sort.reverse.extend NotesArray
+    end
+
+    def notes_of(commit)
+      all_visible_notes.select{ |note| note[3] == commit }.extend NotesArray
+    end
+
+    def all_commits
+      @all_commits ||= driver.commit_history(last_commit)
+    end
+
+    def scoped_commits
+      @scoped_commits ||= driver.commits_between(first_commit, last_commit, :with_messages => true).compact
+    end
+
+    def scoped_tags
+      unless defined? @scoped_tags
+        tags = []
+        commits = scoped_commits.collect(&:first)
+        driver.all_version_tags.each do |version_tag|
+          object = driver.commit_history(version_tag, 1).first
+          tags << version_tag if commits.include?(object)
+        end
+        @scoped_tags = tags
+      end
+      @scoped_tags
+    end
+
+    protected
+
+    def versioned_objects
+      unless defined? @versioned_objects
+        notes = []
+        all_notes_of_section(CONFIG.notes.after_versioned.section, all_commits).each{ |note| notes << note }
+        @versioned_objects = notes
+      end
+      @versioned_objects
+    end
+
+    def all_visible_notes
+      unless defined? @all_visible_notes
+        notes = []
+        CONFIG.notes_sections.names.each do |section|
+          all_notes_of_section(section, all_commits).each{ |note| notes << note }
+        end
+        @all_visible_notes = notes
+      end
+      @all_visible_notes
+    end
+
+    def visible_detached_notes
+      all_visible_notes.select do |note|
+        not versioned_objects.any?{ |object| object[3] == note[3] }
+      end
+    end
+
+    def scoped_attached_notes
+      return [] if scoped_tags.empty?
+      version_tags = scoped_tags.map{ |tag| tag.gsub(/([\.\*\?\{\}])/, '\\\\\1') }.join('|')
+      matcher = /^#{ CONFIG.notes.after_versioned.changelog_message.gsub(/([\.\*\?\{\}])/, '\\\\\1').sub(/\\\{version\\\}/, "(?:#{ version_tags })") }$/
+
+      all_visible_notes.select do |note|
+        versioned_objects.any?{ |object| object[3] == note[3] && object[4] =~ matcher }
+      end
+    end
+
+    def scoped_commit_notes
+      prefixes = CONFIG.notes_sections.prefixes
+      sections = CONFIG.notes_sections.names
+      tags = CONFIG.notes_sections.tags
+      notes = []
+      scoped_commits.each do |commit|
+        message = commit.last
+        prefixes.each_with_index do |prefix, index|
+          message = message[prefix.size..-1] if message.start_with?(prefix)
+          message = message.sub(/\s*##{ tags[index] }[\s\n]*\z/, '')
+          if message != commit.last
+            notes << [all_commits.index(commit.first), sections[index], COMMIT_NOTE, commit.first, message]
+            break
+          end
+        end
+      end
+      notes
+    end
+
+    private
+
+    def all_notes_of_section(section, commits = nil)
+      notes = []
+      commits = scoped_commits.collect(&:first) if commits.nil?
+      driver.objects_with_notes_of(section).each do |commit|
+        if commits.include?(commit)
+          message = driver.note_message(section, commit)
+          notes << [all_commits.index(commit), section, NOTE, commit, message]
+        end
+      end
+      notes
+    end
+
+  end
+
+  module NotesHash
+    def to_changelog(options = {})
+      changelog = []
+
+      if options[:custom_message]
+        changelog << "Custom message:\n"
+        changelog << parse_message(options[:custom_message])
+        changelog << ""
+      end
+
+      CONFIG.notes_sections.names.each do |section|
+        next unless has_key?(section)
+        changelog << "#{ CONFIG.notes_sections.label(section) }\n"
+        self[section].each do |note|
+          message = note[1]
+          message = message.sub(/$/, " (#{ note[0] })") if options[:mode] == :with_objects
+          changelog << parse_message(message)
+        end
+        changelog << ""
+      end
+      changelog.join("\n").rstrip
+    end
+
+    private
+
+    def parse_message(message)
+      message = message.rstrip.gsub(/^(\s\s)?([^\s\-])/, '\1  - \2')
+      begin
+        changed = message.sub!(/^(\s*-\s.*?\n)\n+(\s*-\s)/, '\1\2')
+      end until changed.nil?
+      message
+    end
+  end
+
+  module NotesArray
+    def as_hash
+      notes = {}.extend NotesHash
+      each do |note|
+        notes[note[1]] ||= []
+        notes[note[1]] << [note[3], note[4], note[2]] unless notes[note[1]].any?{ |n| n[0] == note[3] }
+      end
+      notes
+    end
+  end
+end