gohanlonllc-jeweler 0.11.1.20090513153819

data/lib/jeweler/generator.rb

@@ -0,0 +1,284 @@
+require 'git'
+require 'erb'
+
+require 'net/http'
+require 'uri'
+
+require 'jeweler/generator/bacon_mixin'
+require 'jeweler/generator/micronaut_mixin'
+require 'jeweler/generator/minitest_mixin'
+require 'jeweler/generator/rspec_mixin'
+require 'jeweler/generator/shoulda_mixin'
+require 'jeweler/generator/testunit_mixin'
+
+class Jeweler
+  class NoGitUserName < StandardError
+  end
+  class NoGitUserEmail < StandardError
+  end
+  class FileInTheWay < StandardError
+  end
+  class NoGitHubRepoNameGiven < StandardError
+  end
+  class NoGitHubUser < StandardError
+  end
+  class NoGitHubToken < StandardError
+  end
+  class GitInitFailed < StandardError
+  end    
+
+  class Generator    
+    attr_accessor :target_dir, :user_name, :user_email, :summary, :testing_framework,
+                  :project_name, :github_username, :github_token,
+                  :repo, :should_create_repo, :should_use_cucumber, :should_setup_rubyforge
+
+    DEFAULT_TESTING_FRAMEWORK = :shoulda
+
+    def initialize(project_name, options = {})
+      if project_name.nil? || project_name.squeeze.strip == ""
+        raise NoGitHubRepoNameGiven
+      end
+
+      self.project_name   = project_name
+
+      self.testing_framework  = (options[:testing_framework] || DEFAULT_TESTING_FRAMEWORK).to_sym
+      begin
+        generator_mixin_name = "#{self.testing_framework.to_s.capitalize}Mixin"
+        generator_mixin = self.class.const_get(generator_mixin_name)
+        extend generator_mixin
+      rescue NameError => e
+        raise ArgumentError, "Unsupported testing framework (#{testing_framework})"
+      end
+
+
+      self.target_dir             = options[:directory] || self.project_name
+
+      self.should_create_repo     = options[:create_repo]
+      self.summary                = options[:summary] || 'TODO'
+      self.should_use_cucumber    = options[:use_cucumber]
+      self.should_setup_rubyforge = options[:rubyforge]
+
+      use_user_git_config
+      
+    end
+
+    def run
+      create_files
+      gitify
+      $stdout.puts "Jeweler has prepared your gem in #{target_dir}"
+      if should_create_repo
+        create_and_push_repo
+        $stdout.puts "Jeweler has pushed your repo to #{project_homepage}"
+        enable_gem_for_repo
+        $stdout.puts "Jeweler has enabled gem building for your repo"
+      end
+    end
+
+    def git_remote
+      "git@github.com:#{github_username}/#{project_name}.git"
+    end
+
+    def project_homepage
+      "http://github.com/#{github_username}/#{project_name}"
+    end
+    
+    def constant_name
+      self.project_name.split(/[-_]/).collect{|each| each.capitalize }.join
+    end
+
+    def lib_filename
+      "#{project_name}.rb"
+    end
+
+    def require_name
+      self.project_name
+    end
+
+    def file_name_prefix
+      self.project_name.gsub('-', '_')
+    end
+
+    def lib_dir
+      'lib'
+    end
+
+    def feature_filename
+      "#{project_name}.feature"
+    end
+
+    def steps_filename
+      "#{project_name}_steps.rb"
+    end
+
+    def features_dir
+      'features'
+    end
+
+    def features_support_dir
+      File.join(features_dir, 'support')
+    end
+
+    def features_steps_dir
+      File.join(features_dir, 'step_definitions')
+    end
+
+  protected
+
+    # This is in a separate method so we can stub it out during testing
+    def read_git_config
+      # we could just use Git::Base's .config, but that relies on a repo being around already
+      # ... which we don't have yet, since this is part of a sanity check
+      lib = Git::Lib.new(nil, nil)
+      config = lib.parse_config '~/.gitconfig'
+    end
+
+  private
+    def create_files
+      unless File.exists?(target_dir) || File.directory?(target_dir)
+        FileUtils.mkdir target_dir
+      else
+        raise FileInTheWay, "The directory #{target_dir} already exists, aborting. Maybe move it out of the way before continuing?"
+      end
+
+
+      output_template_in_target '.gitignore'
+      output_template_in_target 'Rakefile'
+      output_template_in_target 'LICENSE'
+      output_template_in_target 'README.rdoc'
+      output_template_in_target '.document'
+
+      mkdir_in_target           lib_dir
+      touch_in_target           File.join(lib_dir, lib_filename)
+
+      mkdir_in_target           test_dir
+      output_template_in_target File.join(testing_framework.to_s, 'helper.rb'), File.join(test_dir, test_helper_filename)
+      output_template_in_target File.join(testing_framework.to_s, 'flunking.rb'), File.join(test_dir, test_filename)
+
+      if should_use_cucumber
+        mkdir_in_target           features_dir
+        output_template_in_target File.join(%w(features default.feature)), File.join('features', feature_filename)
+
+        mkdir_in_target           features_support_dir
+        output_template_in_target File.join(features_support_dir, 'env.rb')
+
+        mkdir_in_target           features_steps_dir
+        touch_in_target           File.join(features_steps_dir, steps_filename)
+      end
+
+    end
+
+    def use_user_git_config
+      git_config = self.read_git_config
+
+      unless git_config.has_key? 'user.name'
+        raise NoGitUserName
+      end
+      
+      unless git_config.has_key? 'user.email'
+        raise NoGitUserEmail
+      end
+      
+      unless git_config.has_key? 'github.user'
+        raise NoGitHubUser
+      end
+      
+      if should_create_repo
+        unless git_config.has_key? 'github.token'
+          raise NoGitHubToken
+        end
+      end
+
+      self.user_name       = git_config['user.name']
+      self.user_email      = git_config['user.email']
+      self.github_username = git_config['github.user']
+      self.github_token    = git_config['github.token']
+    end
+
+    def output_template_in_target(source, destination = source)
+      final_destination = File.join(target_dir, destination)
+
+      template_contents = File.read(File.join(template_dir, source))
+      template = ERB.new(template_contents, nil, '<>')
+
+      template_result = template.result(binding)
+
+      File.open(final_destination, 'w') {|file| file.write(template_result)}
+
+      $stdout.puts "\tcreate\t#{destination}"
+    end
+
+    def template_dir
+      File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    def mkdir_in_target(directory)
+      final_destination = File.join(target_dir, directory)
+
+      FileUtils.mkdir final_destination
+
+      $stdout.puts "\tcreate\t#{directory}"
+    end
+
+    def touch_in_target(destination)
+      final_destination = File.join(target_dir, destination)
+      FileUtils.touch  final_destination
+      $stdout.puts "\tcreate\t#{destination}"
+    end
+
+    def gitify
+      saved_pwd = Dir.pwd
+      Dir.chdir(target_dir)
+      begin
+        begin
+          @repo = Git.init()
+        rescue Git::GitExecuteError => e
+          raise GitInitFailed, "Encountered an error during gitification. Maybe the repo already exists, or has already been pushed to?"
+        end
+
+        begin
+          @repo.add('.')
+        rescue Git::GitExecuteError => e
+          #raise GitAddFailed, "There was some problem adding this directory to the git changeset"
+          raise
+        end
+
+        begin
+          @repo.commit "Initial commit to #{project_name}."
+        rescue Git::GitExecuteError => e
+          raise
+        end
+
+        begin
+          @repo.add_remote('origin', git_remote)
+        rescue Git::GitExecuteError => e
+          puts "Encountered an error while adding origin remote. Maybe you have some weird settings in ~/.gitconfig?"
+          raise
+        end
+      ensure
+        Dir.chdir(saved_pwd)
+      end
+    end
+    
+    def create_and_push_repo
+      Net::HTTP.post_form URI.parse('http://github.com/repositories'),
+                                'login' => github_username,
+                                'token' => github_token,
+                                'repository[description]' => summary,
+                                'repository[name]' => project_name
+      # TODO do a HEAD request to see when it's ready
+      @repo.push('origin')
+    end
+
+    def enable_gem_for_repo
+      url = "https://github.com/#{github_username}/#{project_name}/update"
+      `curl -F 'login=#{github_username}' -F 'token=#{github_token}' -F 'field=repository_rubygem' -F 'value=1' #{url} 2>/dev/null`
+      # FIXME use NET::HTTP instead of curl
+      #Net::HTTP.post_form URI.parse(url),
+                                #'login' => github_username,
+                                #'token' => github_token,
+                                #'field' => 'repository_rubygem',
+                                #'value' => '1'
+    end
+
+  end
+end

data/lib/jeweler/rubyforge_tasks.rb

@@ -0,0 +1,46 @@
+require 'rake'
+require 'rake/tasklib'
+require 'rake/contrib/sshpublisher'
+
+
+class Jeweler
+  class RubyforgeTasks < ::Rake::TaskLib
+    attr_accessor :project, :remote_doc_path
+    attr_accessor :jeweler
+
+    def initialize
+      yield self if block_given?
+
+      self.jeweler = Rake.application.jeweler
+
+      self.remote_doc_path ||= jeweler.gemspec.name
+      self.project ||= jeweler.gemspec.rubyforge_project
+
+      define
+    end
+
+    def define
+      namespace :rubyforge do
+
+        desc "Release gem and RDoc documentation to RubyForge"
+        task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+
+        namespace :release do
+          desc "Publish RDoc to RubyForge."
+          task :docs => [:rdoc] do
+            config = YAML.load(
+              File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+            )
+
+            host = "#{config['username']}@rubyforge.org"
+            remote_dir = "/var/www/gforge-projects/#{project}/#{remote_doc_path}"
+            local_dir = 'rdoc'
+
+            sh %{rsync -av --delete #{local_dir}/ #{host}:#{remote_dir}}
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/jeweler/specification.rb

@@ -0,0 +1,65 @@
+require 'rubygems/specification'
+
+class Jeweler
+  # Extend a Gem::Specification instance with this module to give it Jeweler
+  # super-cow powers.
+  module Specification
+
+    def self.filelist_attribute(name)
+      code = %{
+        def #{name}
+          @#{name} ||= FileList[]
+        end
+        def #{name}=(value)
+          @#{name} = FileList[value]
+        end
+      }
+
+      module_eval code, __FILE__, __LINE__ - 9
+    end
+
+    filelist_attribute :files
+    filelist_attribute :test_files
+    filelist_attribute :extra_rdoc_files
+
+
+    # Assigns the Jeweler defaults to the Gem::Specification
+    def set_jeweler_defaults(base_dir)
+      Dir.chdir(base_dir) do
+        if blank?(files) && File.directory?(File.join(base_dir, '.git'))
+          repo = Git.open(base_dir)
+          self.files = repo.ls_files.keys
+        end
+
+        if blank?(test_files)
+          self.test_files = FileList['{spec,test,examples}/**/*.rb']
+        end
+
+        if blank?(executable)
+          self.executables = Dir["bin/*"].map { |f| File.basename(f) }
+        end
+
+        self.has_rdoc = true
+        rdoc_options << '--charset=UTF-8'
+
+        if blank?(extra_rdoc_files)
+          self.extra_rdoc_files = FileList["README*", "ChangeLog*", "LICENSE*"]
+        end
+      end
+    end
+
+    # Used by Specification#to_ruby to generate a ruby-respresentation of a Gem::Specification
+    def ruby_code(obj)
+      case obj
+      when Rake::FileList then obj.to_a.inspect
+      else super
+      end
+    end
+
+    private
+
+    def blank?(value)
+      value.nil? || value.empty?
+    end
+  end
+end

data/lib/jeweler/tasks.rb

@@ -0,0 +1,131 @@
+require 'rake'
+require 'rake/tasklib'
+
+class Rake::Application
+  attr_accessor :jeweler
+end
+
+class Jeweler
+  class Tasks < ::Rake::TaskLib
+    attr_accessor :gemspec, :jeweler
+
+    def initialize(gemspec = nil, &block)
+      @gemspec = gemspec || Gem::Specification.new
+      @jeweler = Jeweler.new(@gemspec)
+      yield @gemspec if block_given?
+
+      Rake.application.jeweler = @jeweler
+      define
+    end
+
+  private
+    def define
+      desc "Setup initial version of 0.0.0"
+      task :version_required do
+        unless jeweler.version_exists?
+          abort "Expected VERSION or VERSION.yml to exist. See version:write to create an initial one."
+        end
+      end
+
+      desc "Build gem"
+      task :build do
+        jeweler.build_gem
+      end
+
+      desc "Install gem using sudo"
+      task :install => :build do
+        jeweler.install_gem
+      end
+
+      desc "Generate and validates gemspec"
+      task :gemspec => ['gemspec:generate', 'gemspec:validate']
+
+      namespace :gemspec do
+        desc "Validates the gemspec"
+        task :validate => :version_required do
+          jeweler.validate_gemspec
+        end
+
+        desc "Generates the gemspec, using version from VERSION"
+        task :generate => :version_required do
+          jeweler.write_gemspec
+        end
+      end
+
+      desc "Displays the current version"
+      task :version => :version_required do
+        $stdout.puts "Current version: #{jeweler.version}"
+      end
+
+      namespace :version do
+        desc "Writes out an explicit version. Respects the following environment variables, or defaults to 0: MAJOR, MINOR, PATCH"
+        task :write do
+          major, minor, patch = ENV['MAJOR'].to_i, ENV['MINOR'].to_i, ENV['PATCH'].to_i
+          jeweler.write_version(major, minor, patch, :announce => false, :commit => false)
+          $stdout.puts "Updated version: #{jeweler.version}"
+        end
+
+        namespace :bump do
+          desc "Bump the gemspec by a major version."
+          task :major => [:version_required, :version] do
+            jeweler.bump_major_version
+            $stdout.puts "Updated version: #{jeweler.version}"
+          end
+
+          desc "Bump the gemspec by a minor version."
+          task :minor => [:version_required, :version] do
+            jeweler.bump_minor_version
+            $stdout.puts "Updated version: #{jeweler.version}"
+          end
+
+          desc "Bump the gemspec by a patch version."
+          task :patch => [:version_required, :version] do
+            jeweler.bump_patch_version
+            $stdout.puts "Updated version: #{jeweler.version}"
+          end
+          
+          desc "Bump the gemspec by a timestamp."
+          task :timestamp => [:version_required, :version] do
+            jeweler.bump_timestamp_version
+            $stdout.puts "Updated version: #{jeweler.version}"
+          end
+          
+        end
+      end
+
+      desc "Release the current version. Includes updating the gemspec, pushing, and tagging the release"
+      task :release do
+        jeweler.release
+      end
+      
+      namespace :rubyforge do
+        namespace :release do
+          desc "Release the current gem version to RubyForge."
+          task :gem => [:gemspec, :build] do
+            begin
+              jeweler.release_gem_to_rubyforge
+            rescue NoRubyForgeProjectInGemspecError => e
+              abort "Setting up RubyForge requires that you specify a 'rubyforge_project' in your Jeweler::Tasks declaration"
+            rescue MissingRubyForgePackageError => e
+              abort "Rubyforge reported that the #{e.message} package isn't setup. Run rake rubyforge:setup to do so."
+            rescue RubyForgeProjectNotConfiguredError => e
+              abort "RubyForge reported that #{e.message} wasn't configured. This means you need to run 'rubyforge setup', 'rubyforge login', and 'rubyforge configure', or maybe the project doesn't exist on RubyForge"
+            end
+          end
+        end
+
+        desc "Setup a rubyforge project for this gem"
+        task :setup do
+          begin 
+            jeweler.setup_rubyforge
+          rescue NoRubyForgeProjectInGemspecError => e
+            abort "Setting up RubyForge requires that you specify a 'rubyforge_project' in your Jeweler::Tasks declaration"
+          rescue RubyForgeProjectNotConfiguredError => e
+            abort "The RubyForge reported that #{e.message} wasn't configured. This means you need to run 'rubyforge setup', 'rubyforge login', and 'rubyforge configure', or maybe the project doesn't exist on RubyForge"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/jeweler/templates/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/lib/jeweler/templates/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/lib/jeweler/templates/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 <%= user_name %>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/jeweler/templates/README.rdoc

@@ -0,0 +1,7 @@
+= <%= project_name %>
+
+Description goes here.
+
+== Copyright
+
+Copyright (c) <%= Time.now.year %> <%= user_name %>. See LICENSE for details.

data/lib/jeweler/templates/Rakefile

@@ -0,0 +1,102 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "<%= project_name %>"
+    gem.summary = %Q{<%= summary %>}
+    gem.email = "<%= user_email %>"
+    gem.homepage = "<%= project_homepage %>"
+    gem.authors = ["<%= user_name %>"]
+<% if should_setup_rubyforge %>
+    gem.rubyforge_project = "<%= project_name %>"
+<% end %>
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+<% if should_setup_rubyforge %>
+  Jeweler::RubyforgeTasks.new
+<% end %>
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+<% case testing_framework %>
+<% when :rspec %>
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:<%= test_task %>) do |<%= test_task %>|
+  <%= test_task %>.libs << 'lib' << '<%= test_dir %>'
+  <%= test_task %>.spec_files = FileList['<%= test_pattern %>']
+end
+<% when :micronaut %>
+require 'micronaut/rake_task'
+Micronaut::RakeTask.new(<%= test_task %>) do |<%= test_task %>|
+  <%= test_task %>.pattern = '<%= test_pattern %>'
+  <%= test_task %>.ruby_opts << '-Ilib -I<%= test_dir %>'
+end
+<% else %>
+require 'rake/testtask'
+Rake::TestTask.new(:<%= test_task %>) do |<%= test_task %>|
+  <%= test_task %>.libs << 'lib' << '<%= test_dir %>'
+  <%= test_task %>.pattern = '<%= test_pattern %>'
+  <%= test_task %>.verbose = true
+end
+<% end %>
+
+<% case testing_framework %>
+<% when :rspec %>
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = '<%= test_pattern %>'
+  spec.rcov = true
+end
+<% when :micronaut %>
+Micronaut::RakeTask.new(:rcov) do |examples|
+  examples.pattern = '<%= test_pattern %>'
+  examples.rcov_opts = '-Ilib -I<%= test_dir %>'
+  examples.rcov = true
+end
+<% else %>
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |<%= test_task %>|
+    <%= test_task %>.libs << '<%= test_dir %>'
+    <%= test_task %>.pattern = '<%= test_pattern %>'
+    <%= test_task %>.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+<% end %>
+
+<% if should_use_cucumber %>
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+rescue LoadError
+  task :features do
+    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+  end
+end
+<% end %>
+
+task :default => :<%= default_task %>
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "<%= project_name %> #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/lib/jeweler/templates/bacon/flunking.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "<%= constant_name %>" do
+  it "fails" do
+    should.flunk "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/lib/jeweler/templates/bacon/helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bacon'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require '<%= require_name %>'
+
+Bacon.summary_on_exit