tumbler 0.0.1

data/lib/tumbler/updater.rb

@@ -0,0 +1,87 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+class Tumbler
+  class Updater
+
+    def initialize(dir, opts = nil)
+      @dir = dir
+      @name = opts && opts[:name] || File.basename(File.expand_path(dir))
+      raise "Couldn't find #{gemspec_path}" unless File.exist?(gemspec_path)
+    end
+
+    def update
+      upgrade_deps
+      upgrade_version
+      upgrade_changelog
+      upgrade_rakefile
+    end
+
+    def upgrade_deps
+      if File.exist?(gemfile_path)
+        gemspec = File.read(gemspec_path)
+        unless gemspec[/add_bundler_dependencies/] || gemspec[/inject_dependencies/]
+          @tainted_gemspec = true
+          File.open(gemspec_path, 'a') do |g|
+            g << <<-HERE_DOC
+raise # (see below)
+
+# You probably want to use inject the dependencies using either
+# add_bundler_depenedencies or Tumbler::Gemspec.inject_dependencies(spec) (where spec is your Gemspec)
+            HERE_DOC
+          end
+        end
+      end
+    end
+
+    def upgrade_version
+      unless File.exists?(version_path)
+        # go to rubygems and get it
+        gem_data = JSON.parse(Net::HTTP.get(URI.parse("http://rubygems.org/api/v1/gems/#{URI.escape(@name)}.json")))
+        version = gem_data['version']
+        File.open(version_path, 'w') {|f| f << version}
+      end
+    end
+
+    def upgrade_changelog
+      unless File.exists?(changelog_path)
+        File.open(changelog_path, 'w'){ |f| f << '' }
+      end
+    end
+
+    def upgrade_rakefile
+      create_rakefile and return if !File.exist?(rakefile_path)
+      rakefile = File.read(rakefile_path)
+      if rakefile !~ /Tumbler.use_rake_tasks/
+        File.open(rakefile_path, 'a') {|f| f.puts "\n\n# automatically added Tumbler tasks\n\nrequire 'tumbler'\nTumbler.use_rake_tasks"}
+      end
+    end
+
+    def rakefile_path
+      File.join(@dir, 'Rakefile')
+    end
+
+    def create_rakefile
+      File.open(rakefile_path, 'w') { |f|
+        f.puts "require 'tumbler'\nnTumbler.use_rake_tasks"
+      }
+    end
+
+    def version_path
+      File.join(@dir, Version::DEFAULT_FILE)
+    end
+
+    def changelog_path
+      File.join(@dir, Changelog::DEFAULT_FILE)
+    end
+
+    def gemspec_path
+      File.join(@dir, "#{@name}.gemspec")
+    end
+
+    def gemfile_path
+      File.join(@dir, 'Gemfile')
+    end
+  end
+end

data/lib/tumbler/version.rb

@@ -0,0 +1,57 @@
+class Tumbler
+  class Version
+    include Runner
+
+    attr_reader :file, :basefile, :field_names
+
+    DEFAULT_FILE = 'VERSION'
+    DEFAULT_FIELD = [:major, :minor, :tiny]
+    INITIAL_VERSION = '0.0.0'
+
+    def initialize(manager, &block)
+      @manager = manager
+      filename(DEFAULT_FILE)
+      fields(DEFAULT_FIELD)
+      instance_eval(&block) if block
+      reload
+    end
+
+    def fields(f)
+      @field_names = (f == :all ? @version.field_names : f)
+    end
+
+    def reload
+      @version = Versionomy.parse(File.exist?(file) ? File.read(file).strip : '0.0.0')
+    end  
+
+    def filename(file)
+      @basefile = file
+      @file = File.join(@manager.base, file)
+    end
+
+    def value
+      @version
+    end
+
+    def to_s
+      value.to_s
+    end
+
+    def bump(level)
+      if @manager.noop
+        @manager.dry "Bumping version to #{bump(level).to_s}"
+      else
+        File.open(file, 'w') {|f| f << @version.bump(level).to_s}
+        reload
+      end
+    end
+    
+    def commit(from)
+      sh "git commit #{@basefile} -m'Bumped version from #{from} to #{to_s}'"
+    end
+    
+    def base
+      @manager.base
+    end
+  end
+end

data/lib/tumbler.rb

@@ -0,0 +1,178 @@
+require 'callsite'
+require 'versionomy'
+require 'bundler'
+
+Callsite.activate_kernel_dir_methods
+$LOAD_PATH << __DIR__
+
+require 'tumbler/runner'
+require 'tumbler/updater'
+require 'tumbler/rake_tasks'
+require 'tumbler/version'
+require 'tumbler/gemspec_helper'
+require 'tumbler/changelog'
+require 'tumbler/generate'
+require 'tumbler/gem'
+require 'tumbler/cli'
+
+class Tumbler
+  def self.load_version(filename = Version::DEFAULT_FILE)
+    File.read(File.join(__DIR__, '..', filename))
+  end
+
+  VERSION = Tumbler.load_version
+
+  include Runner
+  
+  Change = Struct.new(:hash, :author, :summary)
+  
+  attr_reader :base, :version, :changelog, :gem, :name
+  attr_accessor :noop
+
+  def self.use_rake_tasks(name = nil)
+    root = File.dirname(Callsite.parse(caller).find{|c| c.filename =~ /Rakefile/}.filename)
+    Tumbler::Raketasks.register(File.expand_path(root), name)
+  end
+
+  def self.load(base)
+    File.exist?(File.join(base, 'Tumbler')) ? new(base) : nil
+  end
+
+  def set_version(version)
+    @version = Version.new
+  end
+
+  def gem_name(name)
+    @name = name
+  end
+
+  def bundler
+    @definition ||= Bundler::Dsl.evaluate(gemfile_path)
+  end
+
+  def config_path
+    File.join(@base, 'Tumbler')
+  end
+
+  def gemfile_path
+    File.join(@base, 'Gemfile')
+  end
+
+  def gemspec_path
+    File.join(@base, "#{@name}.gemspec")
+  end
+
+  def lockfile_path
+    File.join(@base, 'Gemfile.lock')
+  end
+
+  def use_version(&block)
+    @version = Version.new(self, &block)
+  end
+
+  def use_gem(&block)
+    @gem.instance_eval(block)
+  end
+
+  def use_changelog(&block)
+    @changelog = Changelog.new(self, &block)
+  end
+
+  def reset
+    @version = nil
+    @changelog = nil
+  end
+
+  def bump_and_commit(field)
+    guard_clean
+    @changelog.update if @changelog
+    bump(field)
+    if @changelog
+      @changelog.write_version_header
+      @changelog.commit
+    end
+  end
+
+  def tag_and_push
+    guard_clean
+    guard_already_tagged
+    tag
+    push
+  end
+
+  def bump_and_push(field)
+    revert_on_error {
+      bump_and_commit(field)
+      tag_and_push
+    }
+  end
+
+  def current_revision
+    sh('git show --pretty=format:%H').split(/\n/)[0].strip
+  end
+
+  def revert_on_error
+    current_ref = current_revision
+    begin
+      yield
+    rescue
+      sh "git reset --hard #{current_ref}"
+      raise
+    end
+  end
+
+  def guard_clean
+    clean? or raise("There are files that need to be committed first.")
+  end
+
+  def guard_already_tagged
+    sh('git tag').split(/\n/).include?(@version.to_s) and raise("This tag has already been committed to the repo.")
+  end
+
+  def bump(level)
+    from = @version.to_s
+    @version.bump(level)
+    @version.commit(from)
+  end
+
+  def clean?
+    sh("git ls-files -dm").split("\n").size.zero?
+  end
+
+  def push
+    sh "git push --all"
+    sh "git push --tags"
+  end
+
+  def tag
+    sh "git tag #{@version.to_s}"
+  end
+
+  def commit(msg)
+    sh "git commit #{@version.basefile} -m'#{msg}'"
+  end
+
+  def tags
+    sh('git tag').split(/\n/)
+  end
+
+  def reload
+    reset
+    @gem = Gem.new(self)
+    instance_eval(File.read(config_path), config_path, 1)
+  end
+
+  def latest_changes
+    changes = sh("git log --pretty=format:'%h (%aN) %s' --no-color #{@version}..HEAD").
+      scan(/([a-f0-9]{7}) \((.*?)\) (.*)$/).
+      map{|line| Change.new(line[0], line[1], line[2])}
+  end
+
+  private
+  def initialize(base)
+    @base = base
+    reload
+    @noop = true if ENV['DRY'] == '1'
+  end
+
+end

data/spec/bin_bijou_spec.rb

@@ -0,0 +1,67 @@
+require 'spec/spec_helper'
+
+describe 'bin/tumbler' do
+  before(:each) do
+    @bin = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'tumbler'))
+    @target = temp_dir('tmp')
+  end
+
+  after(:each) do
+    FileUtils.rm_rf @target
+    $".delete "tumbler/gemspec.rb" # we need to delete this so each gemspec can be generated fresh
+  end
+
+  context 'creation' do
+    it "should generate an app" do
+      Dir.chdir(@target) {`bundle exec ruby #{@bin} test_gem`}
+      $?.should == 0
+      tumbler = Tumbler.new(File.join(@target, 'test_gem'))
+      tumbler.version.to_s.should == '0.0.0'
+      tumbler.bundler.dependencies.first.name.should == 'tumbler'
+      tumbler.bundler.dependencies.first.requirements_list.should == ['>= 0']
+      tumbler.bundler.dependencies.first.groups.should == [:development]
+    end
+  end
+  
+  context 'upgrading' do
+    before(:each) do
+      Dir.chdir(@target) {`bundle exec ruby #{@bin} rails`}
+    end
+    
+    it "should do nothing on a normal existing tumbler app" do
+      tumbler = Tumbler.new(File.join(@target, 'rails'))
+      version_file = File.read(tumbler.version.file)
+      changelog_file = File.read(tumbler.changelog.file)
+      gemfile_file = File.read(tumbler.gemfile_path)
+      gemspec_file = File.read(tumbler.gemspec_path)
+      Dir.chdir(@target) {`bundle exec ruby #{@bin} rails -u`}
+      $?.should == 0
+      version_file.should == File.read(tumbler.version.file)
+      changelog_file.should == File.read(tumbler.changelog.file)
+      gemfile_file.should == File.read(tumbler.gemfile_path)
+      gemspec_file.should == File.read(tumbler.gemspec_path)
+    end
+
+    it "should work from inside the directory" do
+      tumbler = Tumbler.new(File.join(@target, 'rails'))
+      version_file = File.read(tumbler.version.file)
+      changelog_file = File.read(tumbler.changelog.file)
+      gemfile_file = File.read(tumbler.gemfile_path)
+      gemspec_file = File.read(tumbler.gemspec_path)
+      Dir.chdir("#{@target}/rails") {`bundle exec ruby #{@bin} . -u --name rails`}
+      $?.should == 0
+      version_file.should == File.read(tumbler.version.file)
+      changelog_file.should == File.read(tumbler.changelog.file)
+      gemfile_file.should == File.read(tumbler.gemfile_path)
+      gemspec_file.should == File.read(tumbler.gemspec_path)
+    end
+
+    it "should not work if the directory and gemspec mismatch and you don't supply a name" do
+      tumbler = Tumbler.new(File.join(@target, 'rails'))
+      FileUtils.mv("#{@target}/rails/rails.gemspec", "#{@target}/rails/notrails.gemspec")
+      Dir.chdir(@target) {`bundle exec ruby #{@bin} rails -u`}
+      $?.exitstatus.should == 1
+    end
+
+  end
+end

data/spec/changelog_spec.rb

@@ -0,0 +1,52 @@
+require 'spec/spec_helper'
+
+describe Tumbler::Changelog do
+
+  after(:each) do
+    $".delete "tumbler/gemspec.rb" # we need to delete this so each gemspec can be generated fresh
+  end
+
+  it "should generate a changelog" do
+    create_app('test') { |tumbler|
+      tumbler.sh 'touch file1'
+      tumbler.sh 'git add file1'
+      tumbler.sh 'git commit file1 -m"added file1"'
+      tumbler.sh 'touch file2'
+      tumbler.sh 'git add file2'
+      tumbler.sh 'git commit file2 -m"added file2"'
+      tumbler.bump_and_push(:tiny)
+      tumbler.version.to_s.should == '0.0.1'
+      changelog = File.read(tumbler.changelog.file)
+      changelog.should match(/== 0\.0\.1\s+\* added file2 \(.*?, [a-f0-9]{7}\)\s+\* added file1 \(.*?, [a-f0-9]{7}\)/)
+    }
+  end
+
+  it "should not perform any changelog activity when the option isn't specified" do
+    create_app('test', :changelog => nil) { |tumbler|
+      tumbler.sh 'touch file1'
+      tumbler.sh 'git add file1'
+      tumbler.sh 'git commit file1 -m"added file1"'
+      tumbler.sh 'touch file2'
+      tumbler.sh 'git add file2'
+      tumbler.sh 'git commit file2 -m"added file2"'
+      tumbler.bump_and_push(:tiny)
+      tumbler.version.to_s.should == '0.0.1'
+      File.exist?(File.join(tumbler.base, 'CHANGELOG')).should be_false
+    }
+  end
+  
+  it "should rollback the entire set of commits when the remote is unreachable" do
+    create_app('test', :changelog => nil, :remote => 'ssh://ijustmadethisupisadomain.com/what_you_say.git') { |tumbler|
+      tumbler.sh 'touch file1'
+      tumbler.sh 'git add file1'
+      tumbler.sh 'git commit file1 -m"added file1"'
+      tumbler.sh 'touch file2'
+      tumbler.sh 'git add file2'
+      tumbler.sh 'git commit file2 -m"added file2"'
+      current_rev = tumbler.current_revision
+      proc {tumbler.bump_and_push(:tiny)}.should raise_error
+      tumbler.sh('git log').split(/\n/)[0].should == "commit #{current_rev}"
+    }
+  end
+
+end

data/spec/gemspec_spec.rb

@@ -0,0 +1,38 @@
+require 'spec/spec_helper'
+
+describe Tumbler::GemspecHelper do
+  before(:each) do
+    @dir, @app = create_bare_app('test')
+    @helper = Tumbler::GemspecHelper.new(@app)
+  end
+  
+  after(:each) do
+    FileUtils.rm_rf(@dir)
+  end
+  
+  it "should have a name" do
+    @helper.name.should == 'test'
+  end
+
+  it "should have a version number" do
+    @helper.version.should == '0.0.0'
+  end
+
+  it "should have files" do
+    @helper.files.should == ["CHANGELOG", "Gemfile", "Rakefile", "Tumbler", "VERSION", "test.gemspec"]
+  end
+
+  it "should have a date" do
+    @helper.date.should == Time.new.strftime("%Y-%m-%d")
+  end
+
+  it "should inject_dependencies" do
+    spec = Gem::Specification.new
+    File.open("#{@app.base}/Gemfile", 'a') {|f| f.puts "gem 'test', '>= 0.0.5'"}
+    @app.reload
+    @helper.inject_dependencies(spec)
+    spec.runtime_dependencies.should == [Gem::Dependency.new('test', '>= 0.0.5')]
+    spec.development_dependencies.should == [Gem::Dependency.new('tumbler', '>= 0', :development)]
+  end
+
+end

data/spec/generate_spec.rb

@@ -0,0 +1,50 @@
+require 'spec/spec_helper'
+
+describe Tumbler::Generate do
+
+  after(:each) do
+    $".delete "tumbler/gemspec.rb" # we need to delete this so each gemspec can be generated fresh
+  end
+
+  it "should suppress changelog creation if disabled" do
+    temp_dir('test') do |test_dir|
+      Tumbler::Generate.app(test_dir, 'mygem', :changelog => nil).write
+      File.exist?(File.join(test_dir, "CHANGELOG")).should be_false
+    end
+  end
+
+  it "should generate a gemspec" do
+    temp_dir('test') do |test_dir|
+      Tumbler::Generate.app(test_dir, 'mygem').write
+      spec = Gem::Specification.load("#{test_dir}/mygem.gemspec")
+      spec.dependencies.should == [Gem::Dependency.new('tumbler', '>=0', :development)]
+    end
+  end
+
+  it "should generate a Rakefile" do
+    temp_dir('test') do |test_dir|
+      Tumbler::Generate.app(test_dir, 'mygem').write
+      File.exist?("#{test_dir}/Rakefile").should be_true
+    end
+  end
+
+  it "should accept an extra dependency" do
+    temp_dir('test2') do |test_dir|
+      Tumbler::Generate.app(test_dir, 'mygem', :dependencies => 'eventmachine').write
+      spec = Gem::Specification.load("#{test_dir}/mygem.gemspec")
+      spec.dependencies.size.should == 2
+      spec.dependencies.should include(Gem::Dependency.new('tumbler', '>=0', :development))
+      spec.dependencies.should include(Gem::Dependency.new('eventmachine', '>=0', :runtime))
+    end
+  end
+
+  it "should accept an extra dependency with a version" do
+    temp_dir('test2') do |test_dir|
+      Tumbler::Generate.app(test_dir, 'mygem', :dependencies => [['eventmachine', '>=1.0.0']]).write
+      spec = Gem::Specification.load("#{test_dir}/mygem.gemspec")
+      spec.dependencies.size.should == 2
+      spec.dependencies.should include(Gem::Dependency.new('tumbler', '>=0', :development))
+      spec.dependencies.should include(Gem::Dependency.new('eventmachine', '>=1.0.0', :runtime))
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+specdoc
+--loadby
+mtime
+--reverse
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+require 'tempfile'
+require 'fileutils'
+
+$LOAD_PATH << File.basename(__FILE__)
+$LOAD_PATH << File.join(File.basename(__FILE__), '..', 'lib')
+
+require 'tumbler'
+
+def create_app(name, opts = {})
+  temp_dir(name) do |dir|
+    temp_dir("remote-#{name}.git") do |remote_dir|
+      Tumbler::Generate.app(dir, name, opts).write
+      tumbler = Tumbler.new(dir)
+
+      Dir.chdir(remote_dir) { `git --bare init` }
+
+      remote = opts[:remote] || "file://#{remote_dir}"
+
+      Dir.chdir(dir) {
+        `git remote add origin #{remote}`
+        `git push origin master`
+      }
+
+      yield tumbler
+    end
+  end
+end
+
+def create_bare_app(name, opts = {})
+  dir = temp_dir(name)
+  Tumbler::Generate.app(dir, name, opts).write
+  tumbler = Tumbler.new(dir)
+  [dir, tumbler]
+end
+
+def temp_dir(name)
+  dir = File.join(Dir.tmpdir, rand(10000).to_s, "#{Process.pid}-#{name}")
+  FileUtils.rm_rf(dir)
+  FileUtils.mkdir_p(dir)
+  if block_given?
+    begin
+      yield dir
+    ensure
+      FileUtils.rm_rf(dir)
+    end
+  else
+    dir
+  end
+end

data/spec/updater_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'fakeweb'
+
+describe Tumbler::Updater do
+  before(:each) do
+    @bin = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'tumbler'))
+    @target = temp_dir('tmp')
+    Dir.chdir(@target) {`bundle exec ruby #{@bin} rails`}
+  end
+
+  after(:each) do
+    FileUtils.rm_rf @target
+    $".delete "tumbler/gemspec.rb" # we need to delete this so each gemspec can be generated fresh
+  end
+
+  it "should fetch the version number" do
+    FakeWeb.allow_net_connect = false
+    FakeWeb.register_uri(:get, "http://rubygems.org/api/v1/gems/rails.json", :body => '{ "name": "rails", "info": "Rails is a framework for building web-application using CGI, FCGI, mod_ruby, or WEBrick on top of either MySQL, PostgreSQL, SQLite, DB2, SQL Server, or Oracle with eRuby- or Builder-based templates.", "version": "2.3.5", "version_downloads": 2451, "authors": "David Heinemeier Hansson", "downloads": 134451, "project_uri": "http://rubygems.org/gems/rails", "gem_uri": "http://rubygems.org/gems/rails-2.3.5.gem", "dependencies": { "runtime": [ { "name": "activesupport", "requirements": ">= 2.3.5" } ], "development": [ ] }}')
+    File.unlink("#{@target}/rails/VERSION")
+    Tumbler::Updater.new("#{@target}/rails", :name => 'rails').update
+    File.read("#{@target}/rails/VERSION").should == '2.3.5'
+  end
+
+  it "should generate a CHANGELOG" do
+    File.unlink("#{@target}/rails/CHANGELOG")
+    Tumbler::Updater.new("#{@target}/rails", :name => 'rails').update
+    File.exist?("#{@target}/rails/CHANGELOG").should be_true
+  end
+  
+  it "should not append anything to the Rakefile as it already has the tumbler tasks in it" do
+    rakefile = File.read("#{@target}/rails/Rakefile")
+    Tumbler::Updater.new("#{@target}/rails", :name => 'rails').update
+    File.read("#{@target}/rails/Rakefile").should == rakefile
+  end
+  
+  it "should append the Tumbler tasks if they don't already exist" do
+    File.open("#{@target}/rails/Rakefile", 'w') {|f| f.puts '# Some other rake file'}
+    Tumbler::Updater.new("#{@target}/rails", :name => 'rails').update
+    File.read("#{@target}/rails/Rakefile").scan(/require 'tumbler'\nTumbler\.use_rake_tasks/).size.should == 1
+  end
+  
+  it "should not append anything to the gemspec if it already is using tumbler" do
+    gemspec = File.read("#{@target}/rails/rails.gemspec")
+    Tumbler::Updater.new("#{@target}/rails", :name => 'rails').update
+    File.read("#{@target}/rails/rails.gemspec").should == gemspec
+  end
+  
+  it "should append inject deps if its not there already" do
+    File.open("#{@target}/rails/Rakefile", 'w') {|f| f.puts '# Some other gemspec file'}
+    Tumbler::Updater.new("#{@target}/rails", :name => 'rails').update
+    File.read("#{@target}/rails/rails.gemspec").scan(/Tumbler::Gemspec.inject_dependencies/).size.should == 1
+  end
+  
+end

data/spec/version_spec.rb

@@ -0,0 +1,48 @@
+require 'spec/spec_helper'
+
+describe 'Tumbler#version' do
+  it "should read the current version" do
+    create_app('test', :version => '0.1.2') { |tumbler|
+      tumbler.version.to_s.should == '0.1.2'
+    }
+  end
+
+  it "should bump the current version by minor" do
+    create_app('test', :version => '0.1.2') { |tumbler|
+      tumbler.bump_and_push(:minor)
+      tumbler.version.to_s.should == '0.2.0'
+      tumbler.tags.should include('0.2.0')
+    }
+  end
+
+  it "should bump the current version by tiny" do
+    create_app('test', :version => '0.1.2') { |tumbler|
+      tumbler.bump_and_push(:tiny)
+      tumbler.version.to_s.should == '0.1.3'
+    }
+  end
+
+  it "should bump the current version by major" do
+    create_app('test', :version => '0.1.2') { |tumbler|
+      tumbler.bump_and_push(:major)
+      tumbler.version.to_s.should == '1.0.0'
+    }
+  end
+
+  it "should bump the current version by major" do
+    create_app('test', :version => '0.1.2') { |tumbler|
+      tumbler.bump_and_push(:major)
+      tumbler.version.to_s.should == '1.0.0'
+    }
+  end
+
+  it "should not let you tag the same version twice" do
+    create_app('test', :version => '0.1.2') { |tumbler|
+      tumbler.bump_and_push(:major)
+      tumbler.version.to_s.should == '1.0.0'
+      proc {tumbler.tag_and_push(:major)}.should raise_error
+      
+    }
+  end
+
+end