rubycut-vclog 1.9.4

data/lib/vclog/heuristics/rule.rb

@@ -0,0 +1,73 @@
+module VCLog
+
+  class Heuristics
+
+    # Defines a categorization rule for commits.
+    #
+    class Rule
+
+      # Initialize a new log rule.
+      #
+      # @param [Regexp] pattern
+      #   An optional regular expression to match agains the commit message.
+      #   If the pattern does not match the commit message than the rule 
+      #   does not apply.
+      #
+      # @yieldparam [Change]
+      #   An encapsulation of the commit.
+      #
+      # @yieldreturn [Boolean]
+      #   If the return value is +nil+ or +false+, the rule does not apply.
+      #   If a rule does not apply then be sure not to alter the commit!
+      #
+      def initialize(pattern=nil, &block)
+        @pattern = pattern
+        @block   = block        
+      end
+
+      # Message pattern to match for the rule to apply.
+      attr :pattern
+
+      # Process the rule.
+      #
+      # @since 1.9.0 
+      #   If using a message pattern and the block takes two arguments
+      #   then the first will be the commit object, not the message as
+      #   was the case in older versions.
+      #
+      def call(commit)
+        if pattern
+          call_pattern(commit)
+        else
+          call_commit(commit)
+        end
+      end
+
+     private
+
+      # 
+      def call_pattern(commit)
+        if matchdata = @pattern.match(commit.message)
+          #case @block.arity
+          #when 0
+          #  @block.call
+          #when 1
+          #  @block.call(matchdata)
+          #else
+            @block.call(commit, matchdata)
+          #end
+        else
+          nil
+        end
+      end
+
+      #
+      def call_commit(commit)
+        @block.call(commit)
+      end
+
+    end
+
+  end
+
+end

data/lib/vclog/heuristics/type.rb

@@ -0,0 +1,29 @@
+module VCLog
+
+  class Heuristics
+
+    #
+    #
+    class Type
+      #
+      def initialize(type, level, label)
+        @type  = type.to_sym
+        @level = level.to_i
+        @label = label.to_s
+      end
+
+      attr :type
+
+      attr :level
+
+      attr :label
+
+      #
+      def to_a
+        [type, level, label]
+      end
+    end
+
+  end
+
+end

data/lib/vclog/history_file.rb

@@ -0,0 +1,69 @@
+module VCLog
+
+  # The HistoryFile class will parse a history into an array
+  # of release tags. Of course to do this, it assumes a specific
+  # file format.
+  #
+  class HistoryFile
+
+    FILE = '{HISTORY,HISTORY.*}'
+
+    LINE = /^[=#]/
+    VERS = /(\d+[._])+\d+/
+    DATE = /(\d+[-])+\d+/
+
+    # Alias for `File::FNM_CASEFOLD`.
+    CASEFOLD = File::FNM_CASEFOLD
+
+    # Release tags.
+    attr :tags
+
+    # Setup new HistoryFile instance.
+    def initialize(source=nil)
+      if File.file?(source)
+        @file = source
+        @root = File.dirname(source)
+      elsif File.directory?(source)
+        @file = Dir.glob(File.join(source,FILE), CASEFOLD).first
+        @root = source
+      else
+        @file = Dir.glob(FILE).first
+        @root = Dir.pwd
+      end
+      raise "no history file" unless @file
+
+      @tags = extract_tags
+    end
+
+    # Parse history file.
+    def extract_tags
+      tags = []
+      desc = ''
+      text = File.read(@file)
+      text.lines.each do |line|
+        if LINE =~ line
+          vers = (VERS.match(line) || [])[0]
+          date = (DATE.match(line) || [])[0]
+          next unless vers
+          tags << [vers, date, desc = '']
+        else
+          desc << line
+        end
+      end
+
+      tags.map do |vers, date, desc|
+        index = desc.index(/^Changes:/) || desc.index(/^\*/) || desc.size
+        desc = desc[0...index].strip.fold
+        #[vers, date, desc]
+        Tag.new(:name=>vers, :date=>date, :msg=>desc)
+      end
+    end
+
+    #
+    def news
+      tags.first.message
+    end
+
+  end
+
+end

data/lib/vclog/metadata.rb

@@ -0,0 +1,16 @@
+module VCLog
+
+  def self.metadata
+    @metadata ||= (
+      require 'yaml'
+      YAML.load_file(File.dirname(__FILE__) + '/../vclog.yml')
+    )
+  end
+
+  def self.const_missing(name)
+    key = name.to_s.downcase
+    metadata.key?(key) ? metadata[key] : super(name)
+  end
+
+end
+

data/lib/vclog/rc.rb

@@ -0,0 +1,9 @@
+begin
+  require 'rc/api'
+
+  configure 'vclog' do |config|
+    VCLog.configure(&config) if config.profile?
+  end
+rescue LoadError
+end
+

data/lib/vclog/release.rb

@@ -0,0 +1,67 @@
+module VCLog
+
+  # A Release encapsulate a collection of {Change} objects
+  # associated with a {Tag}.
+  #
+  class Release
+
+    # Tag object this release represents.
+    attr :tag
+
+    # Array of Change objects.
+    attr :changes
+
+    #
+    # New Release object.
+    #
+    # @param [Tag] tag
+    #   A Tag object.
+    #
+    # @param [Array<Change>] changes
+    #   An array of Change objects.
+    #
+    def initialize(tag, changes)
+      @tag     = tag
+      @changes = changes
+    end
+
+    #
+    # Group +changes+ by type and sort by level.
+    #
+    # @return [Array<Array>]
+    #   Returns an associative array of [type, changes].
+    #
+    def groups
+      @groups ||= (
+        changes.group_by{ |e| e.label }.sort{ |a,b| b[1][0].level <=> a[1][0].level }
+      )
+    end
+
+    #
+    # Compare release by tag.
+    #
+    # @param [Release] other
+    #   Another release instance.
+    #
+    def <=>(other)
+      @tag <=> other.tag
+    end
+
+    #
+    # Convert Release to Hash.
+    #
+    # @todo Should +version+ be +name+?
+    #
+    def to_h
+      { 'version'  => tag.name,
+        'date'     => tag.date,
+        'message'  => tag.message,
+        'author'   => tag.author,
+        'id'       => tag.id,
+        'changes'  => changes.map{|change| change.to_h}
+      }
+    end
+
+  end
+
+end

data/lib/vclog/repo.rb

@@ -0,0 +1,298 @@
+require 'vclog/core_ext'
+require 'vclog/adapters'
+require 'vclog/config'
+require 'vclog/heuristics'
+require 'vclog/history_file'
+require 'vclog/changelog'
+require 'vclog/tag'
+require 'vclog/release'
+require 'vclog/report'
+
+module VCLog
+
+  # Encapsulate representaiton of the repository.
+  #
+  class Repo
+
+    #
+    # File glob used to find project root directory.
+    #
+    ROOT_GLOB = '{.ruby,.map/,.git/,.hg/,_darcs/,.svn/}'
+
+    #
+    # Project's root directory.
+    #
+    attr :root
+
+    #
+    # Options hash.
+    #
+    attr :options
+
+    #
+    # Setup new Repo instance.
+    #
+    def initialize(root, options={})
+      options[:root] = root if root
+
+      @config  = Config.new(options)
+      @options = options
+
+      vcs_type = @config.vcs_type
+
+      raise ArgumentError, "Not a recognized version control system." unless vcs_type
+
+      @adapter = Adapters.const_get(vcs_type.capitalize).new(self)
+    end
+
+    #
+    # Returns instance of an Adapter subclass.
+    #
+    def adapter
+      @adapter
+    end
+
+    #
+    # Configuration.
+    #
+    def config
+      @config
+    end
+
+    #
+    # Project root directory.
+    #
+    def root
+      config.root
+    end
+
+    #
+    # Load heuristics script.
+    #
+    def heuristics
+      config.heuristics
+    end
+
+    #
+    # Check force option.
+    #
+    def force?
+      config.force?
+    end
+
+    #
+    # Access to Repo's HISTORY file.
+    #
+    def history_file
+      @history_file ||= HistoryFile.new(options[:history_file] || root)
+    end
+
+    #
+    # Read history file and make a commit tag for any release not already
+    # tagged. Unless the force option is set the user will be prompted for
+    # each new tag.
+    #
+    def autotag(prefix=nil)
+      history_file.tags.each do |tag|
+        label = "#{prefix}#{tag.name}"
+        if not adapter.tag?(label)
+          chg = adapter.change_by_date(tag.date)
+          if chg
+            if force? or ask_yn(new_tag_message(label, tag) + "\nCreate tag? [yN] ")
+              adapter.tag(chg.rev, label, tag.date, tag.message)
+            end
+          else
+            puts "No commit found for #{label} #{tag.date.strftime('%Y-%m-%d')}."
+          end
+        end
+      end
+    end
+
+    #
+    # List of all changes.
+    #
+    def changes
+      @changes ||= apply_heuristics(adapter.changes)
+    end
+
+    #
+    # List of all change points.
+    #
+    def change_points
+      @change_points ||= apply_heuristics(adapter.change_points)
+    end
+
+    #
+    # Apply heuristics to changes.
+    #
+    def apply_heuristics(changes)
+      changes.each do |change|
+        change.apply_heuristics(heuristics)
+      end
+    end
+
+    #
+    # Collect releases for the given set of +changes+.
+    #
+    # Releases are groups of changes segregated by tags. The release version,
+    # release date and release note are defined by hard tag commits.
+    #
+    # @param [Array<Change>] changes
+    #   List of Change objects.
+    #
+    # @return [Array<Release>]
+    #   List of Release objects.
+    #
+    def releases(changes)
+      rel  = []
+      tags = self.tags.dup
+
+      #ver  = repo.bump(version)
+
+      name = config.version || 'HEAD'
+      user = adapter.user
+      date = ::Time.now + (3600 * 24) # one day ahead
+
+      change = Change.new(:id=>'HEAD', :date=>date, :who=>user)
+
+      tags << Tag.new(:name=>name, :date=>date, :who=>user, :msg=>"Current Development", :commit=>change)
+
+      # TODO: Do we need to add a Time.now tag?
+      # add current verion to release list (if given)
+      #previous_version = tags[0].name
+      #if current_version < previous_version  # TODO: need to use natural comparision
+      #  raise ArgumentError, "Release version is less than previous version (#{previous_version})."
+      #end
+
+      # sort by release date
+      tags = tags.sort{ |a,b| a.date <=> b.date }
+
+      # organize into deltas
+      delta = []
+      last  = nil
+      tags.each do |tag|
+        delta << [tag, [last, tag.commit.date]]
+        last = tag.commit.date
+      end
+
+      # gather changes for each delta
+      delta.each do |tag, (started, ended)|
+        if started
+          set = changes.select{ |c| c.date > started && c.date <= ended  }
+          #gt_vers, gt_date = gt.name, gt.date
+          #lt_vers, lt_date = lt.name, lt.date
+          #gt_date = Time.parse(gt_date) unless Time===gt_date
+          #lt_date = Time.parse(lt_date) unless Time===lt_date
+          #log = changelog.after(gt).before(lt)
+        else
+          #lt_vers, lt_date = lt.name, lt.date
+          #lt_date = Time.parse(lt_date) unless Time===lt_date
+          #log = changelog.before(lt_date)
+          set = changes.select{ |c| c.date <= ended }
+        end
+        rel << Release.new(tag, set)
+      end
+      rel.sort
+    end
+
+    #
+    # Print a report with given options.
+    #
+    def report(options)
+      report = Report.new(self, options)
+      report.print
+    end
+
+    #
+    # Make an educated guess as to the next version number based on
+    # changes made since previous release.
+    #
+    # @return [String] version number
+    #
+    # @todo Allow configuration of version bump thresholds
+    #
+    def bump
+      last_release = releases(changes).first
+      max = last_release.changes.map{ |c| c.level }.max
+      if max > 1
+        bump_part('major')
+      elsif max >= 0
+        bump_part('minor')
+      else
+        bump_part('patch')
+      end
+    end
+
+    #
+    # Provides a bumped version number.
+    #
+    def bump_part(part=nil)
+      raise "bad version part - #{part}" unless ['major', 'minor', 'patch', 'build', ''].include?(part.to_s)
+
+      if tags.last
+        v = tags[-1].name # TODO: ensure the latest version
+        v = tags[-2].name if v == 'HEAD'
+      else
+        v = '0.0.0'
+      end
+
+      v = v.split(/\W/)    # TODO: preserve split chars
+
+      case part.to_s
+      when 'major'
+        v[0] = v[0].succ
+        (1..(v.size-1)).each{ |i| v[i] = '0' }
+        v.join('.')
+      when 'minor'
+        v[1] = '0' unless v[1]
+        v[1] = v[1].succ
+        (2..(v.size-1)).each{ |i| v[i] = '0' }
+        v.join('.')
+      when 'patch'
+        v[1] = '0' unless v[1]
+        v[2] = '0' unless v[2]
+        v[2] = v[2].succ
+        (3..(v.size-1)).each{ |i| v[i] = '0' }
+        v.join('.')
+      else
+        v[-1] = '0' unless v[-1]
+        v[-1] = v[-1].succ
+        v.join('.')
+      end
+    end
+
+    #
+    # Delegate missing methods to SCM adapter.
+    #
+    def method_missing(s, *a, &b)
+      if adapter.respond_to?(s)
+        adapter.send(s, *a, &b)
+      else
+        super(s,*a,&b)
+      end
+    end
+
+  private
+
+    #
+    # Ask yes/no question.
+    #
+    def ask_yn(message)
+      case ask(message)
+      when 'y', 'Y', 'yes'
+        true
+      else
+        false
+      end
+    end
+
+    #
+    # Returns a String.
+    #
+    def new_tag_message(label, tag)
+      "#{label} / #{tag.date.strftime('%Y-%m-%d')}\n#{tag.message}"
+    end
+
+  end
+
+end