namelessjon-jeweler 0.6.2 → 0.6.5

data/ChangeLog.markdown

@@ -0,0 +1,7 @@
+# jeweler 0.6.5
+
+ * `jeweler --create-repo foo` now enables gem creation in addition to creating the repository
+
+# jeweler 0.6.4
+
+ * Added tasks `build` and `install` as shortcuts for `gem:build` and `gem:install`

data/README.markdown

@@ -1,39 +1,14 @@
-# Jeweler: Let us craft you the perfect gem
+# Jeweler: Craft the perfect RubyGem
 
-Rubygems are the awesome way of distributing your code to others. GitHub is the awesome way of managing the source code of your project. GitHub can even generate a Rubygem if you include a gemspec.
+Jeweler provides two things:
 
-Trouble is when developing your Rubygems on GitHub, you generally do one of the following:
+ * Rake tasks for managing gems and versioning of a <a href="http://github.com">GitHub</a> project
+ * A generator for creating kickstarting a new project
 
- * Manage the gemspec by hand
-  * ... why bother doing something by hand when you can automate it?
- * Write your own Rake stuff to create the Gem::Specification and output it to a gemspec file, and deal with keeping the Rakefile and gemspec in sync
-  * ... why keep reinventing the wheel?
- * Use hoe or echoe for generating the gemspec
-  * ... why use utilities made for the days before GitHub existed?
-  * ... why have extra stuff you aren't going to use?
+## Setting up in an existing project
 
-Jeweler was created with a few goals in mind:
+It's easy to get up and running. Update your instantiate a `Jeweler::Tasks`, and give it a block with details about your project.
 
- * Only use a Gem::Specification as configuration
- * Be one command away from version bumping and releasing
- * Store version information in one place
- * Only concern itself with git, gems, and versioning
- * Not be a requirement for using your Rakefile (you just wouldn't be able to use its tasks)
- * Use Jeweler internally. Oh the meta!
-
-## Installation
-
-Run the following if you haven't already:
-
-    gem sources -a http://gems.github.com
-
-Install the gem:
-
-    sudo gem install technicalpickles-jeweler
-
-## Configuration for an existing project
-
-Armed with the gem, we can begin diving into an example. [the-perfect-gem](http://github.com/technicalpickles/the-perfect-gem/tree) was setup as a Jeweler showcase, and a simple example:
 
     begin
       require 'jeweler'
@@ -49,132 +24,60 @@ Armed with the gem, we can begin diving into an example. [the-perfect-gem](http:
       puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
     end
 
-Here's a rundown of what's happening:
-
- * Wrap everything in a begin block, and rescue from LoadError
-  * This lets us degrade gracefully if jeweler isn't installed
- * Make a new `Jeweler::Tasks`
-   * It gets yielded a new `Gem::Specification`
-   * This is where all the configuration happens
-    * Things you definitely need to specify:
-      * `name`
-    * Things you probably want to specify:
-      * `summary`
-      * `email`
-      * `homepage`
-      * `description`
-      * `authors`
-    * Things you can specify, but have defaults
-     * `files`, defaults to `FileList["[A-Z]*.*", "{bin,generators,lib,test,spec}/**/*"]`
-    * Things you shouldn't specify:
-     * `version`, because Jeweler takes care of this for you
-    * Other things of interest
-     * `executables`, if you have any scripts
-     * `add_dependency`, if you have any dependencies
-    * Keep in mind that this is a `Gem::Specification`, so you can do whatever you would need to do to get your gem in shape
-
-## Bootstrap a new project
-
-Before proceeding, take a minute to setup your git environment, specifically your name, email address, and GitHub username
-
-    $ git config --global user.email johndoe@example.com
-    $ git config --global user.name 'John Doe'
-    $ git config --global github.user johndoe
-    $ git config --global github.token 55555555555555
-
-Jeweler provides a generator of sorts, `jeweler`. It requires only argument, the name of a repo you want to create. It also takes a few options: --[shoulda](http://github.com/thoughtbot/shoulda) and --[bacon](http://github.com/chneukirchen/bacon/tree/master). These control what type of tests are created, with the default being shoulda.
-
-    $ jeweler --create-repo the-perfect-gem
-
-Basically, this does:
-
- * Creates the the-perfect-gem directory
- * Seeds it with some basic files:
-  * `.gitignore`, with the usual suspects predefined
-  * `Rakefile`, setup with tasks for jeweler, test, rdoc, and rcov
-  * `README`, with your project name
-  * `LICENSE`, MIT, with your name prefilled
-  * `test/test_helper`, setup with shoulda, mocha, and a re-opened `Test::Unit::TestCase`
-  * `test/the_perfect_gem.rb`, placeholder failing test
-  * `lib/the_perfect_gem.rb`, placeholder library file
- * Makes it a git repo
- * Sets up `git@github.com:johndoe/jeweler.git` as the `origin` git remote
- * Makes an initial commit
- * Sets up a new repository on GitHub and pushes to it (omit --create-repo to skip this)
-
-You also probably should [enable RubyGem creation for you repository](http://github.com/blog/51-github-s-rubygem-server): Go to your project's edit page and check the 'RubyGem' box.
-
-## Overview of Jeweler workflow
-
-Here's the general idea:
-
- * Hack, commit, hack, commit, etc, etc
- * Version bump
- * Release
- * Have a delicious scotch
-
-The hacking and the scotch are up to you, but Jeweler provides rake tasks for the rest.
-
-### Versioning
-
-Versioning information is stored in `VERSION.yml`. It's a plain ol' YAML file which contains three things:
-
- * major
- * minor
- * patch
+In this example, `s` is a Gem::Specification object. See the documentation for what possible values you can set on it. 
 
-Consider, for a second, `1.5.3`.
+## Kicking off a new project
 
- * major = 1
- * minor = 5
- * patch = 3
+Jeweler provides a generator:
 
-#### Your first time
+    jeweler the-perfect-gem
 
-When you first start using Jeweler, there won't be a `VERSION.yml`, so it'll assume 0.0.0.
+This will prepare a project in the 'the-perfect-gem' directory, setup to use Jeweler.
 
-If you need some arbitrary version, you can do one of the following:
+It supports a number of options:
 
- * `rake version:write MAJOR=6 MINOR=0 PATCH=3`
- * Write `VERSION.yml` by hand (lame)
+ * --create-repo: in addition to preparing a project, it create an repo up on GitHub and enable RubyGem generation
+ * --shoulda: generate test_helper.rb and empty test ready for shoulda (this is the default)
+ * --bacon: generate spec_helper.rb and empty spec ready for bacon
 
+## Gemspec
 
-#### After that
+Jeweler handles generating a gemspec file for your project:
 
-You have a few rake tasks for doing the version bump:
+    rake gemspec
 
-    $ rake version:bump:patch # 1.5.1 -> 1.5.2
-    $ rake version:bump:minor # 1.5.1 -> 1.6.0
-    $ rake version:bump:major # 1.5.1 -> 2.0.0
+This creates a gemspec for your project. It's based on the info you give `Jeweler::Tasks`, the current version of your project, and some defaults that Jeweler provides.
 
-If you need to do an arbitrary bump, use the same task you used to create `VERSION.yml`:
+## Gem
 
-    $ rake version:write MAJOR=6 MINOR=0 PATCH=3
+Jeweler gives you tasks for building and installing your gem:
 
-The process of version bumping does a commit to your repo, so make sure your repo is in a clean state (ie nothing uncommitted).
+    rake build
+    rake install
 
-### Release it
+## Versioning
 
-It's pretty straight forward:
+Jeweler tracks the version of your project. It assumes you will be using a version in the format `x.y.z`. `x` is the 'major' version, `y` is the 'minor' version, and `z` is the patch version.
 
-    $ rake release
+Initially, your project starts out at 0.0.0. Jeweler provides Rake tasks for bumping the version:
 
-This takes care of:
+    rake version:bump:major
+    rake version:bump:minor
+    rake version:bump:patch
 
- * Generating a `.gemspec` for you project, with the version you just bumped to
- * Commit and push the updated `.gemspec`
- * Create a tag
- * Push the tag
+## Releasing
 
-### Play the waiting game
+Jeweler handles releasing your gem into the wild:
 
-How do you know when your gem is built? [Has My Gem Built Yet](http://hasmygembuiltyet.org/) was specifically designed to answer that question.
+    rake release
 
-If it happens to be down, you can also check out the GitHub Gem repo's [list](http://gems.github.com/list). Just search for youname-yourrepo.s
+It does the following for you:
 
-### Putting it all together
+ * Regenerate the gemspec to the latest version of your project
+ * Push to GitHub (which results in a gem being build)
+ * Tag the version and push to GitHub
 
-    <hack, hack, hack, commit>
-    $ rake version:bump:patch release
+## Links
 
-Now browse to http://gems.github.com/yourname/yourproject, and wait for it to be built.
+ * [Bugs](http://technicalpickles.lighthouseapp.com/projects/23560-jeweler/overview)
+ * [Donate](http://pledgie.org/campaigns/2604)

data/Rakefile

@@ -12,16 +12,16 @@ $:.unshift('lib')
 
 begin
   require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "jeweler"
-    gemspec.executables = "jeweler"
-    gemspec.summary = "Simple and opinionated helper for creating Rubygem projects on GitHub"
-    gemspec.email = "josh@technicalpickles.com"
-    gemspec.homepage = "http://github.com/technicalpickles/jeweler"
-    gemspec.description = "Simple and opinionated helper for creating Rubygem projects on GitHub"
-    gemspec.authors = ["Josh Nichols"]
-    gemspec.files =  FileList["[A-Z]*", "{bin,generators,lib,test}/**/*", 'lib/jeweler/templates/.gitignore']
-    gemspec.add_dependency 'schacon-git'
+  Jeweler::Tasks.new do |s|
+    s.name = "jeweler"
+    s.executables = "jeweler"
+    s.summary = "Simple and opinionated helper for creating Rubygem projects on GitHub"
+    s.email = "josh@technicalpickles.com"
+    s.homepage = "http://github.com/technicalpickles/jeweler"
+    s.description = "Simple and opinionated helper for creating Rubygem projects on GitHub"
+    s.authors = ["Josh Nichols"]
+    s.files =  FileList["[A-Z]*", "{bin,generators,lib,test}/**/*", 'lib/jeweler/templates/.gitignore']
+    s.add_dependency 'schacon-git'
   end
 rescue LoadError
   puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"

data/TODO

@@ -1,7 +1,18 @@
+ * use some sort of logger instead of stdout and stderr
+ * jeweler --delete-repo 
+ * output gemspec as yaml
+ * move interactions with github into separate class
+ * use Net::HTTP.post_form instead of `` for enabling gem creation
  * Generators
    * Rails generator for making a plugin that's Jeweler enabled
    * Support rspec?
+   * Support test/unit
+   * Change generated test filename (test_foo not foo_test)
+ * better error handling during generation
+   * directory existing
+   * no github.token configured
+   * no github.username configured
  * Releasing
-  * Create tag based on version
-  * Push tags
-  * Open hasmygembuiltyet.org
+  * Open hasmygembuiltyet.org
+ * enable runcoderun by default
+ * Add --summary option to generator

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-patch: 2
-major: 0
-minor: 6
+:patch: 5
+:major: 0
+:minor: 6

data/lib/jeweler.rb

@@ -1,20 +1,15 @@
 require 'date'
+require 'rubygems/builder'
 
-require 'jeweler/bumping'
-require 'jeweler/versioning'
+require 'jeweler/version'
 require 'jeweler/gemspec'
 require 'jeweler/errors'
 require 'jeweler/generator'
-require 'jeweler/release'
 
 require 'jeweler/tasks'
 
 # A Jeweler helps you craft the perfect Rubygem. Give him a gemspec, and he takes care of the rest.
 class Jeweler
-  include Jeweler::Bumping
-  include Jeweler::Versioning
-  include Jeweler::Gemspec
-  include Jeweler::Release
 
   attr_reader :gemspec
   attr_accessor :base_dir
@@ -23,12 +18,214 @@ class Jeweler
     raise(GemspecError, "Can't create a Jeweler with a nil gemspec") if gemspec.nil?
     @gemspec = gemspec
     @base_dir = base_dir
+    
+    if @gemspec.files.nil? || @gemspec.files.empty?
+      @gemspec.files = FileList["[A-Z]*.*", "{bin,generators,lib,test,spec}/**/*"]
+    end
 
-    @gemspec.files ||= FileList["[A-Z]*.*", "{bin,generators,lib,test,spec}/**/*"]
+    @gemspec.has_rdoc = true
+    @gemspec.rdoc_options << '--inline-source' << '--charset=UTF-8'
+    @gemspec.extra_rdoc_files ||=  FileList["[A-Z]*.*"]
 
     if File.exists?(File.join(base_dir, '.git'))
       @repo = Git.open(base_dir)
     end
+
+    @version = Jeweler::Version.new(@base_dir)
+  end
+
+  # Major version, as defined by the gemspec's Version module.
+  # For 1.5.3, this would return 1.
+  def major_version
+    @version.major
+  end
+
+  # Minor version, as defined by the gemspec's Version module.
+  # For 1.5.3, this would return 5.
+  def minor_version
+    @version.minor
+  end
+
+  # Patch version, as defined by the gemspec's Version module.
+  # For 1.5.3, this would return 5.
+  def patch_version
+    @version.patch
+  end
+
+  # Human readable version, which is used in the gemspec.
+  def version
+    @version.to_s
+  end
+
+  # Writes out the gemspec
+  def write_gemspec
+    self.refresh_version
+
+    helper = gemspec_helper do |s|
+      s.version = self.version
+      s.date = Time.now
+    end
+
+    helper.write
+
+    puts "Generated: #{helper.path}"
+  end
+
+  # Validates the project's gemspec from disk in an environment similar to how 
+  # GitHub would build from it. See http://gist.github.com/16215
+  def validate_gemspec
+    begin
+      gemspec_helper.parse
+      puts "#{gemspec_path} is valid."
+    rescue Exception => e
+      puts "#{gemspec_path} is invalid. See the backtrace for more details."
+      raise
+    end
   end
+
+
+  # is the project's gemspec from disk valid?
+  def valid_gemspec?
+    gemspec_helper.valid?
+  end
+
+  # parses the project's gemspec from disk without extra sanity checks
+  def unsafe_parse_gemspec(data = nil)
+    data ||= File.read(gemspec_path)
+    eval(data, binding, gemspec_path)
+  end
+
+  def build_gem
+    parsed_gemspec = unsafe_parse_gemspec()
+    Gem::Builder.new(parsed_gemspec).build
+
+    pkg_dir = File.join(@base_dir, 'pkg')
+    FileUtils.mkdir_p pkg_dir
+
+    gem_filename = File.join(@base_dir, parsed_gemspec.file_name)
+    FileUtils.mv gem_filename, pkg_dir
+  end
+
+  def install_gem
+    command = "sudo gem install #{gem_path}"
+    $stdout.puts "Executing #{command.inspect}:"
+    sh command
+  end
+
+  # Bumps the patch version.
+  #
+  # 1.5.1 -> 1.5.2
+  def bump_patch_version(options = {})
+    options = version_writing_options(options)
+
+    @version.bump_patch
+    @version.write
+
+    commit_version if options[:commit]
+  end
+
+  # Bumps the minor version.
+  #
+  # 1.5.1 -> 1.6.0
+  def bump_minor_version(options = {})
+    options = version_writing_options(options)
+
+    @version.bump_minor
+    @version.write
+
+    commit_version if options[:commit]
+  end
+
+  # Bumps the major version.
+  #
+  # 1.5.1 -> 2.0.0
+  def bump_major_version(options = {})
+    options = version_writing_options(options)
+
+    @version.bump_major
+    @version.write
+
+    commit_version if options[:commit]
+  end
+
+  # Bumps the version, to the specific major/minor/patch version, writing out the appropriate version.rb, and then reloads it.
+  def write_version(major, minor, patch, options = {})
+    options = version_writing_options(options)
+
+    @version.update_to major, minor, patch
+    @version.write
+
+    @gemspec.version = @version.to_s
+
+    commit_version if options[:commit]
+  end
+
+
+  def release
+    @repo.checkout('master')
+
+    raise "Hey buddy, try committing them files first" if any_pending_changes?
+
+    write_gemspec()
+
+    @repo.add(gemspec_path)
+    $stdout.puts "Committing #{gemspec_path}"
+    @repo.commit("Regenerated gemspec for version #{version}")
+
+    $stdout.puts "Pushing master to origin"
+    @repo.push
+
+    $stdout.puts "Tagging #{release_tag}"
+    @repo.add_tag(release_tag)
+
+    $stdout.puts "Pushing #{release_tag} to origin"
+    @repo.push('origin', release_tag)
+  end
+
+  def release_tag
+    @release_tag ||= "v#{version}"
+  end
+
+  protected
+
+  def version_writing_options(options)
+    {:commit => true}.merge(options)
+  end
+
+  def commit_version
+    if @repo
+      @repo.add('VERSION.yml')
+      @repo.commit("Version bump to #{version}", 'VERSION.yml')
+    end
+  end
+
+  def refresh_version
+    @version.refresh
+  end
+
+  def gemspec_helper(&block)
+    GemSpecHelper.new(@gemspec, @base_dir, &block)
+  end
+
+  def gemspec_path
+    gemspec_helper.path
+  end
+
+  def gem_path
+    parsed_gemspec = unsafe_parse_gemspec()
+    File.join(@base_dir, 'pkg', parsed_gemspec.file_name)
+  end
+
+  def any_pending_changes?
+    unless ENV['JEWELER_DEBUG'].nil? || ENV['JEWELER_DEBUG'].squeeze == ''
+      require 'ruby-debug'; breakpoint
+    end
+    !(@repo.status.added.empty? && @repo.status.deleted.empty? && @repo.status.changed.empty?)
+  end
+
+  protected
+    def any_pending_changes?
+      !(@repo.status.added.empty? && @repo.status.deleted.empty? && @repo.status.changed.empty?)
+    end
 end