doughboy 0.0.4 → 0.1.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    doughboy (0.0.3)
+    doughboy (0.1.0)
       open4 (~> 1.0.1)
 
 GEM

data/README.markdown

@@ -1,35 +1,35 @@
 Doughboy
 ========
 
-Doughboy is a Ruby library that strives to enable developers to easily make subprocessed shell calls. 
+Doughboy is a Ruby library that strives to enable developers to simply make subprocessed shell calls. 
 
 Usage
 --------
 
-Doughboy provides a compossible interface to crafting shell commands.
+Doughboy provides a composable interface to crafting shell commands. The following composition methods are available:
 
-    command = Doughboy.with_exec("ruby").with_options(["-v"])
-    command.run!
+    Doughboy.new("ruby -v")
+    Doughboy.new("python", "setup.py")
+    Doughboy.new(:executable => "python", :arguments => "setup.py")
 
-Commands components can be set directly on any object.
+Doing any of these things will return a command object that can be told to run:
 
-    command = Doughboy::Command.new(:executable => "easy_install", :arguments => "some-python-library").run!
+    command = Doughboy.new("ruby -v")
+    command.run #=> returns and Output object
 
-The preferred method is to use the composable chain methods.
+The Output object includes the output methods: pid, stdin, stdout, stderr. For a shortcut, use the .text method. To create and run a new command, use the .with_exec shortcut:
+
+    output = Doughboy.with_exec("ruby -v") #=> returns an Output object
 
 Command Components
 ------------------
 
-Each command is composed of 3 separate components: executable, options, arguments.
+Each command is composed of 2 components, executable and arguments.
 
 ### Executable
 
 When this component is set, the full-path is captured. If no path information could be determined, the executable passed will be used.
 
-### Options
-
-Options are command line switches that either start w/ "-" or "--". 
-
 ### Arguments
 
 Arguments are items that are passed to the executable. They might be a list of ip addresses or files.
@@ -37,7 +37,7 @@ Arguments are items that are passed to the executable. They might be a list of i
 Origin of the Name
 ------------------
 
-I wish I could say that it was meant to pay homage to the fighting men of the Lost Generation, but it's not. I was watching Boyz N The Hood. 
+I wish I could say that it was meant to pay homage to the fighting men of the Lost Generation, but it's not. I was watching Boyz N The Hood. We got a problem here?
 
 ![Doughboy](http://2.bp.blogspot.com/_xdN0QQwsP1A/TDhzYsJhkpI/AAAAAAAAJZk/yjqX6ZNF1t8/s400/boyz_n_the_hood_xlg+ICE+Cube+crop.jpg)
 

data/lib/doughboy.rb

@@ -5,8 +5,12 @@ require 'doughboy/output'
 
 module Doughboy
 
-  def self.with_exec(command)
-    Command.with_exec(command)
+  def self.with_exec(*args)
+    Command.with_exec(*args)
+  end
+
+  def self.new(*args)
+    Command.new(*args)
   end
 
 end

data/lib/doughboy/command.rb

@@ -1,61 +1,56 @@
 module Doughboy
   class Command
-    attr_accessor :arguments, :executable, :full_arguments, :options
+    attr_accessor :arguments, :executable
+
+    # Command.new
+    # Command.new("python setup.py develop")
+    # Command.new("python", "setup.py develop")
+    # Command.new(:executable => "python", :arguments => "setup.py develop")
 
     def initialize(*args)
-      if args.any?
-        local_args = args.first
+      return self if args.empty?
+      parsed_args = args.first.is_a?(Hash) ? args.first : parse_string_args(args)
 
-        %w( arguments executable options full_arguments).each do |arg|
-          self.send("#{arg}=", local_args[arg.intern])
-        end
-      end
+      self.executable = parsed_args[:executable]
+      self.arguments  = parsed_args[:arguments]
     end
 
-    def self.with_exec(command)
-      parsed_command = parse_command(command)
-
-      new( :executable     => parsed_command[:executable],
-           :arguments      => parsed_command[:arguments],
-           :options        => parsed_command[:options],
-           :full_arguments => parsed_command[:full_arguments])
+    def self.with_exec(*args)
+      command = new(*args)
+      command.run
     end
 
     def command
-      if full_arguments
-        [executable, full_arguments].join(" ")
-      else
-        [executable, options, arguments].join(" ")
-      end
+      [executable, arguments].join(" ")
     end
 
     def executable=(value)
       return nil if value.nil?
+
       full_path = `which #{value}`.strip
       @executable = full_path != "" ? full_path : value
     end
 
-    def options=(value)
-      return nil if value.nil?
-      @options = value.is_a?(Array) ? value : value.split(" ")
-    end
-
-    def run!
+    def run
       Output.new( Open4::popen4(command) )
     end
 
     private
-    def self.parse_command(command)
+    def self.parse_executable(command)
       split_command = command.split(" ")
       parsed_command = { }
-      args_and_opts = split_command[1..(split_command.size-1)]
 
-      parsed_command[:full_arguments] = args_and_opts
       parsed_command[:executable] = split_command[0]
-      parsed_command[:arguments] = args_and_opts.select { |t| !t.include?("-") }.join(" ")
-      parsed_command[:options]   = args_and_opts.select { |t| t.include?("-") }
+      parsed_command[:arguments]  = split_command[1..(split_command.size-1)]
       parsed_command
     end
 
+    def parse_string_args(args)
+      if args.size == 1
+        self.class.parse_executable(args.first)
+      else
+        { :executable => args.first, :arguments => args[1]}
+      end
+    end
   end
 end

data/lib/doughboy/version.rb

@@ -1,3 +1,3 @@
 module Doughboy
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/spec/doughboy/command_spec.rb

@@ -3,30 +3,51 @@ require 'spec_helper'
 module Doughboy
   describe Command do
     describe ".new" do
-      context "with a string argument" do
-        it "sets the executable"
+      context "with no arugments" do
+        it "does not error" do
+          lambda { Command.new }.should_not raise_exception
+        end
       end
 
-      context "with a hash argument" do
+      context "with a single string argument" do
+        it "sets the executable" do
+          command = Command.new("python setup.py develop")
+          command.executable.should_not be_nil
+        end
+
         it "sets the arguments" do
-          command = Command.new(:arguments => "setup.py develop")
+          command = Command.new("python setup.py develop")
+          command.arguments.should_not be_nil
+        end
+      end
+
+      context "with a double string argument" do
+        it "sets the executable" do
+          command = Command.new("python", "setup.py develop")
+          command.executable.should_not be_nil
+        end
+
+        it "sets the arguments" do
+          command = Command.new("python", "setup.py develop")
           command.arguments.should_not be_nil
         end
 
+      end
+
+      context "with a hash argument" do
         it "sets the executeable" do
           command = Command.new(:executable => "python")
           command.executable.should_not be_nil
         end
 
-        it "sets the options" do
-          options = "-r -i"
-          command = Command.new(:options => options)
-          command.options.should_not be_nil
+        it "sets the arguments" do
+          command = Command.new(:arguments => "setup.py develop")
+          command.arguments.should_not be_nil
         end
 
         # Command.with_exec("python setup.py develop).run
-        # Command.with_exec("python").with_option("-r").with_arg("123456").run
-        # Command.with_exec("mi").with_options([]).with_args([]).run
+        # Command.with_exec("python").with_arg("123456").run
+        # Command.with_exec("mi").with_args([]).run
         # Command.with_exec("python") do |input|
         #   input.puts("exit()")
         # end
@@ -34,52 +55,11 @@ module Doughboy
     end
 
     describe ".with_exec" do
-      it "returns a Command" do
-        Command.with_exec("ruby").should be_kind_of(Command)
-      end
-
-      context "with a string of executable and argument" do
-        before(:each) do
-          @command_string = "ps aux"
-        end
-
-        it "assigns the executable" do
-          command = Command.with_exec(@command_string)
-          command.executable.should == `which ps`.strip
-        end
-
-        it "assigns the arguments" do
-          command = Command.with_exec(@command_string)
-          command.arguments.should == "aux"
-        end
-      end
-
-      context "with a string of executable, arguments, and options" do
-        before(:each) do
-          @command_string = "mi -r 212984"
-        end
 
-        it "assigns the executable" do
-          command = Command.with_exec(@command_string)
-          command.executable.should == `which mi`.strip
-        end
-
-        it "assigns the arguments" do
-          command = Command.with_exec(@command_string)
-          command.arguments.should == "212984"
-        end
-
-        it "assigns the options" do
-          command = Command.with_exec(@command_string)
-          command.options.should == ["-r"]
-        end
+      it "returns a Output" do
+        Command.with_exec("ruby").should be_kind_of(Output)
       end
 
-      context "with an executable" do
-        it "assigns the executable" do
-          Command.with_exec("ruby").executable.should include("ruby")
-        end
-      end
     end
 
     describe "#arguments=" do
@@ -92,15 +72,15 @@ module Doughboy
     end
 
     describe "#command" do
-      it "joins the executable, options, and arguments" do
-        full_command = "/bin/ps  aux"
+      it "joins the executable and arguments" do
+        full_command = "/bin/ps aux"
         command = Command.new(:executable => "ps", :options => "", :arguments => "aux")
         command.command.should == full_command
       end
 
       it "returns them in the proper order" do
         python = `which python`.strip
-        command = Command.with_exec("python mbu_information.py -r 218298")
+        command = Command.new("python mbu_information.py -r 218298")
         command.command.should == "#{python} mbu_information.py -r 218298"
       end
     end
@@ -119,19 +99,20 @@ module Doughboy
       end
     end
 
-    describe "#options=" do
-      context "with an array of options" do
-        it "sets the options as an array" do
-          options = ["-r", "-i"]
-          command = Command.new(:options => options)
-          command.options.should == options
-        end
+    describe "#run" do
+      it "runs the command" do
+        full_command = "/bin/ps  aux"
+        command = Command.new()
+        command.stub!(:command).and_return(full_command)
+
+        Open4.should_receive(:popen4).with(full_command).
+          and_return([1234, StringIO.new, StringIO.new, StringIO.new])
+        command.run
       end
 
-      context "with a string of options" do
-        options = "-r -i"
-        command = Command.new(:options => options)
-        command.options.should == ["-r", "-i"]
+      it "returns an output object" do
+        command = Command.new(:executable => "ps", :arguments => "aux")
+        command.run.should be_kind_of(Output)
       end
     end
 
@@ -143,12 +124,12 @@ module Doughboy
 
         Open4.should_receive(:popen4).with(full_command).
           and_return([1234, StringIO.new, StringIO.new, StringIO.new])
-        command.run!
+        command.run
       end
 
       it "returns an output object" do
-        command = Command.new(:executable => "ps", :options => "", :arguments => "aux")
-        command.run!.should be_kind_of(Output)
+        command = Command.new(:executable => "ps", :arguments => "aux")
+        command.run.should be_kind_of(Output)
       end
     end
   end

data/spec/doughboy_spec.rb

@@ -2,9 +2,15 @@ require 'spec_helper'
 
 describe Doughboy do
 
-  describe "with_exec" do
-    it "returns a command" do
-      Doughboy.with_exec("ruby -v").should be_kind_of(Doughboy::Command)
+  describe ".new" do
+    it "returns a Command" do
+      Doughboy.new("ruby -v").should be_kind_of(Doughboy::Command)
+    end
+  end
+
+  describe ".with_exec" do
+    it "returns returns the output from a command" do
+      Doughboy.with_exec("ruby -v").should be_kind_of(Doughboy::Output)
     end
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 4
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors: 
 - Joshua Schairbaum