robot-vim 0.9.0 → 0.10.0

data/README.md

@@ -26,23 +26,33 @@ Or create an instance with a specific Vim
 ### Running commands
 Commands are passed in as a string with one command per line.
 
+The input file can be specified as a path to an existing input file, or as a string which RobotVim will turn into an short lived file backed buffer.
+
     commands = <<-COMMANDS
       RunSomeCoolCommand
       SomeOtherCoolCommand
     COMMANDS
 
+
     buffer_text = robot.run(:input_file => "some/file.txt", :commands => commands)
 
+    input = <<-CONTENT
+      This text will be used
+      as the contents of my input file
+    CONTENT
+
+    buffer_text = robot.run(:input_file => input, :commands => commands)
+
 
 ### Making Assertions
 Use your preferred Ruby testing library to make assertions about the buffer text string returned by RobotVim::Runner#run
 
-See spec/integration\_spec.rb for an example of sorting a file and making an assertion.
+spec/integration\_spec.rb contains examples of asserting with Rspec
 
 ## TODO
 - automatically save buffer to an output file after running the last command(done)
 - automatically close Vim after running the last command(done)
-- take a string for input and write out a temporary file that Vim will run against
+- take a string for input and write out a temporary file that Vim will run against(done)
 - figure out if there is a way to specify a .vimrc file without disabling the normal Vim initialization process
 
 ## Author

data/lib/robot-vim.rb

@@ -1,3 +1,5 @@
 require 'uuid'
 require "robot-vim/runner"
 require "robot-vim/script_file"
+require "robot-vim/input_file"
+require "robot-vim/file_name_generator"

data/lib/robot-vim/file_name_generator.rb

@@ -0,0 +1,7 @@
+module RobotVim
+  class FileNameGenerator
+    def self.generate
+      UUID.new.generate(:compact)
+    end
+  end
+end

data/lib/robot-vim/input_file.rb

@@ -0,0 +1,26 @@
+module RobotVim
+  class InputFile
+    def self.path_for(input, &block)
+      if File.exists?(input)
+        yield_existing_file_path(input, block)
+      else
+        yield_on_demand_file_path(input, block)
+      end
+    end
+
+
+    def self.yield_existing_file_path(input, block)
+      block.call(input)
+    end
+
+    def self.yield_on_demand_file_path(input, block)
+      file_name = FileNameGenerator.generate
+      File.open(file_name, "w+") do |file|
+        file << input
+      end
+      block.call(file_name)
+    ensure
+      File.delete(file_name)
+    end
+  end
+end

data/lib/robot-vim/runner.rb

@@ -11,21 +11,36 @@ module RobotVim
     end
 
     def run(args={})
-      output_file_name = UUID.new.generate(:compact)
-      commands = args[:commands] + ":w #{output_file_name}"
-      commands = commands + "\n:%bd!\n:q!\n"
-      invoke_vim(commands, args[:input_file])
-      return File.read(output_file_name)
+      output_file_name = RobotVim::FileNameGenerator.generate
+      commands = args[:commands] + output_write_command(output_file_name) + vim_close_commands
+
+      InputFile.path_for(args[:input_file]) do |input_file_path|
+        ScriptFile.open(commands) do |script_file_path|
+          invoke_vim(script_file_path, input_file_path)
+        end
+      end
+
+      return read_output_file_contents(output_file_name)
     ensure
       File.delete(output_file_name) if File.exists?(output_file_name)
     end
 
     private
-    
-    def invoke_vim(commands, input_file)
-      ScriptFile.open(commands) do |script_file_path|
-        Kernel.send(:`, "#{self.vim_binary} -n -s #{script_file_path} #{input_file}")
-      end
+
+    def invoke_vim(script_file_path, input_file)
+      Kernel.send(:`, "#{self.vim_binary} -n -s #{script_file_path} #{input_file}")
+    end
+
+    def output_write_command(output_file_name)
+      ":w #{output_file_name}"
+    end
+
+    def vim_close_commands
+      "\n:%bd!\n:q!\n"
+    end
+
+    def read_output_file_contents(output_file_name)
+      File.read(output_file_name)
     end
   end
 end

data/lib/robot-vim/script_file.rb

@@ -2,7 +2,7 @@ module RobotVim
   class ScriptFile
 
     def self.open(commands)
-      file_name = UUID.new.generate(:compact)
+      file_name = FileNameGenerator.generate
       script_file = File.new(file_name, "w")
       script_file << commands
       script_file.flush

data/lib/robot-vim/version.rb

@@ -1,5 +1,5 @@
 module Robot
   module Vim
-    VERSION = "0.9.0"
+    VERSION = "0.10.0"
   end
 end

data/spec/integration_spec.rb

@@ -1,16 +1,33 @@
 require 'spec_helper'
 
 describe "Automating Vim with RobotVim" do
-  it "can sort a file using vim" do
-    input_path = File.join(File.dirname(__FILE__), "fixtures", "unsorted_file.txt")
-    unsorted_text = File.read(input_path)
+  let(:runner){RobotVim::Runner.new}
 
-    commands = <<-COMMANDS
+  context "When using an existing input file" do
+    it "can sort a file using vim" do
+      input_path = File.join(File.dirname(__FILE__), "fixtures", "unsorted_file.txt")
+      unsorted_text = File.read(input_path)
+
+      commands = <<-COMMANDS
       :%!sort
-    COMMANDS
+      COMMANDS
+
+      result = runner.run(:commands => commands, :input_file => input_path)
+      result.should == unsorted_text.split("\n").sort.join("\n") + "\n"
+    end
+  end
 
-    runner = RobotVim::Runner.new
-    result = runner.run(:commands => commands, :input_file => input_path)
-    result.should eql(unsorted_text.split("\n").sort.join("\n") + "\n")
+  context "When using a string for input" do
+    it "can uppercase the first line" do
+      text_to_uppercase = "this line should be uppercased"
+
+      commands = <<-COMMANDS
+        :normal 0|gU$
+      COMMANDS
+
+      result = runner.run(:commands => commands, :input_file => text_to_uppercase)
+      result.should == text_to_uppercase.upcase + "\n"
+    end
   end
+
 end

data/spec/robot-vim/file_name_generator_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe RobotVim::FileNameGenerator do
+  describe "generating a file name" do
+    it "returns a unique name each time" do
+      names = (1..5).map{|x| RobotVim::FileNameGenerator.generate}
+      names.uniq.size.should eql(names.size)
+    end
+  end
+end

data/spec/robot-vim/input_file_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe RobotVim::InputFile do
+  describe "path_for" do
+    context "given a file path that exists" do
+      it "yields the file path" do
+        File.stub(:exists?).and_return(true)
+        expected_path = "/some/path/file.txt"
+        RobotVim::InputFile.path_for(expected_path) do |path|
+          path.should == expected_path
+        end
+      end
+    end
+
+    context "given contents for a file" do
+      let(:file_contents) do
+        <<-CONTENTS
+          Hi there.
+          This will serve as our input file.
+        CONTENTS
+      end 
+
+      it "creates a new file with those contents" do
+        RobotVim::InputFile.path_for(file_contents) do |path|
+          File.read(path).should == file_contents
+        end
+      end
+
+      it "cleans up the file when we are done with it" do
+        file_name = "some_file_name"
+        RobotVim::FileNameGenerator.stub(:generate).and_return(file_name)
+        RobotVim::InputFile.path_for(file_contents) do |path|
+          File.exists?(file_name).should be_true
+        end
+        File.exists?(file_name).should be_false
+      end
+    end
+  end
+end

data/spec/robot-vim/runner_spec.rb

@@ -21,11 +21,11 @@ describe RobotVim::Runner do
     let(:runner){RobotVim::Runner.new(:vim => vim_path)}
     let(:commands){"some vim commands\n"}
     let(:input_file){"some/path/to/a/file"}
-    let(:output_file_name){"output_file_name"}
 
     before do
       Kernel.stub(:`)
-      File.stub(:read)
+      runner.stub(:read_output_file_contents)
+      RobotVim::InputFile.stub(:path_for).and_yield(input_file)
     end
 
     def run_robot
@@ -73,20 +73,25 @@ describe RobotVim::Runner do
       RobotVim::ScriptFile.should_receive(:open).with(/:%bd!\n:q!/)
       run_robot
     end
-    
-    it "returns the contents of the output file" do
-      UUID.stub_chain(:new, :generate => output_file_name)
-      expected_result = "awesome buffer"
-      File.stub(:read).with(output_file_name).and_return(expected_result)
-      result = run_robot
-      result.should == expected_result
-    end
 
-    it "deletes the output file" do
-      output_file_name = "somefile" 
-      UUID.stub_chain(:new, :generate => output_file_name)
-      run_robot
-      File.exists?(output_file_name).should be_false
+    describe "output file management" do
+      let(:output_file_name){"output_file_name"}
+
+      before do
+        RobotVim::FileNameGenerator.stub(:generate).and_return(output_file_name)
+      end
+
+      it "returns the contents of the output file" do
+        expected_result = "awesome buffer"
+        runner.stub(:read_output_file_contents).with(output_file_name).and_return(expected_result)
+        result = run_robot
+        result.should == expected_result
+      end
+
+      it "deletes the output file" do
+        run_robot
+        File.exists?(output_file_name).should be_false
+      end
     end
   end
 

data/spec/robot-vim/script_file_spec.rb

@@ -3,15 +3,18 @@ require 'spec_helper'
 describe RobotVim::ScriptFile do
   describe "when creating a script file from a string" do
     let(:commands_string){"some string of vim commands"}
+    let(:expected_file_name){"some_file_name"}
+
+    before do
+      RobotVim::FileNameGenerator.stub(:generate).and_return(expected_file_name)
+    end
 
     it "yields the path of the script file" do
-      expected_path = "/some/path/somewhere"
-      UUID.stub_chain(:new, :generate => expected_path)
       file = stub("file").as_null_object
       File.stub(:new).and_return(file)
 
       RobotVim::ScriptFile.open(commands_string) do |file_path|
-        file_path.should == expected_path
+        file_path.should == expected_file_name
       end
     end
 
@@ -22,11 +25,9 @@ describe RobotVim::ScriptFile do
     end
 
     it "deletes the file after we are done using it" do
-      file_name = "somefile" 
-      UUID.stub_chain(:new, :generate => file_name)
       RobotVim::ScriptFile.open(commands_string) do |file_path|
       end
-      File.exists?(file_name).should be_false
+      File.exists?(expected_file_name).should be_false
     end
 
   end

metadata

@@ -2,7 +2,7 @@
 name: robot-vim
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors: 
 - Matt Margolis
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-26 00:00:00 -05:00
+date: 2011-03-27 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -75,12 +75,16 @@ files:
 - README.md
 - Rakefile
 - lib/robot-vim.rb
+- lib/robot-vim/file_name_generator.rb
+- lib/robot-vim/input_file.rb
 - lib/robot-vim/runner.rb
 - lib/robot-vim/script_file.rb
 - lib/robot-vim/version.rb
 - robot-vim.gemspec
 - spec/fixtures/unsorted_file.txt
 - spec/integration_spec.rb
+- spec/robot-vim/file_name_generator_spec.rb
+- spec/robot-vim/input_file_spec.rb
 - spec/robot-vim/runner_spec.rb
 - spec/robot-vim/script_file_spec.rb
 - spec/spec_helper.rb