mattock 0.7.1 → 0.8.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NWNjNzNlOTczNWY3ZmIzZjc2MWFkMDJkZTI1NzJhODg1Y2JjZDYzMA==
-  data.tar.gz: !binary |-
-    MDEyYmRjYTk1MzcwNjQ0NGE5MzlhM2JkMzk2Y2FkMmQwYWIyMWJmNg==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    MmQ2ZDc1M2I4MzBjZjM2ZTE1YzliZDc3MWE5NjQ5YzVlODFhZGMwZWFkZDBl
-    MTA5NzFmYWRlNWU3ZDdkYmI3M2ZhNTg5MGM1N2YwMDAwNmFiZWUyZDgyYTJi
-    MmU1ODhhM2NkZGJkN2M0OTEwYTA5ODg2YTExODhjNjliOGNmM2Y=
-  data.tar.gz: !binary |-
-    YmQ5OGQ1MGIzOGYxNmRhZGEzNDBjZjEzMjY0NTRmMGQ0NjMwM2M0MDEyMTgx
-    M2E4NTgyZTVmMmQ3NWY2MzAzYzQ2NmU2NzYwNWQzYTA0ZmM4NDlmNDE0OTM0
-    M2E3MjUxZTMxY2RhOGY5ZDVmNjM1YjYwOTI1OTE2MGY0OGY4OTY=
+SHA1:
+  metadata.gz: 4c1151f03e2d5b1b2beae2dbe83fc913acc5781d
+  data.tar.gz: 76e9f884109d43f50acfdf12683f8f8922492410
+SHA512:
+  metadata.gz: 64dd7f1524c69be09ec730ef8d12493d0f0db779a08bac00b1acbf1e17eb9d5c69040cae92e5897faf25b4fb5845d850c3d6207ca11c51ceb145adf1dd5b218f
+  data.tar.gz: 7bdd7d4d2c1010ea3fefad1fd0cf0641398207ff339dbc943bd0d2edadc6655baea1ed80f55ff1c074b40ee19f269acd958af36fd49f89d19d51fd59e34296c5

data/lib/mattock.rb

@@ -1,4 +1,4 @@
 require 'mattock/tasklib'
-require 'mattock/command-line'
 require 'mattock/remote-command-task'
+require 'mattock/command-tasklib'
 require 'mattock/template-host'

data/lib/mattock/command-task.rb

@@ -1,12 +1,19 @@
 require 'mattock/task'
-require 'mattock/command-line'
+begin
+  require 'caliph'
+rescue LoadError => le
+  if le.message =~ /caliph/
+    puts "Mattock's CommandTask (and subclasses) requires a gem called 'caliph' now. Add it to your Gemfile"
+  end
+  raise
+end
 
 module Mattock
   module CommandTaskMixin
-    include CommandLineDSL
+    include Caliph::CommandLineDSL
 
     def self.included(sub)
-      sub.extend CommandLineDSL
+      sub.extend Caliph::CommandLineDSL
       sub.runtime_setting(:verify_command, nil)
       sub.runtime_setting(:command)
     end
@@ -39,12 +46,20 @@ module Mattock
       command
     end
 
+    def self.shell
+      @shell ||= Caliph.new
+    end
+
+    def shell
+      CommandTaskMixin.shell
+    end
+
     def action(args)
-      decorated(command).must_succeed!
+      shell.run(decorated(command)).must_succeed!
     end
 
     def check_verification_command
-      !decorated(verify_command).succeeds?
+      !shell.run(decorated(verify_command)).succeeds?
     end
 
     def needed?

data/lib/mattock/command-tasklib.rb

@@ -0,0 +1,7 @@
+require 'mattock/tasklib'
+
+module Mattock
+  class CommandTaskLib < TaskLib
+    include Caliph::CommandLineDSL
+  end
+end

data/lib/mattock/configurable/class-methods.rb

@@ -107,7 +107,7 @@ module Mattock
 
         attr_writer(name)
         define_method(metadata.reader_method) do
-          value = metadata.value_on(self)
+          metadata.value_on(self)
         end
 
         if existing = default_values.find{|field| field.name == name} and existing.default_value != default_value
@@ -193,6 +193,29 @@ module Mattock
         }])
       end
 
+      def from_hash(obj, hash) #XXX It'd be really nice if this could report unused fields
+        if Configurable > superclass
+          superclass.from_hash(obj, hash)
+        end
+        default_values.each do |field|
+          catch :next do
+            key = field.reader_method.to_s
+            value = hash.fetch(key.to_s) do
+              key = key.to_sym
+              hash.fetch(key) do
+                throw :next
+              end
+            end
+
+            existing_value = obj.__send__(field.reader_method)
+            if Configurable === existing_value and value.is_a? Hash
+              existing_value.from_hash(value)
+            else
+              obj.__send__(field.writer_method, value)
+            end
+          end
+        end
+      end
 
       def included(mod)
         mod.extend ClassMethods

data/lib/mattock/configurable/instance-methods.rb

@@ -27,6 +27,10 @@ module Mattock
       self.class.to_hash(self)
     end
 
+    def from_hash(hash)
+      self.class.from_hash(self, hash)
+    end
+
     def unset_defaults_guard
       raise "Tried to check required settings before running setup_defaults"
     end

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

@@ -20,21 +20,19 @@ module Mattock
         fail "Need remote server for #{self.class.name}" unless remote_server.address
 
         raise "Empty remote command" if command_on_remote.nil?
-        Mattock::WrappingChain.new do |cmd|
-          cmd.add Mattock::CommandLine.new("ssh") do |cmd|
-            cmd.options << "-i #{id_file}" if id_file
-            cmd.options << "-l #{remote_server.user}" unless remote_server.user.nil?
-            cmd.options << remote_server.address
-            cmd.options << "-p #{remote_server.port}" #ok
-            cmd.options << "-n"
-            cmd.options << "-#{'v'*verbose}" if verbose > 0
-            unless ssh_options.empty?
-              ssh_options.each do |opt|
-                cmd.options << "-o #{opt}"
-              end
+        cmd("ssh") do |cmd|
+          cmd.options << "-i #{id_file}" if id_file
+          cmd.options << "-l #{remote_server.user}" unless remote_server.user.nil?
+          cmd.options << remote_server.address
+          cmd.options << "-p #{remote_server.port}" #ok
+          cmd.options << "-n"
+          cmd.options << "-#{'v'*verbose}" if verbose > 0
+          unless ssh_options.empty?
+            ssh_options.each do |opt|
+              cmd.options << "-o #{opt}"
             end
           end
-          cmd.add Mattock::ShellEscaped.new(command_on_remote)
+          cmd - escaped_command(command_on_remote)
         end
       end
     end

data/spec/command-task.rb

@@ -1,28 +1,26 @@
 require 'mattock/remote-command-task'
 require 'mattock/bundle-command-task'
+
 require 'mattock/testing/rake-example-group'
-require 'mattock/testing/mock-command-line'
+require 'caliph/testing/mock-command-line'
 
 describe Mattock::RemoteCommandTask do
   include Mattock::RakeExampleGroup
-  include Mattock::CommandLineExampleGroup
+  include Caliph::CommandLineExampleGroup
 
   let! :remote_task do
     namespace :test do
       Mattock::Rake::RemoteCommandTask.define_task do |t|
         t.remote_server.address = "nowhere.com"
-        t.command = Mattock::PrereqChain.new do |prereq|
-          prereq.add Mattock::CommandLine.new("cd", "a_dir")
-          prereq.add Mattock::PipelineChain.new do |pipe|
-            pipe.add Mattock::CommandLine.new("ls")
-            pipe.add Mattock::CommandLine.new("grep") do |cmd|
-              cmd.options << "*.rb"
-              cmd.redirect_stderr("/dev/null")
-              cmd.redirect_stdout("/tmp/rubyfiles.txt")
-            end
-          end
+        t.command = t.cmd do |cmd|
+          cmd.from("cd", "a_dir")
+          cmd &= "ls"
+          cmd |= "grep"
+          cmd.options << "*.rb"
+          cmd.redirect_stderr("/dev/null")
+          cmd.redirect_stdout("/tmp/rubyfiles.txt")
         end
-        t.verify_command = Mattock::CommandLine.new("should_do")
+        t.verify_command = t.cmd("should_do")
       end
     end
   end
@@ -43,7 +41,7 @@ end
 
 describe Mattock::BundleCommandTask do
   include Mattock::RakeExampleGroup
-  include Mattock::CommandLineExampleGroup
+  include Caliph::CommandLineExampleGroup
 
   let! :bundle_task do
     Mattock::BundleCommandTask.define_task(:bundle_test) do |t|

data/spec/configurable.rb

@@ -35,6 +35,13 @@ describe Mattock::Configurable do
     hash[:two][:a].should == "a"
   end
 
+  it "#from_hash" do
+    subject.from_hash({:one => 111, "two" => { :a => "aaa" }})
+
+    subject.one.should == 111
+    subject.two.a.should == "aaa"
+  end
+
   it "should complain about unset required fields" do
     expect do
       subject.check_required
@@ -115,7 +122,7 @@ describe Mattock::Configurable do
     it "should complain about missing fields" do
       expect do
         subject.check_required
-      end.to raise_error /Required field/
+      end.to raise_error(/Required field/)
     end
 
     it "should inspect cleanly" do
@@ -134,7 +141,7 @@ describe Mattock::Configurable do
       it "should complain about missing fields" do
         expect do
           subject.check_required
-        end.to raise_error /Required field/
+        end.to raise_error(/Required field/)
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mattock
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Judson Lester
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-24 00:00:00.000000000 Z
+date: 2014-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: corundum
@@ -56,20 +56,41 @@ dependencies:
   name: tilt
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>'
+    - - '>'
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>'
+    - - '>'
       - !ruby/object:Gem::Version
         version: '0'
-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
-  mocking for tests.\n  * A module to support common templating patterns\n\n"
+- !ruby/object:Gem::Dependency
+  name: caliph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+description: |2+
+    If Rake won't do it by itself, you oughtta Mattock.
+
+    If you survived the pun, you might enjoy this gem.
+
+    Features:
+
+    * Extensions to Tasklibs to support powerful deerpaths.
+    * A commandline library that supports mocking for tests.
+    * A module to support common templating patterns
+
 email:
 - nyarly@gmail.com
 executables: []
@@ -84,12 +105,9 @@ files:
 - yard_templates/default/module/html/task_definition.erb
 - yard_templates/default/layout/html/setup.rb
 - yard_templates/default/layout/html/tasklib_list.erb
-- lib/mattock/command-line.rb
-- lib/mattock/command-line/command-run-result.rb
 - lib/mattock/command-task.rb
+- lib/mattock/command-tasklib.rb
 - lib/mattock/testing/rake-example-group.rb
-- lib/mattock/testing/mock-command-line.rb
-- lib/mattock/testing/record-commands.rb
 - lib/mattock/template-host.rb
 - lib/mattock/yard_extensions.rb
 - lib/mattock/remote-command-task.rb
@@ -109,7 +127,6 @@ files:
 - lib/mattock.rb
 - doc/README
 - doc/Specifications
-- spec/command-line.rb
 - spec/command-task.rb
 - spec/tasklib.rb
 - spec/configurable.rb
@@ -128,17 +145,17 @@ rdoc_options:
 - --main
 - doc/README
 - --title
-- mattock-0.7.1 RDoc
+- mattock-0.8.0 RDoc
 require_paths:
 - lib/
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []

data/lib/mattock/command-line.rb

@@ -1,258 +0,0 @@
-require 'mattock/command-line/command-run-result'
-
-module Mattock
-  class CommandLine
-    class << self
-      def define_chain_op(opname, klass)
-        define_method(opname) do |other|
-          unless CommandLine === other
-            other = CommandLine.new(*[*other])
-          end
-          chain = nil
-          if klass === self
-            chain = self
-          else
-            chain = klass.new
-            chain.add(self)
-          end
-          chain.add(other)
-        end
-      end
-
-      def define_op(opname)
-        CommandLine.define_chain_op(opname, self)
-      end
-
-      attr_accessor :output_stream
-    end
-
-    def initialize(executable, *options)
-      @output_stream = self.class.output_stream || $stderr
-      @executable = executable
-      @options = options
-      @redirections = []
-      @env = {}
-      yield self if block_given?
-    end
-
-    attr_accessor :name, :executable, :options, :env, :output_stream
-    attr_reader :redirections
-
-    alias_method :command_environment, :env
-
-    def set_env(name, value)
-      command_environment[name] = value
-      return self
-    end
-
-    def verbose
-      ::Rake.verbose && ::Rake.verbose != ::Rake::FileUtilsExt::DEFAULT
-    end
-
-    def name
-      @name || executable
-    end
-
-    def command
-      ([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
-
-    def redirect_to(stream, path)
-      @redirections << "#{stream}>#{path}"
-    end
-
-    def redirect_from(path, stream)
-      @redirections << "#{stream}<#{path}"
-    end
-
-    def copy_stream_to(from, to)
-      @redirections << "#{from}>&#{to}"
-    end
-
-    def redirect_stdout(path)
-      redirect_to(1, path)
-    end
-
-    def redirect_stderr(path)
-      redirect_to(2, path)
-    end
-
-    def redirect_stdin(path)
-      redirect_from(path, 0)
-    end
-
-    def replace_us
-      output_steeam.puts "Ceding execution to: "
-      output_stream.puts string_format
-      Process.exec(command_environment, command)
-    end
-
-    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)
-      result = CommandRunResult.new(pid, self)
-      result.streams = {1 => host_stdout, 2 => host_stderr}
-      result.wait
-      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
-
-    #Run a command in the background.  The command can survive the caller
-    def spin_off
-      pid, out, err = spawn_process
-      Process.detach(pid)
-      return pid, out, err
-    end
-
-    #Run a command in parallel with the parent process - will kill it if it
-    #outlasts us
-    def background
-      pid, out, err = spawn_process
-      Process.detach(pid)
-      at_exit do
-        kill_process(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 report(message, newline=true)
-      output_stream.print(message + (newline ? "\n" : ""))
-    end
-
-    def run
-      report string_format + " ", false
-      result = execute
-      report "=> #{result.exit_code}"
-      report result.format_streams if verbose
-      return result
-    ensure
-      report "" if verbose
-    end
-
-    def succeeds?
-      run.succeeded?
-    end
-
-    def must_succeed!
-      run.must_succeed!
-    end
-  end
-
-  module CommandLineDSL
-    def cmd(*args, &block)
-      CommandLine.new(*args, &block)
-    end
-
-    def escaped_command(*args, &block)
-      ShellEscaped.new(CommandLine.new(*args, &block))
-    end
-  end
-
-  class ShellEscaped < CommandLine
-    def initialize(cmd)
-      @escaped = cmd
-    end
-
-    def command
-      "'" + @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 = []
-      @command_environment = {}
-      super(nil)
-    end
-
-    attr_reader :commands
-
-    def add(cmd)
-      yield cmd if block_given?
-      @commands << cmd
-      self
-    end
-
-    #Honestly this is sub-optimal - biggest driver for considering the
-    #mini-shell approach here.
-    def command_environment
-      @command_environment = @commands.reverse.inject(@command_environment) do |env, command|
-        env.merge(command.command_environment)
-      end
-    end
-
-    def name
-      @name || @commands.last.name
-    end
-  end
-
-  class WrappingChain < CommandChain
-    define_op('-')
-
-    def command
-      @commands.map{|cmd| cmd.command}.join(" -- ")
-    end
-  end
-
-  class PrereqChain < CommandChain
-    define_op('&')
-
-    def command
-      @commands.map{|cmd| cmd.command}.join(" && ")
-    end
-  end
-
-  class PipelineChain < CommandChain
-    define_op('|')
-
-    def command
-      @commands.map{|cmd| cmd.command}.join(" | ")
-    end
-  end
-end

data/lib/mattock/command-line/command-run-result.rb

@@ -1,131 +0,0 @@
-module Mattock
-  class CommandLine
-    class CommandRunResult
-      def initialize(pid, command)
-        @command = command
-        @pid = pid
-
-        #####
-        @process_status = nil
-        @streams = {}
-        @consume_timeout = nil
-      end
-      attr_reader :process_status, :pid
-      attr_accessor :consume_timeout, :streams
-
-      def stdout
-        @streams[1]
-      end
-
-      def stderr
-        @streams[2]
-      end
-
-      def exit_code
-        @process_status.exitstatus
-      end
-      alias exit_status exit_code
-
-      def succeeded?
-        must_succeed!
-        return true
-      rescue
-        return false
-      end
-
-      def format_streams
-        "stdout:#{stdout.nil? || stdout.empty? ? "[empty]\n" : "\n#{stdout}"}" +
-        "stderr:#{stderr.nil? || 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#{format_streams}"
-        end
-      end
-
-      def wait
-        @accumulators = {}
-        waits = {}
-        @buffered_echo = []
-
-        ioes = streams.values
-        ioes.each do |io|
-          @accumulators[io] = []
-          waits[io] = 3
-        end
-        begin_echoing = Time.now + (@consume_timeout || 3)
-
-        @live_ioes = ioes.dup
-
-        until @live_ioes.empty? do
-          newpid, @process_status = Process.waitpid2(pid, Process::WNOHANG)
-
-          unless @process_status.nil?
-            consume_buffers(@live_ioes)
-            break
-          end
-
-          timeout = 0
-
-          if !@buffered_echo.nil?
-            timeout = begin_echoing - Time.now
-            if timeout < 0
-              @command.report ""
-              @command.report "Long running command output:"
-              @command.report @buffered_echo.join
-              @buffered_echo = nil
-            end
-          end
-
-          if timeout > 0
-            result = IO::select(@live_ioes, [], @live_ioes, timeout)
-          else
-            result = IO::select(@live_ioes, [], @live_ioes, 1)
-          end
-
-          unless result.nil? #timeout
-            readable, _writeable, errored = *result
-            unless errored.empty?
-              raise "Error on IO: #{errored.inspect}"
-            end
-
-            consume_buffers(readable)
-          end
-        end
-
-        if @process_status.nil?
-          newpid, @process_status = Process.waitpid2(pid)
-        end
-
-        ioes.each do |io|
-          io.close
-        end
-        @streams = Hash[ioes.each_with_index.map{|io, index| [index + 1, @accumulators[io].join]}]
-      end
-
-      def consume_buffers(readable)
-        if not(readable.nil? or readable.empty?)
-          readable.each do |io|
-            begin
-              while chunk = io.read_nonblock(4096)
-                if @buffered_echo.nil?
-                  @command.report chunk, false
-                else
-                  @buffered_echo << chunk
-                end
-                @accumulators[io] <<  chunk
-              end
-            rescue IO::WaitReadable => ex
-            rescue EOFError => ex
-              @live_ioes.delete(io)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-require 'mattock/command-line'
-
-module Mattock
-  class MockCommandResult < CommandLine::CommandRunResult
-    def self.create(*args)
-      if args.length == 1
-        args = [args[0], {1 => ""}]
-      end
-
-      if String == args[1]
-        args[1] = {1 => args[1]}
-      end
-
-      return self.new(*args)
-    end
-
-    def initialize(code, streams)
-      @streams = streams
-      @exit_code = code
-    end
-
-    attr_reader :exit_code, :streams
-
-    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
-    include CommandLineDSL
-    module MockingExecute
-      def execute
-        Mattock::CommandLine.execute(command)
-      end
-    end
-
-
-    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
-
-      group.after :each do
-        Mattock::CommandLine.send(:define_method, :execute, @original_execute)
-      end
-    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
-
-    #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
-  end
-end

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

@@ -1,38 +0,0 @@
-require 'mattock/command-line'
-
-module Mattock
-  class CommandLine
-    @@commands = []
-    alias original_execute execute
-
-    def execute
-      result = original_execute
-      @@commands << [command, result]
-      return result
-    end
-
-    class << self
-      attr_accessor :command_recording_path
-
-      def command_recording_path
-        @command_recording_path ||= ENV['MATTOCK_CMDREC']
-      end
-
-      def emit_recording
-        io = $stderr
-        if command_recording_path
-          io = File.open(command_recording_path, "w")
-        else
-          io.puts "Set MATTOCK_CMDREC to write to a path"
-        end
-        @@commands.each do |pair|
-          io.puts "[/#{pair[0]}/, #{[pair[1].exit_code, pair[1].streams].inspect}]"
-        end
-      end
-    end
-  end
-end
-
-at_exit do
-  Mattock::CommandLine.emit_recording
-end

data/spec/command-line.rb

@@ -1,162 +0,0 @@
-require 'mattock/command-line'
-require 'mattock/testing/rake-example-group'
-require 'mattock/testing/mock-command-line'
-
-require 'mattock/testing/record-commands'
-
-Mattock::CommandLine.command_recording_path = "/dev/null"
-
-describe Mattock::CommandLine do
-  let :commandline do
-    Mattock::CommandLine.new('echo', "-n") do |cmd|
-      cmd.options << "Some text"
-    end
-  end
-
-  it "should have a name set" do
-    commandline.name.should == "echo"
-  end
-
-  it "should produce a command string" do
-    commandline.command.should == "echo -n Some text"
-  end
-
-  it "should succeed" do
-    commandline.succeeds?.should be_true
-  end
-
-  it "should not complain about success" do
-    expect do
-      commandline.must_succeed!
-    end.to_not raise_error
-  end
-
-  describe Mattock::CommandLine::CommandRunResult do
-    let :result do
-      commandline.run
-    end
-
-    it "should have a result code" do
-      result.exit_code.should == 0
-    end
-
-    it "should have stdout" do
-      result.stdout.should == "Some text"
-    end
-  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
-
-  describe "using the - operator" do
-    let :command do
-      cmd("sudo") - ["gem", "install", "bundler"]
-    end
-
-    it "should define commands" do
-      command.should be_an_instance_of(Mattock::WrappingChain)
-      command.should have(2).commands
-      command.commands[0].should be_an_instance_of(Mattock::CommandLine)
-      command.commands[1].should be_an_instance_of(Mattock::CommandLine)
-      command.command.should == "sudo -- gem install bundler"
-    end
-  end
-
-  describe "using the | operator" do
-    let :command do
-      cmd("cat", "/etc/passwd") | ["grep", "root"]
-    end
-
-    it "should define commands" do
-      command.should be_an_instance_of(Mattock::PipelineChain)
-      command.should have(2).commands
-      command.commands[0].should be_an_instance_of(Mattock::CommandLine)
-      command.commands[1].should be_an_instance_of(Mattock::CommandLine)
-      command.command.should == "cat /etc/passwd | grep root"
-    end
-  end
-
-  describe "using the & operator" do
-    let :command do
-      cmd("cd", "/tmp/trash") & %w{rm -rf *}
-    end
-
-    it "should define commands" do
-      command.should be_an_instance_of(Mattock::PrereqChain)
-      command.should have(2).commands
-      command.commands[0].should be_an_instance_of(Mattock::CommandLine)
-      command.commands[1].should be_an_instance_of(Mattock::CommandLine)
-      command.command.should == "cd /tmp/trash && rm -rf *"
-    end
-  end
-end
-
-describe Mattock::CommandLine, "that fails" do
-  let :commandline do
-    Mattock::CommandLine.new("false")
-  end
-
-  it "should not succeed" do
-    commandline.succeeds?.should == false
-  end
-
-  it "should raise error if succeed demanded" do
-    expect do
-      commandline.must_succeed
-    end.to raise_error
-  end
-end