rube 0.1.1 → 0.1.2

data/Manifest.txt

@@ -6,6 +6,7 @@ Rakefile
 VERSION
 bin/rube
 lib/rube.rb
+lib/rube/cli.rb
 script/console
 script/destroy
 script/generate

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/bin/rube

@@ -1,2 +1,10 @@
-#!/bin/bash
-`dirname $0`/../lib/rube.rb "$@"
+#!/usr/bin/env ruby
+#
+#  Created on 2009-7-20.
+#  Copyright (c) 2009. All rights reserved.
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/rube")
+
+require "rube/cli"
+
+Rube::CLI.execute(STDOUT, ARGV)

data/lib/rube.rb

@@ -30,8 +30,7 @@
 #   The equivalent code for the above, when invoked from within a Ruby script, would be:
 #
 #     require 'rube'
-#     rube = Rube.new
-#     rube.trim_level = 2
+#     rube = Rube.new($stdout, :trim_level=>2)
 #     rube.add_task(:require, 'active_support')
 #     rube.add_task(:require, 'yaml')
 #     rube.add_task(:eval, "document=YAML.load(IO.read('document.yml))" )
@@ -47,16 +46,14 @@
 #     rube --help
 #
 #   at the command line for more information.
-#
-#   For convenience, the Ruby API allows two additional methods which override the default setting for output,
-#   which is to $stdout:
-#     rube.to_string = true     Causes rube.generate to output results to a string
-#     rube.to_file "name"       Causes rube.generate to output results to the named file
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 require 'optparse'
 require 'erb'
 
-class Rube
+module Rube
   VERSION = %x{cat #{File.dirname(__FILE__)+'/../VERSION'}}.chomp
   
   # Class and procedure to provide context for evaluation of tasks: ruby inline code, requires, and erb templates
@@ -67,212 +64,127 @@ class Rube
     end
   end
   
-  class HelpRequested < ArgumentError
-    def self.exit_code
-      1
-    end
+  class RubeError < RuntimeError
   end
   
-  class BadArgumentError < ArgumentError
-    def self.exit_code
-      2
-    end
+  class BadArgumentError < RubeError
   end
   
-  class MissingRequireError < IOError
-    def self.exit_code
-      3
-    end
+  class MissingRequireError < RubeError
   end
   
-  class MissingTemplateError < IOError
-    def self.exit_code
-      4
-    end
+  class MissingTemplateError < RubeError
   end
   
-  class ScriptError < IOError
-    def self.exit_code
-      5
-    end
+  class ScriptError < RubeError
   end
   
-  attr_accessor :tasks, :safety, :from_command_line, :to_string, :to_file
-  attr_reader :trim_level, :trim_mode, :disable_percent
-  
-  def initialize
-    @tasks = []
-    @trim_level = nil
-    self.disable_percent = false
-    self.trim_level = nil
-    @from_command_line = nil
-    @to_string = false
-    @to_file = nil
-    @safety = nil
-    @explicit = false
-  end
+  class Generator
+    attr_accessor :tasks, :safety, :from_command_line
+    attr_reader :trim_level, :trim_mode, :disable_percent
   
-  # Process command line options
-  def process_options(*args)
-    @tasks = []
-    template_count = 0
-    tr_level = nil
-    @op = OptionParser.new
-    @op.banner = "Process erb templates along with other ruby tasks"
-    @op.separator "Usage: #{File.basename($0)} [options] task ..."
-    @op.separator ''
-    @op.separator "Each task may be a template, require or eval (see below). These are processed in the order given,"
-    @op.separator "so results from prior tasks are available to subsequent ones. All variables and constants, including"
-    @op.separator "local variables, are preserved, so their values are available to subsequent tasks."
-    @op.separator ''
-    @op.separator "Tasks:"
-    @op.separator "    path/to/template/file            Process the specified erb template file"
-    @op.on('-i', '--stdin', "Process the template provided in stdin") do |val| 
-      template_count += 1
-      @tasks << [:template, '/dev/stdin']
+    def initialize(stdout=$stdout, options={})
+      @stdout = stdout
+      @tasks = options[:tasks] || []
+      @trim_level = nil
+      self.disable_percent = options[:disable_percent]
+      self.trim_level = options[:trim_level]
+      @from_command_line = options[:from_command_line]
+      @safety = options[:safety]
+      @explicit = options[:explicit]
     end
-    @op.on('-r', '--require path/to/ruby/file', "Load a ruby library or source code file") {|val| @tasks << [:require, val] }
-    @op.on('-e', '--eval "ruby code"', "Evaluate some inline ruby code"){|src| @tasks << [:eval, src] }
-    @op.separator ''
-    @op.separator "Options:"
-    @op.on('-E', '--[no-]explicit', "All templates must be explicitly provided. Default is false -- rube assumes it should read",
-                      "a template from stdin if no templates are specified among the tasks") {|val| @explicit = val }
-    @op.on('-S', '--safe SAFE_LEVEL', Integer, "Set $SAFE (0..4). Default off") do |val|
-      error BadArgumentError, "Invalid --safe level #{val}. Should be 0..4" unless (0..4).include?(val)
-      @safety = val 
-    end
-    @op.on('-T', '--trim TRIM_LEVEL', "Set trim level (0..2, or '-'). Default 0") {|trim| tr_level = trim }
-    @op.on('-P', '--[no-]disable-percent', "Disable '%' prefix for erb code. Default false") {|val| self.disable_percent = val }
-    @op.on_tail('-h', '--help', "Produce this help list") {|val| help }
-    @op.on_tail('-v', '--version', "Show version") {|val| puts VERSION; exit 0 }
-    begin
-      @templates = @op.order!(args) do |template|
-        template_count += 1
-        @tasks << [:template, template]
-      end
-    rescue OptionParser::InvalidOption, OptionParser::InvalidArgument => e
-      $stderr.puts e.to_s
-      help BadArgumentError
+
+    def disable_percent=(disable_percent)
+      @disable_percent = disable_percent
+      @trim_mode = trim_mode_opt(@trim_level)
     end
-    @tasks << [:template, '/dev/stdin'] if !@explicit && template_count == 0
-    self.trim_level = tr_level
-  end
-  
-  def disable_percent=(disable_percent)
-    @disable_percent = disable_percent
-    @trim_mode = trim_mode_opt(@trim_level)
-  end
-  
-  def trim_level=(trim_level)
-    @trim_level = (trim_level || '0').to_s
-    @trim_mode = trim_mode_opt(@trim_level)
-  end
 
-  # Convert command line trim_mode to a form erb will understand
-  def trim_mode_opt(trim_mode)
-    mode = disable_percent ? '' : '%'
-    mode += case trim_mode.to_s
-    when '0','' then  ''
-    when '1'    then  '>'
-    when '2'    then  '<>'
-    when '-'    then  '-'
-    else              error BadArgumentError, "Invalid trim mode #{trim_mode}. Should be 0, 1, 2, or -"
+    def trim_level=(trim_level)
+      @trim_level = (trim_level || '0').to_s
+      @trim_mode = trim_mode_opt(@trim_level)
     end
-  end
 
-  # Display command line help
-  def help(exception=HelpRequested)
-    error exception, @op.to_s
-  end
-  
-  # Add a task
-  def add_task(type, task)
-    case type
-    when :require, :eval, :template then  @tasks << [type, task]
-    else                                  raise "Invalid task type #{type.inspect}"
+    # Convert command line trim_mode to a form erb will understand
+    def trim_mode_opt(trim_mode)
+      mode = disable_percent ? '' : '%'
+      mode += case trim_mode.to_s
+      when '0','' then  ''
+      when '1'    then  '>'
+      when '2'    then  '<>'
+      when '-'    then  '-'
+      else              error BadArgumentError, "Invalid trim mode #{trim_mode}. Should be 0, 1, 2, or -"
+      end
     end
-    self # Allow chaining
-  end
   
-  # Run all the tasks
-  def generate
-    @eval_context = EvalContext.new
-    @binding = @eval_context.sandbox
-    saved_stdout = $stdout
-    if @to_string
-      $stdout = StringIO.new
-    elsif @to_file
-      $stdout = File.new @to_file, 'w'
+    # Add a task
+    def add_task(type, task)
+      case type
+      when :require, :eval, :template then  @tasks << [type, task]
+      else                                  raise "Invalid task type #{type.inspect}"
+      end
+      self # Allow chaining
     end
-    @tasks.each {|p| execute p }
-    res = nil
-    if @to_string
-      res = $stdout.string
-    elsif @to_file
-      $stdout.close
+  
+    # Run all the tasks
+    def generate
+      @eval_context = EvalContext.new
+      @binding = @eval_context.sandbox
+      saved_stdout, $stdout = $stdout, @stdout
+      @tasks.each {|p| execute p }
+      nil
+    ensure
+      $stdout = saved_stdout
     end
-    res
-  ensure
-    $stdout = saved_stdout
-  end
   
-  # Execute a single task
-  def execute(p)
-    case p.first
-    when :require
-      protected_require(p.last)
-    when :eval
-      protected_eval(p.last)
-    when :template
-      protected_erb(p.last)
-    else
-      raise "Unexpected task #{p.inspect}"
+    # Execute a single task
+    def execute(p)
+      case p.first
+      when :require
+        protected_require(p.last)
+      when :eval
+        protected_eval(p.last)
+      when :template
+        protected_erb(p.last)
+      else
+        raise "Unexpected task #{p.inspect}"
+      end
     end
-  end
   
-  # Load a ruby file or library
-  def protected_require(r)
-    @eval_context.instance_eval {require r}
-  rescue LoadError
-    error MissingRequireError, "Can't find require file #{r}"
-  end
+    # Load a ruby file or library
+    def protected_require(r)
+      @eval_context.instance_eval {require r}
+    rescue LoadError
+      error MissingRequireError, "Can't find require file #{r}"
+    end
   
-  # Evaluate inline ruby code
-  def protected_eval(src)
-    bind_at = @binding
-    @eval_context.instance_eval{eval src, bind_at}
-  rescue => e
-    error ScriptError, "Error executing source:\n#{src}\n\n#{e.to_s}"
-  end
+    # Evaluate inline ruby code
+    def protected_eval(src)
+      bind_at = @binding
+      @eval_context.instance_eval{eval src, bind_at}
+    rescue => e
+      error ScriptError, "Error executing source:\n#{src}\n\n#{e.to_s}"
+    end
   
-  # Process an erb template
-  def protected_erb(template)
-    error MissingTemplateError, "Can't find template file #{template}" unless File.exists?(template)
-    source = File.read(template)
-    puts ERB.new(source, @safety, @trim_mode).result(@binding)
-  end
+    # Process an erb template
+    def protected_erb(template)
+      error MissingTemplateError, "Can't find template file #{template}" unless File.exists?(template)
+      source = File.read(template)
+      @stdout.puts ERB.new(source, @safety, @trim_mode).result(@binding)
+    end
 
-  # Issue an error message or exception
-  def error(exception, msg)
-    raise exception, msg unless @from_command_line || exception.nil?
-    $stderr.puts msg
-    exit_code = exception.exit_code rescue 0
-    exit exit_code if @from_command_line
+    # Issue an error message or exception
+    def self.error(exception, msg)
+      raise exception, msg
+    end
+    
+    def error(exception, msg)
+      self.class.error exception, msg
+    end
   end
   
   # Convenience method: create a Rube object and use it to execute command line-style arguments
-  def self.generate(*args)
-    rube = new
-    options = {}
-    if args.last.is_a?(Hash)
-      options = args.pop
-    end
-    rube.from_command_line = options[:from_command_line]
-    rube.process_options(*args)
+  def self.generate(stdout, options)
+    rube = Generator.new(stdout, options)
     rube.generate
   end
 end
-
-if $0 == __FILE__
-  Rube.generate(*(ARGV << {:from_command_line=>true}))
-end

data/lib/rube/cli.rb

@@ -0,0 +1,105 @@
+require 'optparse'
+
+module Rube
+  class ExitStatus
+    HELP_REQUESTED = 1
+    BAD_ARGUMENT = 2
+    MISSING_REQUIRE = 3
+    MISSING_TEMPLATE = 4
+    SCRIPT_ERROR = 5
+  end
+  
+  class CLI
+    def self.execute(stdout, arguments=[])
+
+      # NOTE: the option -p/--path= is given as an example, and should be replaced in your application.
+
+      options = {
+        :tasks              => [],
+        :explicit           => false,
+        :trim_level         => '0',
+        :disable_percent    => false,
+        :safe               => nil,
+        :from_command_line  => true
+      }
+  
+      mandatory_options = %w(  )
+      template_count = 0
+      tr_level = nil
+      parser = OptionParser.new do |opts|
+        opts = OptionParser.new
+
+        opts.banner = <<-BANNER.gsub(/^          /,'')
+          Process erb templates along with other ruby tasks
+
+          Usage: #{File.basename($0)} [options] tasks
+
+          Each task may be a template, require or eval (see below). These are processed in the order given,
+          so results from prior tasks are available to subsequent ones. All variables and constants, including
+          local variables, are preserved, so their values are available to subsequent tasks.
+        BANNER
+
+        opts.separator ''
+        opts.separator "Tasks:"
+        opts.separator "    path/to/template/file            Process the specified erb template file"
+        opts.on('-i', '--stdin', "Process the template provided in stdin") do |val| 
+          template_count += 1
+          options[:tasks] << [:template, '/dev/stdin']
+        end
+        opts.on('-r', '--require path/to/ruby/file', "Load a ruby library or source code file") {|val| options[:tasks] << [:require, val] }
+        opts.on('-e', '--eval "ruby code"', "Evaluate some inline ruby code"){|src| options[:tasks] << [:eval, src] }
+        opts.separator ''
+        opts.separator "Options:"
+        opts.on('-E', '--[no-]explicit', "All templates must be explicitly provided. Default is false -- rube assumes it should read",
+                          "a template from stdin if no templates are specified among the tasks") {|val| options[:explicit] = val }
+        opts.on('-S', '--safe SAFE_LEVEL', Integer, "Set $SAFE (0..4). Default off") do |val|
+          help stdout, opts, "Invalid --safe level #{val}. Should be 0..4", ExitStatus::BAD_ARGUMENT unless (0..4).include?(val)
+          options[:safety] = val 
+        end
+        opts.on('-T', '--trim TRIM_LEVEL', "Set trim level (0..2, or '-'). Default 0") {|trim| tr_level = trim }
+        opts.on('-P', '--[no-]disable-percent', "Disable '%' prefix for erb code. Default false") {|val| options[:disable_percent] = val }
+        opts.on_tail('-h', '--help', "Produce this help list") {|val| help stdout, opts }
+        opts.on_tail('-v', '--version', "Show version") {|val| puts VERSION; exit 0 }
+        begin
+          @templates = opts.order!(arguments) do |template|
+            template_count += 1
+            options[:tasks] << [:template, template]
+          end
+        rescue OptionParser::InvalidOption, OptionParser::InvalidArgument => e
+          help stdout, opts, e.to_s, ExitStatus::BAD_ARGUMENT 
+        end
+        options[:tasks] << [:template, '/dev/stdin'] if !options[:explicit] && template_count == 0
+        options[:trim_level] = tr_level
+
+        if mandatory_options && mandatory_options.find { |option| options[option.to_sym].nil? }
+          help stdout, opts
+        end
+      end
+
+      begin
+        Rube.generate(stdout, options)
+      rescue BadArgumentError => e
+        quit stdout, e.to_s, ExitStatus::BAD_ARGUMENT
+      rescue MissingRequireError => e
+        quit stdout, e.to_s, ExitStatus::MISSING_REQUIRE
+      rescue MissingTemplateError => e
+        quit stdout, e.to_s, ExitStatus::MISSING_TEMPLATE
+      rescue ScriptError => e
+        quit stdout, e.to_s, ExitStatus::SCRIPT_ERROR
+      end
+    end
+    
+    def self.help(stdout, opt_parser, msg = nil, exit_code = ExitStatus::HELP_REQUESTED)
+      m = msg.to_s
+      m += "\n" unless m == ''
+      m += opt_parser.to_s
+      quit stdout, m, exit_code
+    end
+    
+    def self.quit(stdout, msg=nil,exit_code = 0)
+      stdout.puts msg
+      exit exit_code
+    end
+      
+  end
+end

data/test/test_helper.rb

@@ -2,3 +2,4 @@ require 'stringio'
 require 'tempfile'
 require 'test/unit'
 require File.dirname(__FILE__) + '/../lib/rube'
+require 'rube/cli'

data/test/test_rube.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/test_helper.rb'
 class TestRubeBasic < Test::Unit::TestCase
 
   def setup
-    @new_rube = Rube.new
+    @new_rube = Rube::Generator.new
   end
   
   def test_truth
@@ -11,7 +11,7 @@ class TestRubeBasic < Test::Unit::TestCase
   end
   
   def test_creates_rube_object
-    assert_instance_of Rube, @new_rube, "Rube.new does not create Rube object"
+    assert_instance_of Rube::Generator, @new_rube, "Rube:Generator.new does not create Rube::Generator object"
   end
   
   def test_rube_object_has_tasks
@@ -65,14 +65,6 @@ class TestRubeBasic < Test::Unit::TestCase
   def test_rube_object_trim_mode
     assert_respond_to @new_rube, :trim_mode
   end
-  
-  def test_rube_object_to_string
-    assert_respond_to @new_rube, :to_string
-  end
-  
-  def test_rube_object_to_file
-    assert_respond_to @new_rube, :to_file
-  end
 
   def test_rube_object_go
     assert_respond_to @new_rube, :generate
@@ -86,7 +78,7 @@ end
 class TestRubeTaskManipulation < Test::Unit::TestCase
 
   def setup
-    @empty_rube = Rube.new
+    @empty_rube = Rube::Generator.new
   end
 
   def test_empty_rube_object_has_no_tasks
@@ -143,7 +135,7 @@ end
 class TestRubeSettings < Test::Unit::TestCase
 
   def setup
-    @empty_rube = Rube.new
+    @empty_rube = Rube::Generator.new
   end
 
   def test_rube_default_disable_percent
@@ -172,31 +164,13 @@ class TestRubeSettings < Test::Unit::TestCase
     @empty_rube.from_command_line = 'foo'
     assert_equal 'foo', @empty_rube.from_command_line
   end
-
-  def test_rube_default_to_string
-    assert_equal false, !!@empty_rube.to_string
-  end
-
-  def test_rube_object_preserves_to_string
-    @empty_rube.to_string = 'foo'
-    assert_equal 'foo', @empty_rube.to_string
-  end
-
-  def test_rube_default_to_file
-    assert_equal nil, @empty_rube.to_file
-  end
-
-  def test_rube_object_preserves_to_file
-    @empty_rube.to_file = 'foo'
-    assert_equal 'foo', @empty_rube.to_file
-  end
 end
 
 class TestRubeTrimLevel < Test::Unit::TestCase
 
   def setup
-    @empty_rube = Rube.new
-    @disabled_rube = Rube.new
+    @empty_rube = Rube::Generator.new
+    @disabled_rube = Rube::Generator.new
     @disabled_rube.disable_percent = true
   end
 
@@ -274,113 +248,78 @@ end
 class TestRubeProcessing < Test::Unit::TestCase
 
   def setup
-    @rube = Rube.new
-    @save_stdout = $stdout
-  end
-  
-  def teardown
-    $stdout = @save_stdout
-  end
-  
-  def test_simple_eval_to_stdout
-    StringIO.open do |out|
-      $stdout = out
-      @rube.add_task :eval, 'puts "foo"'
-      res = @rube.generate
-      assert_equal "foo\n", out.string, "Failed to produce expected output on $stdout"
-      assert_equal nil, res, "Without redirection, rube.generate should return nil"
-    end
+    @out = StringIO.new
+    @rube = Rube::Generator.new(@out)
   end
   
-  def test_simple_eval_to_string
-    @rube.to_string = true
-    @rube.add_task :eval, 'puts "foo"'
-    out = @rube.generate
-    assert_equal "foo\n", out, "Failed to output to string"
-  end
-  
-  def test_simple_eval_to_file
-    out = Tempfile.new('testout')
-    @rube.to_file = out.path
+  def test_simple_eval
     @rube.add_task :eval, 'puts "foo"'
     res = @rube.generate
-    out.close
-    output = File.read(out.path)
-    assert_equal "foo\n", output, "Failed to produce expected output on file #{out.path}"
+    assert_equal "foo\n", @out.string, "Failed to produce expected output on $stdout"
     assert_equal nil, res, "Without redirection, rube.generate should return nil"
   end
   
   def test_process_require_task
-    StringIO.open do |out|
-      $stdout = out
-      @rube.add_task :require, 'English'
-      @rube.add_task :eval, 'puts $PID'
-      @rube.generate
-      # If English doesn't load properly, then $PID is nil; if it does, then it's a numeric process id
-      assert_match(/^\d+$/, out.string.chomp, "Failed to load require file")
-    end
+    @rube.add_task :require, 'English'
+    @rube.add_task :eval, 'puts $PID'
+    @rube.generate
+    # If English doesn't load properly, then $PID is nil; if it does, then it's a numeric process id
+    assert_match(/^\d+$/, @out.string.chomp, "Failed to load require file")
   end
   
   def test_process_template_task
-    @rube.to_string = true
     @rube.add_task :template, 'templates/test1'
-    out = @rube.generate
-    assert_equal "foo\nblurg\nblurble\n\nfarb\n\n", out, "Failed to produce expected result from test1 template"
+    @rube.generate
+    assert_equal "foo\nblurg\nblurble\n\nfarb\n\n", @out.string, "Failed to produce expected result from test1 template"
   end
   
   def test_process_template_task_with_disabled_percent
-    @rube.to_string = true
     @rube.disable_percent = true
     @rube.add_task :template, 'templates/test1'
-    out = @rube.generate
+    @rube.generate
     # Note: test1 template produces different results with % lines disabled
-    assert_equal "foo\nblurg\nblurble\n\n% z = 'farb'\nbarf\n\n", out, "Failed to produce expected result from test1 template with percentage lines disabled"
+    assert_equal "foo\nblurg\nblurble\n\n% z = 'farb'\nbarf\n\n", @out.string, "Failed to produce expected result from test1 template with percentage lines disabled"
   end
   
   def test_process_template_task_with_trim_level_1
-    @rube.to_string = true
     @rube.trim_level = 1
     @rube.add_task :template, 'templates/test1'
-    out = @rube.generate
-    assert_equal "foo\nblurgblurblefarb\n", out, "Failed to produce expected result from test1 template"
+    @rube.generate
+    assert_equal "foo\nblurgblurblefarb\n", @out.string, "Failed to produce expected result from test1 template"
   end
   
   def test_process_template_task_with_trim_level_2
-    @rube.to_string = true
     @rube.trim_level = 2
     @rube.add_task :template, 'templates/test1'
     out = @rube.generate
-    assert_equal "foo\nblurgblurble\nfarb\n", out, "Failed to produce expected result from test1 template"
+    assert_equal "foo\nblurgblurble\nfarb\n", @out.string, "Failed to produce expected result from test1 template"
   end
   
   def test_process_template_with_persistent_variable
-    @rube.to_string = true
     @rube.add_task :eval, 'b="foo"'
     @rube.add_task :template, 'templates/test2'
-    out = @rube.generate
-    assert_equal "bar\nfoo*2\n", out, "Failed to produce expected result from test2 template with passed variable value"
+    @rube.generate
+    assert_equal "bar\nfoo*2\n", @out.string, "Failed to produce expected result from test2 template with passed variable value"
   end
 end
 
 class TestRubeErrors < Test::Unit::TestCase
   def setup
-    @rube = Rube.new
+    @out = StringIO.new
+    @rube = Rube::Generator.new(@out)
   end
 
   def test_bad_eval
-    @rube.to_string = true
     @rube.add_task :eval, 'foo'
     assert_raises(Rube::ScriptError) { @rube.generate }
   end
 
   def test_bad_require
-    @rube.to_string = true
     @rube.add_task :require, 'foo'
     assert_raises(Rube::MissingRequireError) { @rube.generate }
   end
 
   def test_bad_template
-    @rube.to_string = true
     @rube.add_task :template, 'foo'
     assert_raises(Rube::MissingTemplateError) { @rube.generate }
   end
@@ -427,30 +366,17 @@ class TestRubeCommandLineIndirectly < Test::Unit::TestCase
 #
 #   Not really an exhaustive test, but if this works, things should be okay
 #
-
-  def setup
-    @rube = Rube.new
-    @save_stdout = $stdout
-  end
-
-  def teardown
-    $stdout = @save_stdout
-  end
   
   def test_eval
     StringIO.open do |out|
-      $stdout = out
-      @rube.process_options('-E', '-e', 'puts "foo"')
-      res = @rube.generate
+      res = Rube::CLI.execute(out, ['-E', '-e', 'puts "foo"'])
       assert_equal "foo\n", out.string, "Failed to produce expected output on $stdout"
     end
   end
 
   def test_process_require_task
     StringIO.open do |out|
-      $stdout = out
-      @rube.process_options('-E', '-r', 'English', '-e', 'puts $PID')
-      @rube.generate
+      res = Rube::CLI.execute(out, ['-E', '-r', 'English', '-e', 'puts $PID'])
       # If English doesn't load properly, then $PID is nil; if it does, then it's a numeric process id
       assert_match(/^\d+$/, out.string.chomp, "Failed to load require file")
     end
@@ -458,9 +384,7 @@ class TestRubeCommandLineIndirectly < Test::Unit::TestCase
 
   def test_process_require_task_long_form
     StringIO.open do |out|
-      $stdout = out
-      @rube.process_options('--explicit', '--require', 'English', '--eval', 'puts $PID')
-      @rube.generate
+      res = Rube::CLI.execute(out, ['--explicit', '--require', 'English', '--eval', 'puts $PID'])
       # If English doesn't load properly, then $PID is nil; if it does, then it's a numeric process id
       assert_match(/^\d+$/, out.string.chomp, "Failed to load require file")
     end
@@ -468,18 +392,14 @@ class TestRubeCommandLineIndirectly < Test::Unit::TestCase
   
   def test_process_template_task
     StringIO.open do |out|
-      $stdout = out
-      @rube.process_options('templates/test1')
-      @rube.generate
+      res = Rube::CLI.execute(out, ['templates/test1'])
       assert_equal "foo\nblurg\nblurble\n\nfarb\n\n", out.string, "Failed to produce expected result from test1 template"
     end
   end
   
   def test_process_template_task_with_disabled_percent
     StringIO.open do |out|
-      $stdout = out
-      @rube.process_options('-P', 'templates/test1')
-      @rube.generate
+      res = Rube::CLI.execute(out, ['-P', 'templates/test1'])
       # Note: test1 template produces different results with % lines disabled
       assert_equal "foo\nblurg\nblurble\n\n% z = 'farb'\nbarf\n\n", out.string, "Failed to produce expected result from test1 template with percentage lines disabled"
     end
@@ -487,27 +407,21 @@ class TestRubeCommandLineIndirectly < Test::Unit::TestCase
   
   def test_process_template_task_with_trim_level_1
     StringIO.open do |out|
-      $stdout = out
-      @rube.process_options('--trim', '1', 'templates/test1')
-      @rube.generate
+      res = Rube::CLI.execute(out, ['--trim', '1', 'templates/test1'])
       assert_equal "foo\nblurgblurblefarb\n", out.string, "Failed to produce expected result from test1 template"
     end
   end
   
   def test_process_template_task_with_trim_level_2
     StringIO.open do |out|
-      $stdout = out
-      @rube.process_options('--trim', '2', 'templates/test1')
-      @rube.generate
+      res = Rube::CLI.execute(out, ['--trim', '2', 'templates/test1'])
       assert_equal "foo\nblurgblurble\nfarb\n", out.string, "Failed to produce expected result from test1 template"
     end
   end
   
   def test_process_template_with_persistent_variable
     StringIO.open do |out|
-      $stdout = out
-      @rube.process_options('--eval', 'b="foo"', 'templates/test2')
-      @rube.generate
+      res = Rube::CLI.execute(out, ['--eval', 'b="foo"', 'templates/test2'])
       assert_equal "bar\nfoo*2\n", out.string, "Failed to produce expected result from test2 template with passed variable value"
     end
   end
@@ -529,7 +443,7 @@ class TestRubeCommandLineDirectly < Test::Unit::TestCase
   end
   
   def test_process_template_task
-    res = `rube.rb templates/test1` # Not sure why it insists on the '.rb' here, but it does...
+    res = `rube templates/test1` # Not sure why it insists on the '.rb' here, but it does...
     assert_equal "foo\nblurg\nblurble\n\nfarb\n\n", res, "Failed to produce expected result from test1 template"
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rube
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Richard LeBer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-20 00:00:00 -04:00
+date: 2009-07-23 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,6 +59,7 @@ files:
 - VERSION
 - bin/rube
 - lib/rube.rb
+- lib/rube/cli.rb
 - script/console
 - script/destroy
 - script/generate