corundum 0.0.6 → 0.0.7

data/lib/corundum.rb

@@ -7,35 +7,26 @@ module Corundum
   extend Rake::DSL
 
   class Toolkit < TaskLib
-    def default_configuration
-      settings(
-        :finished_dir => "corundum",
-        :finished_files => nested(
-          :build => nil,
-          :qa => nil,
-          :package => nil,
-          :release => nil,
-          :press => nil),
-
-        :browser => "chromium",
-        :gemspec => nil,
-        :gemspec_path => nil,
-        :email => nested(
-          :servers => [ nested({ :server => "ruby-lang.org", :helo => "gmail.com" }) ],
-          :announce_to_email => "ruby-talk@ruby-lang.org"
-      ),
-        :package_dir => "pkg",
-        :files => nested(:code => nil, :test => nil, :docs => nil),
-        :file_lists => nested(:code => FileList['lib/**/*.rb'],
-                              :test => FileList['test/**/*.rb','spec/**/*.rb','features/**/*.rb'],
-                              :docs => FileList['doc/**/*.rb'],
-                              :project => FileList['Rakefile'],
-                              :all => nil),
-        :rubyforge => nested().nil_fields(:group_id, :package_id,
-                                          :release_name, :home_page, :project_page),
-        :doc_dir => "rubydoc"
-      )
-    end
+    settings(
+      :gemspec => nil,
+      :gemspec_path => nil,
+      :finished_dir => "corundum",
+      :package_dir => "pkg",
+      :doc_dir => "rubydoc",
+      :browser => "chromium",
+      :finished_files => nested.nil_fields(:build, :qa, :package, :release, :press),
+      :files => nested.nil_fields(:code, :test, :docs),
+      :rubyforge => nested.nil_fields(:group_id, :package_id, :release_name, :home_page, :project_page),
+      :email => nested(
+        :servers => [ nested({ :server => "ruby-lang.org", :helo => "gmail.com" }) ],
+        :announce_to_email => "ruby-talk@ruby-lang.org"
+    ),
+      :file_lists => nested(:code => FileList['lib/**/*.rb'],
+                            :test => FileList['test/**/*.rb','spec/**/*.rb','features/**/*.rb'],
+                            :docs => FileList['doc/**/*.rb'],
+                            :project => FileList['Rakefile'],
+                            :all => nil)
+    )
 
     def load_gemspec
       @gemspec_path ||= guess_gemspec

data/lib/corundum/browser-task.rb

@@ -0,0 +1,21 @@
+require 'mattock/command-task'
+
+module Corundum
+  class BrowserTask < Mattock::CommandTask
+    setting(:browser, "chromium")
+    setting(:index_html)
+    setting(:task_name, "view")
+
+    def default_configuration(parent)
+      self.browser = parent.browser
+    end
+
+    def task_args
+      [{task_name => index_html}]
+    end
+
+    def resolve_configuration
+      self.command = Mattock::CommandLine.new(browser, index_html)
+    end
+  end
+end

data/lib/corundum/email.rb

@@ -2,17 +2,19 @@ require 'corundum/tasklib'
 
 module Corundum
   class Email < TaskLib
-    def default_namespace
-      :email
-    end
+    default_namespace :email
+
+    setting(:rubyforge)
+    setting(:email_servers, [])
+    setting(:gemspec)
+    setting(:announce_to_email, nil)
+    setting(:urls, nested.required_fields(:home_page, :project_page))
 
     def default_configuration(toolkit)
-      setting(:rubyforge, toolkit.rubyforge)
-      setting(:email_servers, [])
-      setting(:gemspec, toolkit.gemspec)
-      setting(:announce_to_email, nil)
-      setting(:urls, nested(:home_page => toolkit.gemspec.homepage,
-                            :project_page => toolkit.rubyforge.project_page))
+      self.rubyforge = toolkit.rubyforge
+      self.gemspec = toolkit.gemspec
+      self.urls.home_page = toolkit.gemspec.homepage
+      self.urls.project_page = toolkit.rubyforge.project_page
     end
 
     def announcement

data/lib/corundum/gem_building.rb

@@ -2,10 +2,13 @@ require 'corundum/tasklib'
 
 module Corundum
   class GemBuilding < TaskLib
+    setting(:gemspec)
+    setting(:qa_finished_file)
+    setting(:package_dir, "pkg")
+
     def default_configuration(toolkit)
-      setting(:gemspec,  toolkit.gemspec)
-      setting(:qa_finished_file,  toolkit.finished_files.qa)
-      setting(:package_dir,  "pkg")
+      self.gemspec =  toolkit.gemspec
+      self.qa_finished_file =  toolkit.finished_files.qa
     end
 
     def define

data/lib/corundum/gemcutter.rb

@@ -2,21 +2,25 @@ require 'corundum/tasklib'
 
 module Corundum
   class GemCutter < TaskLib
-    def default_namespace
-      :gemcutter
-    end
+    default_namespace :gemcutter
+
+    setting(:gem_path, nil)
+    setting(:build)
+    setting(:gemspec)
+    setting(:build_finished_path)
+    setting(:gem_name)
+    setting(:package_dir)
 
     def default_configuration(toolkit, build)
-      setting(:build, build)
-      setting(:gemspec, toolkit.gemspec)
-      setting(:build_finished_path, toolkit.finished_files.build)
-      setting(:gem_path, nil)
-      setting(:gem_name, toolkit.gemspec.full_name)
-      setting(:package_dir, build.package_dir)
+      self.build = build
+      self.gemspec = toolkit.gemspec
+      self.build_finished_path = toolkit.finished_files.build
+      self.gem_name = toolkit.gemspec.full_name
+      self.package_dir = build.package_dir
     end
 
     def resolve_configuration
-      @gem_path ||= File::join(package_dir, gemspec.file_name)
+      self.gem_path ||= File::join(package_dir, gemspec.file_name)
     end
 
     module CommandTweaks

data/lib/corundum/gemspec_sanity.rb

@@ -2,16 +2,22 @@ require 'corundum/tasklib'
 
 module Corundum
   class GemspecSanity < TaskLib
-    def default_namespace
-      :gemspec_sanity
-    end
+    default_namespace :gemspec_sanity
+
+    setting(:gemspec)
 
     def default_configuration(toolkit)
-      setting(:gemspec, toolkit.gemspec)
+      self.gemspec = toolkit.gemspec
     end
 
     def define
       in_namespace do
+        task :has_files do
+          if gemspec.files.nil? or gemspec.files.empty?
+            fail "No files mentioned in gemspec - do you intend an empty gem?"
+          end
+        end
+
         task :files_exist do
           missing = gemspec.files.find_all do |path|
             not File::exists?(path)
@@ -21,7 +27,7 @@ module Corundum
         end
       end
 
-      task :preflight => in_namespace(:files_exist)
+      task :preflight => in_namespace(:files_exist, :has_files)
     end
   end
 end

data/lib/corundum/github-pages.rb

@@ -0,0 +1,147 @@
+require 'corundum/tasklib'
+require 'mattock/task'
+
+module Corundum
+  class GitTask < Mattock::CommandTask
+    setting(:subcommand)
+    setting(:arguments, [])
+
+    def command
+      Mattock::CommandLine.new("git", "--no-pager") do |cmd|
+        cmd.options << subcommand
+        arguments.each do |arg|
+          cmd.options += [*arg]
+        end
+      end
+    end
+  end
+
+  class InDirCommandTask < Mattock::CommandTask
+    setting :target_dir
+
+    def default_configuration(parent)
+      parent.copy_settings_to(self)
+    end
+
+    def needed?
+      FileUtils.cd target_dir do
+        super
+      end
+    end
+
+    def action
+      FileUtils.cd target_dir do
+        super
+      end
+    end
+  end
+
+  class GithubPages < TaskLib
+    default_namespace :publish_docs
+
+    setting(:target_dir, "gh-pages")
+    setting(:source_dir)
+
+    nil_fields :repo_dir
+
+    def branch
+      "gh-pages"
+    end
+
+    def default_configuration(doc_gen)
+      self.source_dir = doc_gen.target_dir
+    end
+
+    def resolve_configuration
+      self.repo_dir ||= File::join(target_dir, ".git")
+    end
+
+    def git_command(*args)
+      Mattock::CommandLine.new("git", "--no-pager") do |cmd|
+        args.each do |arg|
+          cmd.options += [*arg]
+        end
+      end
+    end
+
+    def git(*args)
+      result = git_command(*args).run
+      result.must_succeed!
+      result.stdout.lines.to_a
+    end
+
+    $verbose = true
+
+    def define
+      in_namespace do
+        InDirCommandTask.new(self) do |t|
+          t.task_name = :on_branch
+          t.verify_command = Mattock::PipelineChain.new do |chain|
+            chain.add git_command(%w{branch})
+            chain.add Mattock::CommandLine.new("grep", "-q", "'^[*] #{branch}'")
+          end
+          t.command = Mattock::PrereqChain.new do |chain|
+            chain.add git_command("checkout", branch)
+          end
+        end
+
+        file repo_dir do
+          fail "Refusing to clobber existing #{target_dir}" if File.exists?(target_dir)
+
+          url = git("config", "--get", "remote.origin.url").first
+
+          git("clone", url.chomp, "-b", branch, target_dir)
+          Mattock::CommandLine.new("rm", File::join(repo_dir, "hooks", "*")).must_succeed!
+        end
+
+        task :pull => [repo_dir, :on_branch] do
+          FileUtils.cd target_dir do
+            git("pull")
+          end
+        end
+
+        InDirCommandTask.new(self) do |t|
+          t.task_name = :setup
+          t.verify_command = Mattock::PipelineChain.new do |chain|
+            chain.add git_command(%w{branch -r})
+            chain.add Mattock::CommandLine.new("grep", "-q", branch)
+          end
+          t.command = Mattock::PrereqChain.new do |cmd|
+            cmd.add git_command("checkout", "-b", branch)
+            cmd.add Mattock::CommandLine.new("rm -rf *")
+            cmd.add git_command(%w{commit -a -m} + ["'Creating pages'"])
+            cmd.add git_command("push", "origin", branch)
+            cmd.add git_command("branch", "--set-upstream", branch, "origin/" + branch)
+          end
+        end
+        task :setup => repo_dir
+
+        task :pre_publish => [repo_dir, :setup, :pull]
+
+        task :clobber_target => :on_branch do
+          Mattock::CommandLine.new(*%w{rm -rf}) do |cmd|
+            cmd.options << target_dir + "/*"
+          end.must_succeed!
+        end
+
+        task :assemble_docs => [:pre_publish, :clobber_target] do
+          Mattock::CommandLine.new(*%w{cp -a}) do |cmd|
+            cmd.options << source_dir + "/*"
+            cmd.options << target_dir
+          end.must_succeed!
+        end
+
+        task :publish => [:assemble_docs, :on_branch] do
+          FileUtils.cd target_dir do
+            git("add", ".")
+            git("commit", "-m", "'Corundum auto-publish'")
+            git("push", "origin", branch)
+          end
+        end
+      end
+
+      desc "Push documentation files to Github Pages"
+      task root_task => self[:publish]
+    end
+  end
+end

data/lib/corundum/rspec.rb

@@ -1,114 +1,100 @@
 require 'corundum/tasklib'
 require 'rspec/core'
+require 'mattock/command-task'
+require 'rbconfig'
 
 module Corundum
-  #TODO: this should take two command generators as arguments: the test runner,
-  #and the coverage tool - then the various tasks are the result of the
-  #collaboration of those two.
-  #
-  class RSpec < TaskLib
-    def default_namespace
-      :rspec
+  class RSpecTask < Mattock::CommandTask
+    setting :ruby_command, Mattock::CommandLine.new(RbConfig.ruby) do |cmd|
+      if /^1\.8/ =~ RUBY_VERSION
+        cmd.options << "-S"
+      end
     end
 
-    def default_configuration(toolkit)
-      setting(:task_options, nested(
-        :pattern => './spec{,/*/**}/*_spec.rb',
-        :ruby_opts => nil,
-        :rspec_configs => nil,
-        :rspec_opts => nil,
-        :warning => false,
-        :verbose => true,
-        :fail_on_error => true,
-        :ruby_opts => [],
-        :rspec_path => 'rspec',
-        :rspec_opts => %w{--format documentation --out last_run --color --format documentation},
-        :failure_message => "Spec examples failed.",
-        :files_to_run => "spec"
-      ))
-
-      setting(:gemspec_path, toolkit.gemspec_path)
-      setting(:qa_finished_path, toolkit.finished_files.qa)
+    setting :runner_command
+
+    required_fields :pattern, :ruby_opts, :rspec_configs, :rspec_opts,
+      :warning, :rspec_path, :rspec_opts, :failure_message, :files_to_run
+
+    def default_configuration(rspec)
+      self.pattern = rspec.pattern
+      self.ruby_opts = rspec.ruby_opts
+      self.rspec_configs = rspec.rspec_configs
+      self.rspec_opts = rspec.rspec_opts
+      self.warning = rspec.warning
+      self.rspec_path = rspec.rspec_path
+      self.rspec_opts = rspec.rspec_opts
+      self.failure_message = rspec.failure_message
+      self.files_to_run = rspec.files_to_run
     end
 
     def resolve_configuration
-      #XXX Que?
-      @task_options.rspec_configs = task_options.rspec_opts
-      @task_options.rspec_opts = []
-      @task_options.rspec_path = %x"which #{task_options.rspec_path}".chomp
-    end
+      self.rspec_configs = rspec_opts
+      self.rspec_path = %x"which #{rspec_path}".chomp
 
-    #XXX some point in the future, there needs to be a composible command
-    #object
-    def ruby_command(options)
-      cmd_parts = []
-      cmd_parts << RUBY
-      cmd_parts << options.ruby_opts
-      cmd_parts << "-w" if options.warning
-      if /^1\.8/ =~ RUBY_VERSION
-        cmd_parts << "-S"
+      ruby_command.options << ruby_opts if ruby_opts
+      ruby_command.options << "-w" if warning
+
+      self.runner_command = Mattock::CommandLine.new(rspec_path) do |cmd|
+        cmd.options << rspec_opts
+        cmd.options << files_to_run
       end
-      return cmd_parts
-    end
 
-    def runner_command(options)
-      cmd_parts = []
-      cmd_parts << options.rspec_path
-      cmd_parts << options.rspec_opts
-      cmd_parts << options.files_to_run
-      return cmd_parts
+      self.command = Mattock::WrappingChain.new do |cmd|
+        cmd.add ruby_command
+        cmd.add runner_command
+      end
     end
+  end
 
-    def full_command(options)
-      cmd_parts = ruby_command(options) + runner_command(options)
-      return cmd_parts.flatten.compact.reject{|part| part.nil? or part.empty?}.join(" ")
-    end
 
-    def custom_options
-      options = task_options.dup
-      yield(options)
-      return options
+  class RSpec < TaskLib
+    default_namespace :rspec
+
+    settings(
+      :pattern => './spec{,/*/**}/*_spec.rb',
+      :rspec_configs => nil,
+      :rspec_opts => nil,
+      :warning => false,
+      :verbose => true,
+      :ruby_opts => [],
+      :rspec_path => 'rspec',
+      :rspec_opts => %w{--format documentation --out last_run --color --format documentation},
+      :failure_message => "Spec examples failed.",
+      :files_to_run => "spec"
+    )
+
+    required_fields :gemspec_path, :qa_finished_path
+
+    def default_configuration(toolkit)
+      self.gemspec_path = toolkit.gemspec_path
+      self.qa_finished_path = toolkit.finished_files.qa
     end
 
-    def define_spec_task(name)
-      options = if block_given?
-                  custom_options{|options| yield(options) if block_given?}
-                else
-                  task_options
-                end
-      task name do
-        RakeFileUtils.send(:verbose, verbose) do
-          if options.files_to_run.empty?
-            puts "No examples matching #{options.pattern} could be found"
-          else
-            begin
-              cmd = full_command(options)
-              puts cmd if options.verbose
-              success = system(cmd)
-            rescue Object => ex
-              p ex
-              puts options.failure_message if options.failure_message
-            end
-            raise("ruby #{cmd} failed") if options.fail_on_error unless success
-          end
-        end
-      end
+    def resolve_configuration
+      #XXX Que?
+      self.rspec_configs = rspec_opts
+      self.rspec_opts = []
+      self.rspec_path = %x"which #{rspec_path}".chomp
     end
 
     def define
       in_namespace do
         desc "Always run every spec"
-        define_spec_task(:all)
+        RSpecTask.new(self) do |t|
+          t.task_name = :all
+        end
 
         desc "Generate specifications documentation"
-        define_spec_task(:doc) do |t|
+        RSpecTask.new(self) do |t|
+          t.task_name = :doc
           t.rspec_opts = %w{-o /dev/null -f d -o doc/Specifications}
           t.failure_message = "Failed generating specification docs"
-          t.verbose = false
         end
 
         desc "Run only failing examples listed in last_run"
-        define_spec_task(:quick) do |t|
+        RSpecTask.new(self) do |t|
+          t.task_name = :quick
           examples = []
           begin
             File.open("last_run", "r") do |fail_list|