step-up 0.1.0

data/README.md

@@ -0,0 +1,3 @@
+# LastVersion: a project to versioning projects
+
+LastVersion is an utility to manage versioning tags on git projects.

data/Rakefile

@@ -0,0 +1,40 @@
+begin
+  require 'rspec/core/rake_task'
+
+  desc "Run specs"
+  RSpec::Core::RakeTask.new do |t|
+    t.rspec_opts = %w(-fs --color)
+    t.ruby_opts  = %w(-w)
+  end
+rescue LoadError
+  task :spec do
+    abort "Run `rake spec:deps` to be able to run the specs"
+  end
+
+  namespace :spec do
+    desc "Ensure spec dependencies are installed"
+    task :deps do
+      sh "gem list rspec | (grep 'rspec (2.0' 1> /dev/null) || gem install rspec --no-ri --no-rdoc"
+    end
+  end
+end
+
+desc "Build the gem"
+task :build do
+  opers = Dir.glob('*.gem')
+  opers = ["rm #{ opers.join(' ') }"] unless opers.empty?
+  opers << ["gem build step-up.gemspec"]
+  sh opers.join(" && ")
+end
+
+desc "Build and install the gem, removing old installation"
+task :install => :build do
+  gem = Dir.glob('*.gem').first
+  if gem.nil?
+    puts "could not install the gem"
+  else
+    sh "gem uninstall step-up && gem install #{ gem }"
+  end
+end
+
+task :default => :spec

data/bin/stepup

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'step-up/cli'
+
+begin
+  StepUp::CLI.start
+rescue Exception => e
+  puts e.message
+end

data/lib/step-up.rb

@@ -0,0 +1,11 @@
+module StepUp
+  autoload :CONFIG, 'step-up/config.rb'
+  autoload :VERSION, 'step-up/version.rb'
+  module Driver
+    autoload :Git, 'step-up/driver/git.rb'
+  end
+  autoload :GitExtensions, 'step-up/git_extensions.rb'
+  module Parser
+    autoload :VersionMask, 'step-up/parser/version_mask.rb'
+  end
+end

data/lib/step-up/cli.rb

@@ -0,0 +1,26 @@
+require 'thor'
+require 'step-up'
+
+module StepUp
+  class CLI < Thor
+    map %w(--version -v) => :gem_version
+    
+    default_task :version
+
+    desc "", "show the last version of the application"
+    def version
+      puts StepUp::Driver::Git.last_version
+    end
+
+    desc "notes [object]", "show notes for the next version"
+    method_options :clean => :boolean
+    def notes(commit_base = nil)
+      puts StepUp::Driver::Git.unversioned_notes(commit_base, options[:clean])
+    end
+    
+    desc "-v, --version", "show the last version of the gem"
+    def gem_version
+      puts StepUp::VERSION
+    end
+  end
+end

data/lib/step-up/config.rb

@@ -0,0 +1,14 @@
+require 'yaml'
+module StepUp
+  CONFIG = {}
+
+  def self.load_config path
+    return CONFIG unless File.exists? path
+    CONFIG.merge! YAML.load_file(path)
+  rescue TypeError => e
+    puts "could not load #{path}: #{e.inspect}"
+  end
+
+  load_config File.expand_path('../config/step-up.yml', __FILE__)
+  load_config '.versionrc' # from working folder
+end

data/lib/step-up/config/step-up.yml

@@ -0,0 +1,19 @@
+notes:
+  after_versioned:
+    strategy: "remove"
+    #strategy: "keep"
+    section: "versioning"
+    changelog_message: "available on {version}"
+  sections:
+    - changes
+    - bugfixes
+    - features
+    - deploy_steps
+versioning:
+  version_mask: "v0.0.0.9.rc9"
+  version_parts:
+    - major
+    - minor
+    - tiny
+    - patch
+    - rc

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

@@ -0,0 +1,83 @@
+module StepUp
+  module Driver
+    class Git
+      include GitExtensions::Notes
+      attr_reader :mask
+      def initialize
+        @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, '+']
+      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)
+      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")
+      end
+
+      def all_tags
+        `git tag -l`.split("\n")
+      end
+
+      def objects_with_notes_of(ref)
+        `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
+
+      def notes_messages(objects_with_notes)
+        objects_with_notes.messages
+      end
+
+      def all_version_tags
+        @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 = []
+        tag = last_version_tag(commit_base)
+        tag = tag.sub(/\+$/, '')
+        tag = mask.increase_version(tag, part)
+        message = all_objects_with_notes(commit_base)
+        commands << "git fetch"
+        commands << "git tag -a -m \"#{ message.to_changelog }\" #{ tag }"
+        commands << "git push --tags"
+        commands + steps_for_archiving_notes(message, 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?
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/step-up/git_extensions.rb

@@ -0,0 +1,130 @@
+module StepUp
+  module GitExtensions
+    NOTES_STRATEGIES = {}
+    def self.register_notes_strategy(key, instance)
+      NOTES_STRATEGIES[key] = instance
+    end
+
+    module Notes
+      def steps_for_archiving_notes(objects_with_notes, tag)
+        strategy = 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)
+      end
+
+      def kept_notes_section
+        driver.send(:notes_after_versioned)["section"]
+      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")
+      end
+    end
+
+    module Strategy
+      class RemoveNotes
+        def steps_for_archiving_notes(objects_with_notes, tag, driver)
+          commands = []
+          objects_with_notes.sections.each do |section|
+            objects_with_notes[section].each do |object|
+              commands << "git notes --ref=#{ section } remove #{ object }"
+            end
+            commands << "git push origin refs/notes/#{ section }" unless objects_with_notes[section].empty?
+          end
+          commands
+        end
+      end
+
+      class KeepNotes
+        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|
+            objects_with_notes[section].each do |object|
+              unless objects.include?(object)
+                objects << object
+                kept_message = changelog_message.gsub(/\{version\}/, tag)
+                commands << "git notes --ref=#{ driver.notes_after_versioned["section"] } add -m \"#{ kept_message }\" #{ object }"
+              end
+            end
+          end
+          commands << "git push origin refs/notes/#{ driver.notes_after_versioned["section"] }" unless objects.empty?
+          commands
+        end
+      end
+    end
+    register_notes_strategy "remove", Strategy::RemoveNotes.new
+    register_notes_strategy "keep", Strategy::KeepNotes.new
+  end
+end

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

@@ -0,0 +1,73 @@
+module StepUp
+  module Parser
+    class VersionMask
+      attr_reader :mask
+      attr_reader :iterator
+      def initialize(mask)
+        @mask = mask.scan(/\D+[09]/)
+        raise ArgumentError if mask != @mask.join
+        @iterator = @mask.map do |token|
+          Regexp.new token.sub(/\./, '\\.').sub(/[09]$/,'(\d+)')
+        end
+      end
+
+      def parse(version)
+        return unless version.is_a?(String)
+        i = 0
+        v = []
+        iterator.each_with_index do |pattern, index|
+          pos = version.index(pattern, i)
+          if pos.nil?
+            if mask[index] =~ /9$/
+              v << 0
+            else
+              return
+            end
+          else
+            if pos == i
+              n = $1
+              i += mask[index].size + n.size - 1
+              v << n.to_i
+            elsif mask[index] =~ /9$/
+              v << 0
+            else
+              return
+            end
+          end
+        end
+        v
+      end
+
+      def format(version)
+        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)
+          end
+        end
+        v.join
+      end
+
+      def increase_version(version, part)
+        v = parse version
+        part = version_parts.index(part)
+        (v.size-part).times do |index|
+          v[part+index] = (index.zero? ? v[part+index]+1 : 0)
+        end
+        format v
+      end
+
+      def blank
+        format mask.size.times.map{ 0 }
+      end
+
+      private
+
+      def version_parts
+        CONFIG["versioning"]["version_parts"]
+      end
+    end
+  end
+end

data/lib/step-up/version.rb

@@ -0,0 +1,28 @@
+module StepUp
+  path = File.expand_path('../..', __FILE__)
+  v = nil
+  if path =~ /\/step-up-([\w\.\-]+)/
+    v = $1
+  end
+  if v.nil?
+    $:.each do |path|
+      if path =~ /\/step-up-([\w\.\-]+)/
+        v = $1
+        break
+      end
+    end
+  end
+  if v.nil?
+    path = File.expand_path('../../../.git', __FILE__)
+    if File.exists?(path)
+      v = Driver::Git.last_version
+    end
+  end
+  if v.nil?
+    VERSION = "0.0.0"
+  else
+    v.sub!(/^v/, '')
+    v.sub!(/\+$/, '')
+    VERSION = v
+  end
+end

data/spec/lib/step-up/driver/git_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+describe StepUp::Driver::Git do
+  before do
+    @driver = StepUp::Driver::Git.new
+  end
+
+
+  context 'fetching information' do
+    it 'should get all commits from history log' do
+      @driver.should respond_to :commit_history
+      @driver.commit_history("f4cfcc2").should be == ["f4cfcc2c8b1f7edb1b7817b4e8a9063d21db089b", "2fb8a3281fb6777405aadcd699adb852b615a3e4", "d7b0fa26ca547b963569d7a82afd7d7ca11b71ae", "8b38f7c842496fd50b4e1b7ca5e883940b9cbf83", "f76c8d7bf64678963aeef84009be54f1819e3389", "8299243c7dac8f27c3572424a348a7f83ef0ce28", "570fe2e6e7f0b06140ae109e50a1e86628819493", "cdd4d5aa885b22136f4a08c1b35076f888f9536e", "72174c160b50ec73a8f67c8150e0dcd976857411", "b2da007b4fb35e0274858c14a83a836852d055a4", "4f0e7e0f6b3df2d49ed0029ed01998bf2102b28f"]
+      @driver.commit_history("f4cfcc2", 3).should be == ["f4cfcc2c8b1f7edb1b7817b4e8a9063d21db089b", "2fb8a3281fb6777405aadcd699adb852b615a3e4", "d7b0fa26ca547b963569d7a82afd7d7ca11b71ae"]
+    end
+  end
+
+
+  context 'fetching tags' do
+    it "should get tags sorted" do
+      tags = %w[note-v0.2.0-1 v0.1.0 v0.1.1 v0.1.2 v0.1.1.rc3]
+      @driver.stubs(:all_tags).returns(tags)
+      @driver.all_version_tags.should be == %w[v0.1.2 v0.1.1.rc3 v0.1.1 v0.1.0]
+    end
+
+    it "should return last tag visible" do
+      @driver.last_version_tag("f4cfcc2").should be == "v0.0.1+"
+      @driver.last_version_tag("570fe2e").should be == "v0.0.1"
+      @driver.class.last_version("f4cfcc2").should be == "v0.0.1+"
+      @driver.class.last_version("570fe2e").should be == "v0.0.1"
+    end
+
+    it "should get no tag visible" do
+      @driver.last_version_tag("cdd4d5a").should be_nil
+    end
+
+    it "should get a blank tag" do
+      @driver.mask.blank.should be == "v0.0.0"
+      @driver.class.last_version("cdd4d5a").should be == "v0.0.0+"
+    end
+  end
+
+
+  context "fetching notes" do
+    context "from test_* sections" do
+      before do
+        @driver.stubs(:notes_sections).returns(%w[test_changes test_bugfixes test_features])
+        @objects_with_notes = {"test_changes" => ["8299243c7dac8f27c3572424a348a7f83ef0ce28", "2fb8a3281fb6777405aadcd699adb852b615a3e4"], "test_bugfixes" => ["d7b0fa26ca547b963569d7a82afd7d7ca11b71ae"], "test_features" => []}
+        @messages = {"test_changes" => ["removing files from gemspec\n  .gitignore\n  lastversion.gemspec\n", "loading default configuration yaml\n\nloading external configuration yaml\n"], "test_bugfixes" => ["sorting tags according to the mask parser\n"], "test_features" => []}
+        @changelog_full = <<-MSG
+  - removing files from gemspec (8299243c7dac8f27c3572424a348a7f83ef0ce28)
+    - .gitignore
+    - lastversion.gemspec
+  - loading default configuration yaml (2fb8a3281fb6777405aadcd699adb852b615a3e4)
+  - loading external configuration yaml
+
+Test bugfixes:
+
+  - sorting tags according to the mask parser (d7b0fa26ca547b963569d7a82afd7d7ca11b71ae)
+MSG
+        @changelog = @changelog_full.gsub(/\s\(\w+\)$/, '')
+        @all_objects_with_notes = @driver.all_objects_with_notes("f4cfcc2")
+      end
+      it "should get all objects with notes" do
+        @all_objects_with_notes.should be == @objects_with_notes
+      end
+      it "should get all notes messages" do
+        @all_objects_with_notes.should respond_to(:messages)
+        @all_objects_with_notes.messages.should be == @messages
+      end
+      it "should get changelog message" do
+        @all_objects_with_notes.should respond_to(:to_changelog)
+        @all_objects_with_notes.sections.should be == @driver.notes_sections
+        @all_objects_with_notes.messages.should be == @messages
+        @all_objects_with_notes.messages.to_changelog.should be == @changelog
+        @all_objects_with_notes.to_changelog.should be == @changelog
+        @all_objects_with_notes.messages.to_changelog(:mode => :with_objects).should be == @changelog_full
+        @all_objects_with_notes.to_changelog(:mode => :with_objects).should be == @changelog_full
+      end
+      it "should get unversioned changelog message" do
+        @all_objects_with_notes.should be == @objects_with_notes
+        object = @objects_with_notes["test_changes"].shift
+        @all_objects_with_notes.stubs(:kept_notes).returns([object])
+        @all_objects_with_notes.should respond_to(:unversioned_only)
+        @all_objects_with_notes.unversioned_only.should be == @objects_with_notes
+      end
+    end
+  end
+
+
+  context "increasing version" do
+    before do
+      @driver.stubs(:notes_sections).returns(%w[test_changes test_bugfixes test_features])
+    end
+
+
+    context "using 'remove' as after_versioned:strategy" do
+      before do
+        @driver.stubs(:notes_after_versioned).returns({"strategy" => "remove", "section" => "test_versioning", "changelog_message" => "available on {version}"})
+        @steps = <<-STEPS
+        git fetch
+
+        git tag -a -m "  - removing files from gemspec
+            - .gitignore
+            - lastversion.gemspec
+          - loading default configuration yaml
+          - loading external configuration yaml
+        
+        Test bugfixes:
+        
+          - sorting tags according to the mask parser
+        " v0.1.0
+
+        git push --tags
+
+        git notes --ref=test_changes remove 8299243c7dac8f27c3572424a348a7f83ef0ce28
+
+        git notes --ref=test_changes remove 2fb8a3281fb6777405aadcd699adb852b615a3e4
+
+        git push origin refs/notes/test_changes
+
+        git notes --ref=test_bugfixes remove d7b0fa26ca547b963569d7a82afd7d7ca11b71ae
+
+        git push origin refs/notes/test_bugfixes
+        STEPS
+        @steps = @steps.chomp.split(/\n\n/).collect{ |step| step.gsub(/^\s{8}/, '') }
+      end
+      it "should return steps" do
+        @driver.should respond_to :increase_version_tag
+        @driver.increase_version_tag("minor", "f4cfcc2").should be == @steps
+      end
+    end
+
+
+    context "using 'keep' as after_versioned:strategy" do
+      before do
+        @driver.stubs(:notes_after_versioned).returns({"strategy" => "keep", "section" => "test_versioning", "changelog_message" => "available on {version}"})
+        @steps = <<-STEPS
+        git fetch
+
+        git tag -a -m "  - removing files from gemspec
+            - .gitignore
+            - lastversion.gemspec
+          - loading default configuration yaml
+          - loading external configuration yaml
+        
+        Test bugfixes:
+        
+          - sorting tags according to the mask parser
+        " v0.1.0
+
+        git push --tags
+
+        git notes --ref=test_versioning add -m "available on v0.1.0" 8299243c7dac8f27c3572424a348a7f83ef0ce28
+
+        git notes --ref=test_versioning add -m "available on v0.1.0" 2fb8a3281fb6777405aadcd699adb852b615a3e4
+
+        git notes --ref=test_versioning add -m "available on v0.1.0" d7b0fa26ca547b963569d7a82afd7d7ca11b71ae
+
+        git push origin refs/notes/test_versioning
+        STEPS
+        @steps = @steps.chomp.split(/\n\n/).collect{ |step| step.gsub(/^\s{8}/, '') }
+      end
+      it "should return steps" do
+        @driver.should respond_to :increase_version_tag
+        @driver.increase_version_tag("minor", "f4cfcc2").should be == @steps
+      end
+    end
+  end
+
+
+  context "checking helper methods" do
+    it "should load default notes' sections" do
+      @driver.send(:notes_sections).should be == StepUp::CONFIG["notes"]["sections"]
+    end
+  end
+end

data/spec/lib/step-up/parser/version_mask_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe StepUp::Parser::VersionMask do
+  before do
+    lambda {
+      @mask = StepUp::Parser::VersionMask.new("v0.0.0.9.9.rc9")
+    }.should_not raise_error ArgumentError
+  end
+
+
+  context "parsing" do
+    it "should parse" do
+      @mask.parse("v0.1.0.rc3").should be == [0, 1, 0, 0, 0, 3]
+      @mask.parse("v0.1.0").should be == [0, 1, 0, 0, 0, 0]
+      @mask.parse("v0.1.4.5.rc3").should be == [0, 1, 4, 5, 0, 3]
+    end
+    it "should not parse" do
+      @mask.parse("v0.1.rc3").should be_nil
+      @mask.parse("note-v0.1.0-1").should be_nil
+    end
+  end
+
+
+  context "formatting" do
+    it "should format" do
+      @mask.format([0, 1, 0, 0, 0, 3]).should be == "v0.1.0.rc3"
+      @mask.format([0, 1, 0, 0, 0, 0]).should be == "v0.1.0"
+      @mask.format([0, 1, 4, 5, 0, 3]).should be == "v0.1.4.5.rc3"
+    end
+    it "should not format" do
+      lambda {@mask.format([0, 1, 0, 0, 3])}.should raise_error ArgumentError
+      lambda {@mask.format([0, 1, 0, 0, 0, 0, 0])}.should raise_error ArgumentError
+    end
+  end
+
+
+  context "increasing version" do
+    before do
+      @mask.stubs(:version_parts).returns(%w[major minor tiny patch build rc])
+    end
+    it "should increase by parts" do
+      version = "v2.3.1.6.4.rc5"
+      @mask.increase_version(version, "major").should be == "v3.0.0"
+      @mask.increase_version(version, "minor").should be == "v2.4.0"
+      @mask.increase_version(version, "tiny").should be == "v2.3.2"
+      @mask.increase_version(version, "patch").should be == "v2.3.1.7"
+      @mask.increase_version(version, "build").should be == "v2.3.1.6.5"
+      @mask.increase_version(version, "rc").should be == "v2.3.1.6.4.rc6"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'step-up'
+require 'rspec'
+
+Dir["#{File.expand_path('../support', __FILE__)}/*.rb"].each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification 
+name: step-up
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Marcelo Manzan
+- Eric Adrien Fer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-09 00:00:00 -02:00
+default_executable: stepup
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 14
+        - 6
+        version: 0.14.6
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: StepUp manages a project's versioning through its entire life
+email: 
+- manzan@gmail.com
+- eric.fer@gmail.com
+executables: 
+- stepup
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- Rakefile
+- bin/stepup
+- lib/step-up.rb
+- lib/step-up/cli.rb
+- lib/step-up/config.rb
+- lib/step-up/config/step-up.yml
+- lib/step-up/driver/git.rb
+- lib/step-up/git_extensions.rb
+- lib/step-up/parser/version_mask.rb
+- lib/step-up/version.rb
+- spec/lib/step-up/driver/git_spec.rb
+- spec/lib/step-up/parser/version_mask_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/redoc/step-up
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: step-up
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: The best way to manage your project's versioning
+test_files: 
+- spec/lib/step-up/driver/git_spec.rb
+- spec/lib/step-up/parser/version_mask_spec.rb
+- spec/spec_helper.rb