mattock 0.3.0 → 0.3.1

data/lib/mattock/cascading-definition.rb

@@ -26,21 +26,38 @@ module Mattock
     def initialize(*tasklibs)
       @runtime = false
       setup_defaults
-      default_configuration(*tasklibs)
 
-      yield self if block_given?
+      confirm_steps(:default_configuration, :resolve_configuration, :confirm_configuration) do
+        default_configuration(*tasklibs)
 
-      resolve_configuration
-      confirm_configuration
+        yield self if block_given?
+
+        resolve_configuration
+        confirm_configuration
+      end
 
       define
     end
 
+    def confirm_steps(*steps)
+      @steps = steps
+      yield
+      unless @steps.empty?
+        #Otherwise, it's very easy to forget the 'super' statement and leave
+        #essential configuration out.  The result is really confusing
+        raise "#{self.class.name} didn't run superclass step#{@steps.length == 1 ? "" : "s"}: #{@steps.inspect} (put a 'super' in appropriate methods)"
+      end
+    end
+
+    def confirm_step(step)
+      @steps.delete(step)
+    end
 
     #@param [TaskLib] tasklibs Other libs upon which this one depends to set
     #  its defaults
     #Sets default values for library settings
     def default_configuration(*tasklibs)
+      confirm_step(:default_configuration)
     end
 
     #Called after the configuration block has been called, so secondary
@@ -52,6 +69,7 @@ module Mattock
     #the Rakefile, or if bin_dir and command_name are set, we can put those
     #together.
     def resolve_configuration
+      confirm_step(:resolve_configuration)
     end
 
     #Last step before definition: confirm that all the configuration settings
@@ -59,6 +77,7 @@ module Mattock
     #given values.  Very much shortens the debugging cycle when using TaskLibs
     #if this is well written.
     def confirm_configuration
+      confirm_step(:confirm_configuration)
       check_required
     end
 
@@ -88,16 +107,19 @@ module Mattock
       !!@runtime
     end
 
-    def resolve_runtime_configuration
-    end
-
     def finalize_configuration
       return if @finalized
       @runtime = true
       configuration_block[self]
-      resolve_runtime_configuration
-      confirm_configuration
+      confirm_steps(:resolve_runtime_configuration, :confirm_configuration) do
+        resolve_runtime_configuration
+        confirm_configuration
+      end
       @finalized = true
     end
+
+    def resolve_runtime_configuration
+      confirm_step(:resolve_runtime_configuration)
+    end
   end
 end

data/lib/mattock/command-line.rb

@@ -27,12 +27,16 @@ module Mattock
       return false
     end
 
+    def format_streams
+      "stdout:#{stdout.empty? ? "[empty]\n" : "\n#{stdout}"}stderr:#{stderr.empty? ? "[empty]\n" : "\n#{stderr}"}---"
+    end
+
     def must_succeed!
       case exit_code
       when 0
         return exit_code
       else
-        fail "Command #{@command.inspect} failed with exit status #{exit_code}: \n#{streams.inspect}"
+        fail "Command #{@command.inspect} failed with exit status #{exit_code}: \n#{format_streams}"
       end
     end
   end
@@ -62,10 +66,14 @@ module Mattock
       @executable = executable
       @options = options
       @redirections = []
+      @env = {}
       yield self if block_given?
     end
 
-    attr_accessor :name, :executable, :options
+    attr_accessor :name, :executable, :options, :env
+    attr_reader :redirections
+
+    alias_method :command_environment, :env
 
     def verbose
       Rake.verbose && Rake.verbose != Rake::FileUtilsExt::DEFAULT
@@ -79,6 +87,12 @@ module Mattock
       ([executable] + options_composition + @redirections).join(" ")
     end
 
+    def string_format
+      (command_environment.map do |key, value|
+        [key, value].join("=")
+      end + [command]).join(" ")
+    end
+
     def options_composition
       options
     end
@@ -107,19 +121,59 @@ module Mattock
       redirect_from(path, 0)
     end
 
-    def self.execute(command)
-      pipe = IO.popen(command)
-      pid = pipe.pid
+    def spawn_process
+      host_stdout, cmd_stdout = IO.pipe
+      host_stderr, cmd_stderr = IO.pipe
+
+      pid = Process.spawn(command_environment, command, :out => cmd_stdout, :err => cmd_stderr)
+      cmd_stdout.close
+      cmd_stderr.close
+
+      return pid, host_stdout, host_stderr
+    end
+
+    def collect_result(pid, host_stdout, host_stderr)
       pid, status = Process.wait2(pid)
-      result = CommandRunResult.new(command, status, {1 => pipe.read})
-      pipe.close
+
+      stdout = host_stdout.read
+      stderr = host_stderr.read
+      result = CommandRunResult.new(command, status, {1 => stdout, 2 => stderr})
+      host_stdout.close
+      host_stderr.close
+
       return result
     end
 
+    #If I wasn't worried about writing my own limited shell, I'd say e.g.
+    #Pipeline would be an explicit chain of pipes... which is probably as
+    #originally intended :/
+    def execute
+      collect_result(*spawn_process)
+    end
+
+    def background
+      pid, out, err = spawn_process
+      at_exit do
+        kill_process(pid)
+        Process.detach(pid)
+      end
+      return pid, out, err
+    end
+
+    def kill_process(pid)
+      Process.kill("INT", pid)
+    end
+
+    def complete(pid, out, err)
+      kill_process(pid)
+      collect_result(pid, out, err)
+    end
+
     def run
-      print command + " " if verbose
-      result = self.class.execute(command)
-      print "=> #{result.exit_code}" if verbose
+      print string_format + " "
+      result = execute
+      puts "=> #{result.exit_code}"
+      puts result.format_streams if verbose
       return result
     ensure
       puts if verbose
@@ -135,8 +189,12 @@ module Mattock
   end
 
   module CommandLineDSL
-    def cmd(*args)
-      CommandLine.new(*args)
+    def cmd(*args, &block)
+      CommandLine.new(*args, &block)
+    end
+
+    def escaped_command(*args, &block)
+      ShellEscaped.new(CommandLine.new(*args, &block))
     end
   end
 
@@ -146,18 +204,26 @@ module Mattock
     end
 
     def command
-      "'" + @escaped.command.gsub(/'/,"\'") + "'"
+      "'" + @escaped.string_format.gsub(/'/,"\'") + "'"
+    end
+
+    def command_environment
+      {}
     end
 
     def name
       @name || @escaped.name
     end
+
+    def to_s
+      command
+    end
   end
 
   class CommandChain < CommandLine
     def initialize
       @commands = []
-      yield self if block_given?
+      super(nil)
     end
 
     attr_reader :commands
@@ -168,6 +234,14 @@ module Mattock
       self
     end
 
+    #Honestly this is sub-optimal - biggest driver for considering the
+    #mini-shell approach here.
+    def command_environment
+      @commands.reverse.inject({}) do |env, command|
+        env.merge(command.command_environment)
+      end
+    end
+
     def name
       @name || @commands.last.name
     end

data/lib/mattock/command-task.rb

@@ -10,6 +10,23 @@ module Mattock
     runtime_setting(:verify_command, nil)
     runtime_setting(:command)
 
+    def resolve_runtime_configuration
+      super
+      #If there's a second troublesome command, this becomes a class-level
+      #array
+      if not verify_command.nil? and verify_command.name == "bundle"
+        unless BundleCommandTask === self
+          warn "Verify command is 'bundle' - this sometimes has unexpected results.  Consider BundleCommandTask"
+        end
+      end
+
+      if command.name == "bundle"
+        unless BundleCommandTask === self
+          warn "Command is 'bundle' - this sometimes has unexpected results.  Consider BundleCommandTask"
+        end
+      end
+    end
+
     def verify_command
       if @verify_command.respond_to?(:call)
         @verify_command = @verify_command.call

data/lib/mattock/remote-command-task.rb

@@ -10,6 +10,7 @@ module Mattock
     runtime_setting(:remote_target)
 
     def resolve_runtime_configuration
+      super
       self.remote_target ||= [remote_server.user, remote_server.address].compact.join('@') unless remote_server.address.nil?
     end
 

data/lib/mattock/task.rb

@@ -1,6 +1,9 @@
 require 'mattock/cascading-definition'
+require 'singleton' #Rake fails to require this properly
 require 'rake/task'
 require 'rake/file_task'
+require 'rake/file_creation_task'
+require 'rake/multi_task'
 
 module Mattock
   # A configurable subclass of Rake::Task, such that you can use a
@@ -38,6 +41,7 @@ module Mattock
     end
 
     def resolve_configuration
+      super
       if @extracted_task_args.empty?
         self.task_args = [task_name]
       else
@@ -83,16 +87,23 @@ module Mattock
       "#{self.class.name}: #{self.task_args.inspect}"
     end
 
+    attr_accessor :rake_task
     def define
-      task = task_class.define_task(*task_args) do
+      self.rake_task = task_class.define_task(*task_args) do
         finalize_configuration
-        task.action
+        copy_settings_to(rake_task)
+        rake_task.action
       end
-      task.source_task = self
-      copy_settings_to(task)
+      copy_settings_to(rake_task)
+      rake_task.source_task = self
     end
   end
 
+  #I'm having misgivings about this design choice.  Rightly, this is probably a
+  #"Task Definer" that knows what class to ::define_task and then mixin a
+  #module to handle the original purpose of being able to override e.g.
+  ##needed?  There's a lot of client code that relies on this pattern now,
+  #though.
   class Task < Rake::Task
     include TaskMixin
   end

data/lib/mattock/testing/mock-command-line.rb

@@ -24,45 +24,43 @@ module Mattock
     alias exit_status exit_code
   end
 
+  class CommandLine
+    def self.execute(*args)
+      fail "Command line executed in specs without 'expect_command' or 'expect_some_commands'"
+    end
+  end
+
   module CommandLineExampleGroup
-    def self.included(group)
-      group.class_eval do
-        let :pairs do
-          []
-        end
+    module MockingExecute
+      def execute
+        Mattock::CommandLine.execute(command)
+      end
+    end
 
-        before :each do
-          Mattock::CommandLine.should_receive(:execute) do |cmd|
-            pattern, res = pairs.shift
-            pattern.should =~ cmd
-            Mattock::MockCommandResult.create(*res)
-          end.any_number_of_times
-        end
 
-        after :each do
-          pairs.should have_all_been_called
+    def self.included(group)
+      group.before :each do
+        @original_execute = Mattock::CommandLine.instance_method(:execute)
+        unless MockingExecute > Mattock::CommandLine
+          Mattock::CommandLine.send(:include, MockingExecute)
         end
+        Mattock::CommandLine.send(:remove_method, :execute)
       end
-    end
 
-    def expect_command(cmd, *result)
-      raise ArgumentError, "Regexp expected: not #{cmd.inspect}" unless Regexp === cmd
-      pairs << [cmd, result]
+      group.after :each do
+        Mattock::CommandLine.send(:define_method, :execute, @original_execute)
+      end
     end
 
-    module Matchers
-      extend RSpec::Matchers::DSL
-
-      define :have_all_been_called do
-        match do |list|
-          list.empty?
-        end
+    #Registers indifference as to exactly what commands get called
+    def expect_some_commands
+      Mattock::CommandLine.should_receive(:execute).any_number_of_times.and_return(MockCommandResult.create(0))
+    end
 
-        failure_message_for_should do |list|
-          "Expected all commands to be run, but: #{list.map{|item| item[0].source.inspect}.join(", ")} #{list.length > 1 ? "were" : "was"} not."
-        end
-      end
+    #Registers an expectation about a command being run - expectations are
+    #ordered
+    def expect_command(cmd, *result)
+      Mattock::CommandLine.should_receive(:execute, :expected_from => caller(1)[0]).with(cmd).ordered.and_return(MockCommandResult.create(*result))
     end
-    include Matchers
   end
 end

data/lib/mattock/testing/record-commands.rb

@@ -3,15 +3,15 @@ require 'mattock/command-line'
 module Mattock
   class CommandLine
     @@commands = []
-    class << self
-      alias original_execute execute
+    alias original_execute execute
 
-      def execute(command)
-        result = original_execute(command)
-        @@commands << [command, result]
-        return result
-      end
+    def execute
+      result = original_execute
+      @@commands << [command, result]
+      return result
+    end
 
+    class << self
       attr_accessor :command_recording_path
 
       def command_recording_path

data/spec/command-line.rb

@@ -46,6 +46,59 @@ describe Mattock::CommandLine do
   end
 end
 
+describe Mattock::CommandLine, "setting environment variables" do
+  let :commandline do
+    Mattock::CommandLine.new("env") do |cmd|
+      cmd.env["TEST_ENV"] = "indubitably"
+    end
+  end
+
+  let :result do
+    commandline.run
+  end
+
+  it "should succeed" do
+    result.succeeded?.should be_true
+  end
+
+  it "should alter the command's environment variables" do
+    result.stdout.should =~ /TEST_ENV.*indubitably/
+  end
+
+end
+
+describe Mattock::PipelineChain do
+  let :commandline do
+    Mattock::PipelineChain.new do |chain|
+      chain.add Mattock::CommandLine.new("env")
+      chain.add Mattock::CommandLine.new("cat") do |cmd|
+        cmd.env["TEST_ENV"] = "indubitably"
+      end
+    end
+  end
+
+  let :result do
+    commandline.run
+  end
+
+  it "should produce the right command" do
+    commandline.command.should == 'env | cat'
+  end
+
+  it "should produce a runnable command with format_string" do
+    commandline.string_format.should == 'TEST_ENV=indubitably env | cat'
+  end
+
+  it "should succeed" do
+    result.succeeded?.should be_true
+  end
+
+  it "should alter the command's environment variables" do
+    result.stdout.should =~ /TEST_ENV.*indubitably/
+  end
+end
+
+
 describe Mattock::CommandLineDSL do
   include described_class
 
@@ -77,7 +130,7 @@ describe Mattock::CommandLineDSL do
     end
   end
 
-  describe "using the && operator" do
+  describe "using the & operator" do
     let :command do
       cmd("cd", "/tmp/trash") & %w{rm -rf *}
     end

data/spec/configurable.rb

@@ -32,7 +32,6 @@ describe Mattock::Configurable do
 
   it "should complain about unset required fields" do
     expect do
-      p subject
       subject.check_required
     end.to raise_error
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mattock
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-17 00:00:00.000000000 Z
+date: 2012-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: corundum
-  requirement: &82047460 !ruby/object:Gem::Requirement
+  requirement: &84431630 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.0.1
   type: :development
   prerelease: false
-  version_requirements: *82047460
+  version_requirements: *84431630
 - !ruby/object:Gem::Dependency
   name: valise
-  requirement: &82046930 !ruby/object:Gem::Requirement
+  requirement: &84446980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -35,10 +35,10 @@ dependencies:
         - 6
   type: :runtime
   prerelease: false
-  version_requirements: *82046930
+  version_requirements: *84446980
 - !ruby/object:Gem::Dependency
   name: tilt
-  requirement: &82046620 !ruby/object:Gem::Requirement
+  requirement: &84446570 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>'
@@ -48,7 +48,7 @@ dependencies:
         - 0
   type: :runtime
   prerelease: false
-  version_requirements: *82046620
+  version_requirements: *84446570
 description: ! "  If Rake won't do it by itself, you oughtta Mattock.\n\n  If you
   survived the pun, you might enjoy this gem.\n\n  Features:\n\n  * Extensions to
   Tasklibs to support powerful deerpaths.\n  * A commandline library that supports
@@ -101,7 +101,7 @@ rdoc_options:
 - --main
 - doc/README
 - --title
-- mattock-0.3.0 RDoc
+- mattock-0.3.1 RDoc
 require_paths:
 - lib/
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -112,7 +112,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 900034003
+      hash: -637040849
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: