rube 0.1.0

data/History.txt

@@ -0,0 +1,9 @@
+== 0.1.0 2009-07-18
+
+* First public release
+* Testing, extensions
+
+== 0.0.1 2009-07-09
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,15 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+VERSION
+lib/rube
+lib/rube.rb
+script/console
+script/destroy
+script/generate
+templates/test1
+templates/test2
+test/test_helper.rb
+test/test_rube.rb

data/PostInstall.txt

@@ -0,0 +1,2 @@
+
+For more information on rube, see http://rube.rubyforge.org

data/README.rdoc

@@ -0,0 +1,81 @@
+= rube
+
+* http://github.com/rleber/rube
+
+== DESCRIPTION:
+
+  Rube -- Slightly smarter erb front-end
+
+  Rube allows you to apply erb to templates, interspersed with other ruby code, either as inline source or 	
+  as ruby files (e.g. requires). Rube can be invoked from the command line as a command in the form:
+
+    rube [options] task ...
+
+== FEATURES/PROBLEMS:
+
+* Can be invoked from command line or via the Ruby API from within a Ruby script
+* Can process inline ruby code, ruby libraries, and erb templates
+* Information is persistent across tasks: e.g. subsequent templates can refer to results of previous tasks
+
+== SYNOPSIS:
+
+  Rube can be invoked from the command line as a command in the form:
+
+    rube [options] task ...
+
+  or as part of a ruby script, as in:
+
+    require 'rube'
+    rube = Rube.new
+    rube.add_task(:require, 'active_record')
+    rube.add_task(:template, 'foo')
+    rube.generate
+
+  In either case, tasks may be erb templates, ruby files, or inline ruby code. Each of the tasks is 
+  performed in the order specified and variables, constants etc. are preserved across tasks (including 
+  local variables) so that subsequent tasks can refer to the the results of earlier tasks. This makes it 
+  simpler to use erb templates against arbitrary data. For instance:
+
+    rube -r active_support -r yaml -e "document=YAML.load(IO.read('document.yml))" --trim 2 --stdin convert_to_textile.erb
+
+  would process the template on stdin followed by the template in convert_to_textile.erb, having already 
+  loaded the active_support and yaml libraries, and having loaded the YAML file document.yml and parsed it 
+  into a Ruby variable named document, where the information could easily be referred to in the template. 
+  This all would be done at erb trim level 2.
+
+  See rdoc or source for more information, or type the command:
+
+    rube --help
+
+== REQUIREMENTS:
+
+* None
+
+== INSTALL:
+
+* sudo gem install rube
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Richard LeBer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+%w[rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/rube'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('rube', Rube::VERSION) do |p|
+  p.developer('Richard LeBer', 'rleber@mindspring.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  p.rubyforge_name       = p.name # TODO this is default value
+  # p.extra_deps         = [
+  #   ['activesupport','>= 2.0.2'],
+  # ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/rube.rb

@@ -0,0 +1,278 @@
+#!/usr/bin/ruby
+#
+# Rube --
+#   Slightly smarter erb front-end
+#   
+#   Rube allows you to apply erb to templates, interspersed with other ruby code, either as inline source or as 
+#   ruby files (e.g. requires). Rube can be invoked from the command line as a command in the form:
+#
+#     rube [options] task ...
+
+#   or as part of a ruby script, as in:
+#
+#     require 'rube'
+#     rube = Rube.new
+#     rube.add_task(:require, 'active_record')
+#     rube.add_task(:template, 'foo')
+#     rube.generate
+#
+#   In either case, tasks may be erb templates, ruby files, or inline ruby code. Each of the tasks is performed in
+#   the order specified and variables, constants etc. are preserved across tasks (including local variables) so that
+#   subsequent tasks can refer to the the results of earlier tasks. This makes it simpler to use erb templates against 
+#   arbitrary data. For instance:
+#
+#     rube -r active_support -r yaml -e "document=YAML.load(IO.read('document.yml))" --trim 2 --stdin convert_to_textile.erb
+#
+#   would process the template on stdin followed by the template in convert_to_textile.erb, having already loaded the 
+#   active_support and yaml libraries, and having loaded the YAML file document.yml and parsed it into a Ruby variable named 
+#   document, where the information could easily be referred to in the template. This all would be done at erb trim level 2.
+#
+#   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.add_task(:require, 'active_support')
+#     rube.add_task(:require, 'yaml')
+#     rube.add_task(:eval, "document=YAML.load(IO.read('document.yml))" )
+#     rube.add_task(:template, 'dev/stdin') # Note, there is no direct equivalent to the --stdin parameter
+#     rube.add_task(:template, 'convert_to_textile.erb')
+#     rube.generate
+#
+#   If invoked from the command line AND if no template file is specified among the tasks, rube assumes it should read a 
+#   template from stdin, after processing all other tasks. This behavior can be turned off using the --explicit option.
+#
+#   In addition to the above, rube allows similar parameters to erb for setting $SAFE, $DEBUG and trim levels. Type
+#
+#     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
+
+require 'optparse'
+require 'erb'
+
+class 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
+  class EvalContext
+    # All tasks are executed in the sandbox
+    def sandbox
+      return binding
+    end
+  end
+  
+  class HelpRequested < ArgumentError
+    def self.exit_code
+      1
+    end
+  end
+  
+  class BadArgumentError < ArgumentError
+    def self.exit_code
+      2
+    end
+  end
+  
+  class MissingRequireError < IOError
+    def self.exit_code
+      3
+    end
+  end
+  
+  class MissingTemplateError < IOError
+    def self.exit_code
+      4
+    end
+  end
+  
+  class ScriptError < IOError
+    def self.exit_code
+      5
+    end
+  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
+  
+  # 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']
+    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
+    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 -"
+    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}"
+    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'
+    end
+    @tasks.each {|p| execute p }
+    res = nil
+    if @to_string
+      res = $stdout.string
+    elsif @to_file
+      $stdout.close
+    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}"
+    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
+  
+  # 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
+
+  # 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
+  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)
+    rube.generate
+  end
+end
+
+if $0 == __FILE__
+  Rube.generate(*(ARGV << {:from_command_line=>true}))
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/rube.rb'}"
+puts "Loading rube gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/templates/test1

@@ -0,0 +1,8 @@
+foo
+<%= 'blurg' %>
+<%= 'blurble'
+%>
+<% z = 'barf' %>
+% z = 'farb'
+<%= z %>
+

data/templates/test2

@@ -0,0 +1,2 @@
+bar
+<%= b %>*2

data/test/test_helper.rb

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

data/test/test_rube.rb

@@ -0,0 +1,545 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestRubeBasic < Test::Unit::TestCase
+
+  def setup
+    @new_rube = Rube.new
+  end
+  
+  def test_truth
+    assert true
+  end
+  
+  def test_creates_rube_object
+    assert_instance_of Rube, @new_rube, "Rube.new does not create Rube object"
+  end
+  
+  def test_rube_object_has_tasks
+    assert_respond_to @new_rube, :tasks
+  end
+  
+  def test_rube_object_has_tasks=
+    assert_respond_to @new_rube, :tasks=
+  end
+  
+  def test_rube_object_tasks_is_an_array
+    assert_kind_of Array, @new_rube.tasks
+  end
+  
+  def test_rube_object_has_add_task
+    assert_respond_to @new_rube, :add_task
+  end
+  
+  def test_rube_object_disable_percent
+    assert_respond_to @new_rube, :disable_percent
+  end
+  
+  def test_rube_object_disable_percent=
+    assert_respond_to @new_rube, :disable_percent=
+  end
+  
+  def test_rube_object_safety
+    assert_respond_to @new_rube, :safety
+  end
+  
+  def test_rube_object_safety=
+    assert_respond_to @new_rube, :safety=
+  end
+  
+  def test_rube_object_from_command_line
+    assert_respond_to @new_rube, :from_command_line
+  end
+  
+  def test_rube_object_from_command_line=
+    assert_respond_to @new_rube, :from_command_line=
+  end
+  
+  def test_rube_object_trim_level
+    assert_respond_to @new_rube, :trim_level
+  end
+  
+  def test_rube_object_trim_level=
+    assert_respond_to @new_rube, :trim_level=
+  end
+  
+  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
+  end
+  
+  def test_rube_class_go
+    assert_respond_to Rube, :generate
+  end
+end
+  
+class TestRubeTaskManipulation < Test::Unit::TestCase
+
+  def setup
+    @empty_rube = Rube.new
+  end
+
+  def test_empty_rube_object_has_no_tasks
+    assert_equal @empty_rube.tasks.size, 0
+  end
+  
+  def test_rube_object_adds_eval_task
+    @empty_rube.add_task :eval, 'bar'
+    assert_equal @empty_rube.tasks.size, 1, "Rube add_task did not add eval task"
+  end
+  
+  def test_rube_object_adds_require_task
+    @empty_rube.add_task :require, 'bar'
+    assert_equal @empty_rube.tasks.size, 1, "Rube add_task did not add require task"
+  end
+  
+  def test_rube_object_adds_template_task
+    @empty_rube.add_task :template, 'bar'
+    assert_equal @empty_rube.tasks.size, 1, "Rube add_task did not add template task"
+  end
+  
+  def test_rube_object_checks_task_type
+    assert_raises(RuntimeError) { @empty_rube.add_task :foo, 'bar' }
+  end
+  
+  def test_rube_object_adds_eval_task_correctly
+    @empty_rube.add_task :eval, 'bar'
+    assert_equal @empty_rube.tasks.last, [:eval, 'bar']
+  end
+  
+  def test_rube_object_adds_multiple_tasks
+    @empty_rube.add_task :require, 'foo'
+    @empty_rube.add_task :eval, 'bar'
+    assert_equal @empty_rube.tasks.size, 2
+    assert_kind_of Array, @empty_rube.tasks.first
+    assert_equal @empty_rube.tasks.first.size, 2
+    assert_equal @empty_rube.tasks.first.first, :require
+    assert_equal @empty_rube.tasks.first.last, 'foo'
+    assert_kind_of Array, @empty_rube.tasks.last
+    assert_equal @empty_rube.tasks.first.size, 2
+    assert_equal @empty_rube.tasks.last.first, :eval
+    assert_equal @empty_rube.tasks.last.last, 'bar'
+  end
+  
+  def test_rube_object_task_assignment_works
+    @empty_rube.tasks= [[:eval, 'foo'],[:require, 'bar'],[:template, 'baz']]
+    assert_equal @empty_rube.tasks.size, 3
+    assert_equal @empty_rube.tasks.first, [:eval, 'foo']
+    assert_equal @empty_rube.tasks[1], [:require, 'bar']
+    assert_equal @empty_rube.tasks.last, [:template, 'baz']
+  end
+end
+
+class TestRubeSettings < Test::Unit::TestCase
+
+  def setup
+    @empty_rube = Rube.new
+  end
+
+  def test_rube_default_disable_percent
+    assert_equal false, !!@empty_rube.disable_percent
+  end
+  
+  def test_rube_object_preserves_disable_percent
+    @empty_rube.disable_percent = true
+    assert_equal true, @empty_rube.disable_percent
+  end
+
+  def test_rube_default_safety
+    assert_equal nil, @empty_rube.safety
+  end
+
+  def test_rube_object_preserves_safety
+    @empty_rube.safety = 'foo'
+    assert_equal 'foo', @empty_rube.safety
+  end
+
+  def test_rube_default_from_command_line
+    assert_equal false, !!@empty_rube.from_command_line
+  end
+
+  def test_rube_object_preserves_from_command_line
+    @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
+    @disabled_rube.disable_percent = true
+  end
+
+  def test_rube_default_trim_level
+    assert_equal '0', @empty_rube.trim_level
+  end
+
+  def test_rube_default_trim_mode
+    assert_equal '%', @empty_rube.trim_mode
+  end
+
+  def test_rube_default_trim_mode_with_disabled_percent
+    assert_equal '', @disabled_rube.trim_mode
+  end
+
+  def test_rube_object_accepts_trim_level_0
+    @empty_rube.trim_level = '0'
+    assert_equal '0', @empty_rube.trim_level
+    assert_equal '%', @empty_rube.trim_mode
+  end
+
+  def test_rube_object_accepts_trim_level_1
+    @empty_rube.trim_level = '1'
+    assert_equal '1', @empty_rube.trim_level
+    assert_equal '%>', @empty_rube.trim_mode
+  end
+
+  def test_rube_object_accepts_trim_level_2
+    @empty_rube.trim_level = '2'
+    assert_equal '2', @empty_rube.trim_level
+    assert_equal '%<>', @empty_rube.trim_mode
+  end
+
+  def test_rube_object_accepts_trim_level_numeric_1
+    @empty_rube.trim_level = 1
+    assert_equal '1', @empty_rube.trim_level
+    assert_equal '%>', @empty_rube.trim_mode
+  end
+
+  def test_rube_object_rejects_invalid_trim_level
+    assert_raises(Rube::BadArgumentError) { @empty_rube.trim_level = 'foo' }
+  end
+  
+  def test_rube_object_accepts_trim_level_dash
+    @empty_rube.trim_level = '-'
+    assert_equal '-', @empty_rube.trim_level
+    assert_equal '%-', @empty_rube.trim_mode
+  end
+
+  def test_rube_object_accepts_trim_level_0_with_disabled_percent
+    @disabled_rube.trim_level = '0'
+    assert_equal '0', @disabled_rube.trim_level
+    assert_equal '', @disabled_rube.trim_mode
+  end
+
+  def test_rube_object_accepts_trim_level_1_with_disabled_percent
+    @disabled_rube.trim_level = '1'
+    assert_equal '1', @disabled_rube.trim_level
+    assert_equal '>', @disabled_rube.trim_mode
+  end
+
+  def test_rube_object_accepts_trim_level_2_with_disabled_percent
+    @disabled_rube.trim_level = '2'
+    assert_equal '2', @disabled_rube.trim_level
+    assert_equal '<>', @disabled_rube.trim_mode
+  end
+
+  def test_rube_object_accepts_trim_level_dash_with_disabled_percent
+    @disabled_rube.trim_level = '-'
+    assert_equal '-', @disabled_rube.trim_level
+    assert_equal '-', @disabled_rube.trim_mode
+  end
+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
+  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
+    @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 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
+  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"
+  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
+    # 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"
+  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"
+  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"
+  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"
+  end
+end
+
+class TestRubeErrors < Test::Unit::TestCase
+  def setup
+    @rube = Rube.new
+  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
+end
+
+class TestRubeCommandLineHelp < Test::Unit::TestCase
+  HELP_PATTERN = /erb templates.*Usage:/m
+  def test_help
+    res = `rube --help 2>&1`
+    assert_match HELP_PATTERN, res, "Failed to produce help text for --help"
+    assert_equal 1, $?.exitstatus, "Expected return code of 1 for help text"
+  end
+
+  BAD_PATTERN = /invalid option.*foo.*erb templates.*Usage:/m
+  def test_bad_argument
+    res = `rube --foo 2>&1`
+    assert_match BAD_PATTERN, res, "Failed to produce error message and help text for --foo"
+    assert_equal 2, $?.exitstatus, "Expected return code of 2 for bad argument"
+  end
+
+  REQUIRE_ERROR_PATTERN = /Can't find require file/
+  def test_bad_require
+    res = `rube -E -r 'foo' 2>&1`
+    assert_match REQUIRE_ERROR_PATTERN, res, "Failed to produce error message for bad require file"
+    assert_equal 3, $?.exitstatus, "Expected return code of 3 for bad require file"
+  end
+
+  TEMPLATE_ERROR_PATTERN = /Can't find template file/
+  def test_bad_template
+    res = `rube -E foo 2>&1`
+    assert_match TEMPLATE_ERROR_PATTERN, res, "Failed to produce error message for bad template file"
+    assert_equal 4, $?.exitstatus, "Expected return code of 4 for bad template file"
+  end
+
+  SOURCE_ERROR_PATTERN = /Error executing source/
+  def test_bad_eval
+    res = `rube -E -e 'foo' 2>&1`
+    assert_match SOURCE_ERROR_PATTERN, res, "Failed to produce error message for bad eval source"
+    assert_equal 5, $?.exitstatus, "Expected return code of 5 for bad eval source"
+  end
+end
+
+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
+      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
+      # 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
+  end
+
+  def test_process_require_task_long_form
+    StringIO.open do |out|
+      $stdout = out
+      @rube.process_options('--explicit', '--require', 'English', '--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
+  end
+  
+  def test_process_template_task
+    StringIO.open do |out|
+      $stdout = out
+      @rube.process_options('templates/test1')
+      @rube.generate
+      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
+      # 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
+  end
+  
+  def test_process_template_task_with_trim_level_1
+    StringIO.open do |out|
+      $stdout = out
+      @rube.process_options('--trim', '1', 'templates/test1')
+      @rube.generate
+      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
+      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
+      assert_equal "bar\nfoo*2\n", out.string, "Failed to produce expected result from test2 template with passed variable value"
+    end
+  end
+end
+
+class TestRubeCommandLineDirectly < Test::Unit::TestCase
+#
+#   Not really an exhaustive test, but if this works, things should be okay
+#
+  def test_eval
+    res = `rube -E -e 'puts "foo"'`
+    assert_equal "foo\n", res, "Failed to produce expected output on $stdout"
+  end
+
+  def test_process_require_task
+    res = `rube --explicit -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+$/, res.chomp, "Failed to load require file")
+  end
+  
+  def test_process_template_task
+    res = `rube.rb 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
+  
+  def test_process_implicit_template_task
+    res = `rube < templates/test1`
+    assert_equal "foo\nblurg\nblurble\n\nfarb\n\n", res, "Failed to produce expected result from implicit test1 template"
+  end
+  
+  def test_process_explicit_stdin_template_task
+    res = `rube -e 'b="foo"' --stdin templates/test2 < templates/test1`
+    assert_equal "foo\nblurg\nblurble\n\nfarb\n\nbar\nfoo*2\n", res, "Failed to produce expected result from explicit stdin template"
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: rube
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Richard LeBer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-20 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: |-
+  Rube -- Slightly smarter erb front-end
+  
+    Rube allows you to apply erb to templates, interspersed with other ruby code, either as inline source or 	
+    as ruby files (e.g. requires). Rube can be invoked from the command line as a command in the form:
+  
+      rube [options] task ...
+email: 
+- rleber@mindspring.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/rube.rb
+- script/console
+- script/destroy
+- script/generate
+- templates/test1
+- templates/test2
+- test/test_helper.rb
+- test/test_rube.rb
+has_rdoc: true
+homepage: http://github.com/rleber/rube
+licenses: []
+
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rube
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Rube -- Slightly smarter erb front-end  Rube allows you to apply erb to templates, interspersed with other ruby code, either as inline source or 	 as ruby files (e.g
+test_files: 
+- test/test_helper.rb
+- test/test_rube.rb