tumbler 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+.bundle

data/CHANGELOG

@@ -0,0 +1,10 @@
+== 0.0.1
+
+* rollback version (Joshua Hull, 5c14fd9)
+
+== 0.0.1
+
+* reset version, changelog (Joshua Hull, 09e19dc)
+* Updated changelog (Joshua Hull, 161da98)
+* Bumped version from 0.0.0 to 0.0.1 (Joshua Hull, 654eb14)
+

data/Gemfile

@@ -0,0 +1,12 @@
+source :rubygems
+
+gem 'callsite'
+gem 'versionomy'
+gem 'bundler'
+gem 'json'
+
+group :development do
+  gem 'rake'
+  gem 'rspec'
+  gem 'fakeweb'
+end

data/Gemfile.lock

@@ -0,0 +1,51 @@
+--- 
+dependencies: 
+  fakeweb: 
+    group: 
+    - :development
+    version: ">= 0"
+  rake: 
+    group: 
+    - :development
+    version: ">= 0"
+  rspec: 
+    group: 
+    - :development
+    version: ">= 0"
+  versionomy: 
+    group: 
+    - :default
+    version: ">= 0"
+  json: 
+    group: 
+    - :default
+    version: ">= 0"
+  bundler: 
+    group: 
+    - :default
+    version: ">= 0"
+  callsite: 
+    group: 
+    - :default
+    version: ">= 0"
+specs: 
+- rake: 
+    version: 0.8.7
+- blockenspiel: 
+    version: 0.3.3
+- bundler: 
+    version: 0.9.26
+- callsite: 
+    version: 0.0.2
+- fakeweb: 
+    version: 1.2.8
+- json: 
+    version: 1.4.3
+- rspec: 
+    version: 1.3.0
+- versionomy: 
+    version: 0.4.0
+hash: 607cf6d6ac15a00ffd67cd35247ddf8b124dc5a8
+sources: 
+- Rubygems: 
+    uri: http://gemcutter.org

data/README.rdoc

@@ -0,0 +1,85 @@
+= Tumbler
+
+Let's make gem development fun and not at all repetitive! A set of common tasks which should save you a fair bit of typing and give you more time for doing
+useful things with your life.
+
+== The pattern
+
+Typically I want to make a gem, host it on github and tag versions. I want to use git as my source control, and use git to create sets of files. As well, I want to use Bundler to specify my dependencies, and then, I want those dependencies to automatically be in my gemspec. As well, I want to be a good citizen, and use gemspec's directly, instead of generating my gemspec from something.
+
+== Using Tumbler
+
+=== For pre-existing projects
+
+If you have a pre-existing project, and want to use Tumbler, you have to a do a few things. If you're starting from scratch, you can skip this section.
+
+For existing projects, you need to configure it to tell Tumbler to do its work. This is all done from a file at the root of your project called <tt>Tumbler</tt>. A typical <tt>Tumbler</tt> file will look something like this:
+
+  # Names the gem
+  gem_name 'my_awesome_gem'
+  
+  # Use this file to track the version
+  use_version do
+    filename 'VERSION'
+  end
+
+  # Use this file to hang onto your changelog
+  use_changelog do
+    filename 'CHANGELOG'
+  end
+
+Your version number has to only be something parsable by Versionomy. The changelog will automatically be updated when you do releases.
+
+As well, in your +Rakefile+, add the following:
+
+  require 'tumbler'
+  Tumbler.use_rake_tasks
+
+Alternately, you can have Tumbler do all the work for you. If you install Tumbler to your system gems, you can say:
+
+  tumbler . -u --name gem_name
+  
+From inside your project directory, and it will take care of all these details for you.
+
+=== Generating an application from scratch
+
+To generate an application from scratch, run the following:
+
+  tumbler your_gem_name
+  
+This will give you a skeleton of an application that you can fill out and make awesome.
+
+=== Day to day life with Tumbler as your friend
+
+Once you've got Tumbler up and running, you'll have access to the following tasks:
+
+  rake gem:build              # Build the gem
+  rake gem:install            # Install the gem
+  rake gem:push               # Push the gem
+  rake version:major:bump     # Bump version from 0.2.12 ->  1.0.0
+  rake version:major:release  # Bump version from 0.2.12 ->  1.0.0 and push
+  rake version:minor:bump     # Bump version from 0.2.12 ->  0.3.0
+  rake version:minor:release  # Bump version from 0.2.12 ->  0.3.0 and push
+  rake version:push           # Push current version into git
+  rake version:tag            # Tag current version into git
+  rake version:tiny:bump      # Bump version from 0.2.12 ->  0.2.13
+  rake version:tiny:release   # Bump version from 0.2.12 ->  0.2.13 and push
+
+Let's take a look a some common workflow:
+
+==== Releasing a new Gem
+
+You can either do
+
+  rake version:(tiny|minor|major):release
+  
+Which will bump the version, tag it in git, regenerate the changelog from your git commits and push the whole thing to rubygems and your remote or you can do it in two steps:
+
+  rake version:(tiny|minor|major):bump
+  rake version:release
+
+This gives you a chance to review the changelog and do anything else you'd like to do before taking the plunge.
+
+== What's next?
+
+I'm sure there are bugs and other common workflows that I will add/document, but basically, I just wanna type a lot less when I bump a gem, and get things done.

data/Rakefile

@@ -0,0 +1,11 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+require 'tumbler'
+Tumbler.use_rake_tasks
+
+require 'spec'
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts ||= []
+  t.spec_opts << "--options" << "spec/spec.opts"
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

data/Tumbler

@@ -0,0 +1,9 @@
+gem_name 'tumbler'
+
+use_version do
+  filename 'VERSION'
+end
+
+use_changelog do
+  filename 'CHANGELOG'
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/tumbler

@@ -0,0 +1,8 @@
+#!/usr/env ruby
+
+require 'fileutils'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'tumbler'
+
+Tumbler::CLI.run(ARGV)

data/lib/tumbler/changelog.rb

@@ -0,0 +1,62 @@
+require 'tempfile'
+require 'fileutils'
+
+class Tumbler
+  class Changelog
+    include Runner
+
+    DEFAULT_FILE = 'CHANGELOG'
+
+    attr_reader :file
+
+    def initialize(manager, &block)
+      @manager = manager
+      instance_eval(&block) if block
+    end
+
+    def filename(file)
+      @basefile = file
+      @file = File.join(@manager.base, file)
+    end
+
+    def write_version_header
+      prepend "== #{@manager.version}\n\n"
+    end
+
+    def prepend(data)
+      if @manager.noop
+        @manager.dry "Prepending #{data} to #{@basefile}"
+      else
+        Tempfile.open('changelog') do |tmp|
+          tmp.puts data
+          File.open(@file) do |f|
+            f.each do |line|
+              tmp << line
+            end
+          end
+          tmp.close
+          FileUtils.copy(tmp.path, @file)
+          File.unlink(tmp.path)
+        end
+      end
+    end
+
+    def update
+      ensure_existence
+      prepend("\n")
+      prepend(@manager.latest_changes.inject('') { |changes, change| changes << "* #{change.summary} (#{change.author}, #{change.hash})\n" })
+    end
+
+    def ensure_existence
+      File.open(@file, 'w') {|f| f << ''} unless File.exist?(@file)
+    end
+
+    def commit
+      sh "git commit #{@basefile} -m'Updated changelog'"
+    end
+
+    def base
+      @manager.base
+    end
+  end
+end

data/lib/tumbler/cli.rb

@@ -0,0 +1,69 @@
+require 'optparse'
+
+class Tumbler
+  class CLI
+    def self.run(args)
+      CLI.new(args).run
+    end
+
+    def initialize(args)
+      @options = {
+        :changelog => Changelog::DEFAULT_FILE,
+        :version => Version::INITIAL_VERSION
+      }
+      parser.parse!(args)
+    end
+    
+    def parser
+      OptionParser.new do |opts|
+        opts.banner = "Usage: tumbler name [options]"
+
+        opts.separator ""
+        opts.separator "Options:"
+
+        opts.on("-cVALUE", "--changelog=VALUE", "Set changelog file") do |v|
+          @options[:changelog] = v
+        end
+
+        opts.on("-u", "--update", "Update existing application") do |v|
+          @options[:update] = nil
+        end
+
+        opts.on("-nc", "--no-changelog", "Disable changelog") do |v|
+          @options[:changelog] = nil
+        end
+
+        opts.on("-vVALUE", "--version=VALUE", "Set version file") do |v|
+          @options[:version] = v
+        end
+
+        opts.on("-nv", "--no-value", "Disable version") do |v|
+          @options[:version] = nil
+        end
+
+        opts.on("-vNAME", "--name=NAME", "Set gem name") do |v|
+          @options[:name] = v
+        end
+
+        opts.on_tail("-h", "--help", "Show this help message.") { puts opts; exit }
+      end
+    end
+    
+    def run
+      puts @options.inspect
+      app_name = ARGV.first
+
+      if app_name.nil?
+        raise 'You must supply an application name.'
+      elsif @options.key?(:update)
+        Tumbler::Updater.new(app_name, @options).update
+      elsif File.exist?(app_name)
+        raise "There is already a directory named #{app_name}"
+      else
+        FileUtils.mkdir_p(app_name)
+        Tumbler::Generate.app(app_name, app_name, @options).write
+      end
+    end
+    
+  end
+end

data/lib/tumbler/gem.rb

@@ -0,0 +1,35 @@
+class Tumbler
+  class Gem
+    include Runner
+
+    def initialize(manager)
+      @manager = manager
+    end
+
+    def base
+      @manager.base
+    end
+
+    def push
+      build
+      sh("gem push #{built_gem_path}")
+    end
+
+    def built_gem_path
+      "#{@manager.name}-#{@manager.version.to_s}.gem"
+    end
+
+    def install
+      build
+      exec("sudo gem install #{built_gem_path}")
+    end
+
+    def spec_path
+      "#{@manager.name}.gemspec"
+    end
+
+    def build
+      sh("bundle exec gem build #{spec_path}")
+    end
+  end
+end

data/lib/tumbler/gemspec.rb

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), '..', 'tumbler') unless Kernel.const_defined?(:Tumbler)
+root = File.expand_path(File.dirname(Callsite.parse(caller).find{|c| c.filename =~ /\.gemspec$/}.filename))
+Tumbler.send(:remove_const, :Gemspec) if (Tumbler.const_defined?(:Gemspec))
+Tumbler::Gemspec = Tumbler::GemspecHelper.new(Tumbler.new(root))

data/lib/tumbler/gemspec_helper.rb

@@ -0,0 +1,38 @@
+class Tumbler
+  class GemspecHelper
+    def initialize(manager)
+      @manager = manager
+    end
+
+    def version
+      @manager.version.to_s
+    end
+
+    def name
+      @manager.name
+    end
+
+    def git_files
+      @git_files ||= Dir.chdir(@manager.base) { `git ls-files`.split("\n") }
+    end
+
+    def files(test = nil)
+      git_files.select{|f| test.nil? or f.index(test) }
+    end
+
+    def bin_files
+      git_files.select{|f| f[/^bin\//] }.map{|f| f[/bin\/(.*)/, 1]}
+    end
+
+    def inject_dependencies(gemspec)
+      @manager.bundler.dependencies.each do |dep|
+        gemspec.add_runtime_dependency(dep.name, *dep.requirements_list) if dep.groups.include?(:default)
+        gemspec.add_development_dependency(dep.name, *dep.requirements_list) if dep.groups.include?(:development)
+      end
+    end
+
+    def date
+      Time.new.strftime("%Y-%m-%d")
+    end
+  end
+end

data/lib/tumbler/generate.rb

@@ -0,0 +1,137 @@
+require 'rubygems'
+require 'erb'
+
+class Tumbler
+  class Generate
+    
+    include Runner
+    
+    def self.app(dir, name, opts = {})
+      generator = Generate.new(dir, name)
+      generator.version = opts[:version] if opts[:version]
+      generator.changelog = opts[:changelog] if opts.key?(:changelog)
+      generator.development_dependencies << ::Gem::Dependency.new('tumbler')
+      if opts[:dependencies]
+        Array(opts[:dependencies]).each do |dep|
+          generator.dependencies << (dep.is_a?(Array) ? ::Gem::Dependency.new(*dep) : ::Gem::Dependency.new(dep))
+        end
+      end
+      if opts[:development_dependencies]
+        Array(opts[:development_dependencies]).each do |dep|
+          generator.development_dependencies << (dep.is_a?(Array) ? ::Gem::Dependency.new(*dep) : ::Gem::Dependency.new(dep))
+        end
+      end
+      generator
+    end
+
+    attr_reader :development_dependencies, :dependencies, :base
+    attr_accessor :version, :changelog
+    
+    def initialize(dir, name)
+      @base = dir
+      @name = name
+      @dependencies = []
+      @development_dependencies = []
+      @version = Version::INITIAL_VERSION
+      @changelog = Changelog::DEFAULT_FILE
+    end
+
+    def write
+      write_gemspec
+      write_gemfile
+      write_version
+      write_changelog
+      write_rakefile
+      write_tumbler_config
+      sh 'git init'
+      initial_commit
+    end
+
+    def initial_commit
+      sh 'git init'
+      sh 'git add .'
+      sh 'git commit -a -m"Initial commit"'
+      sh "git tag #{@version}"
+    end
+
+    def gemfile_file
+      File.join(@base, 'Gemfile')
+    end
+
+    def config_file
+      File.join(@base, 'Tumbler')
+    end
+
+    def init_version
+      return unless @version
+      File.open(@version.file, "w") {|f| f.puts @version.value.to_s} unless File.exist?(@version.file)
+    end
+
+    def init_changelog
+      return unless @changelog
+      File.open(@changelog.file, "w") {|f| f << ''} unless File.exist?(@changelog.file)
+    end
+
+    def write_version
+      File.open(File.join(@base, Version::DEFAULT_FILE), 'w') {|f| f << @version }
+    end
+    
+    def write_gemfile
+      File.open(gemfile_file, 'w') {|f| f << generate_gemfile }
+    end
+
+    def write_rakefile
+      FileUtils.cp(template_path('Rakefile'), @base)
+    end
+
+    def write_gemspec
+      File.open(File.join(@base, "#{@name}.gemspec"), 'w') {|f| f << generate_gemspec }
+    end
+
+    def write_changelog
+      File.open(File.join(@base, @changelog), 'w') {|f| f << '' } if @changelog
+    end
+
+    def write_tumbler_config
+      File.open(config_file, 'w') {|f| f << generate_tumbler_conf}
+    end
+
+    def git_email
+      sh('git config user.email').strip rescue 'user.email'
+    end
+
+    def git_name
+      sh('git config user.name').strip rescue 'user.name'
+    end
+
+    def github_user
+      sh('git config github.user').strip rescue 'github.user'
+    end
+
+    def template_path(path)
+      File.join(File.dirname(__FILE__), '..', '..', 'template', path)
+    end
+
+    def generate_tumbler_conf
+      template = ERB.new(File.read(template_path('generic.Tumbler.erb')))
+      template.result(binding)
+    end
+
+    def generate_gemfile
+      template = ERB.new <<-EOF
+source :rubygems
+
+<% @dependencies.each do |dep|%>gem <%=dep.name.inspect%>, <%=dep.requirement.to_s.inspect%><%="\n"%><% end %>
+group(:development) do
+<% development_dependencies.each do |dep|%>  gem <%=dep.name.inspect%>, <%=dep.requirement.to_s.inspect%><%="\n"%><% end %>
+end
+      EOF
+      template.result(binding)
+    end
+
+    def generate_gemspec
+      template = ERB.new(File.read(template_path('generic.gemspec.erb')))
+      template.result(binding)
+    end
+  end
+end

data/lib/tumbler/rake_tasks.rb

@@ -0,0 +1,81 @@
+class Tumbler
+  class Raketasks
+
+    def self.register(base, name)
+      if manager = Tumbler.load(base)
+        tasks = Raketasks.new(manager)
+        tasks.activate_project_tasks(name)
+      else
+        raise "This is not properly configured for tumbler probably due to a lack of a Tumbler configuration file."
+      end
+    end
+
+    def initialize(manager)
+      @manager = manager
+    end
+
+    def activate_project_tasks(protect_namespace)
+      tasks = proc do
+        namespace :gem do
+          desc "Build the gem"
+          task :build do
+            @manager.gem.build
+          end
+
+          desc "Push the gem"
+          task :push do
+            @manager.gem.push
+          end
+
+          desc "Install the gem"
+          task :install do
+            @manager.gem.install
+          end
+        end
+
+        namespace :git do
+          task :check_clean do
+            @manager.clean? or raise("There are files that need to be committed first.")
+          end
+
+          task :check_uptodate do
+            @manager.update or raise("Unable to update first.")
+          end
+        end
+
+        namespace :version do
+        
+          desc "Tag current version into git"
+          task :tag do
+            @manager.tag
+          end
+        
+          desc "Push current version into git"
+          task :push do
+            @manager.tag_and_push
+          end
+        
+          @manager.version.field_names.each do |field|
+            namespace field do 
+              desc "Bump version from #{@manager.version.to_s} ->  #{@manager.version.value.bump(field).to_s}"
+              task :bump do
+                @manager.bump_and_commit(field)
+              end
+
+              desc "Bump version from #{@manager.version.to_s} ->  #{@manager.version.value.bump(field).to_s} and push"
+              task :release do
+                @manager.bump_and_push(field)
+              end
+            end
+          end
+        end
+      end
+
+      if protect_namespace
+        namespace protect_namespace, &tasks
+      else
+        tasks.call
+      end
+    end
+  end
+end

data/lib/tumbler/runner.rb

@@ -0,0 +1,26 @@
+class Tumbler
+  module Runner
+
+    attr_accessor :noop
+
+    def sh(cmd)
+      output, code = sh_with_code(cmd)
+      code == 0 ? output : raise(output)
+    end
+
+    def dry(message)
+      puts message
+    end
+
+    def sh_with_code(cmd)
+      if noop
+        dry("Running `#{cmd}'")
+        ['' , 0]
+      else
+        output = ''
+        Dir.chdir(base) { output = `#{cmd}` }
+        [output, $?]
+      end
+    end
+  end
+end