linecook 0.6.2

data/lib/linecook/shell/test.rb

@@ -0,0 +1,254 @@
+require 'linecook/test'
+
+module Linecook
+  module Shell
+    # A module for testing shell scripts.
+    #
+    #   class ShellTestSample < Test::Unit::TestCase
+    #     include Linecook::Test::Shell
+    #
+    #     # these are the default sh_test options used 
+    #     # in tests like test_sh_command_alias
+    #     self.sh_test_options = {
+    #       :cmd_pattern => '% inspect_argv',
+    #       :cmd => 'ruby -e "puts ARGV.inspect"'
+    #     }
+    #
+    #     def test_echo
+    #       assert_equal "goodnight moon", sh("echo goodnight moon").strip
+    #     end
+    #
+    #     def test_echo_using_sh_test
+    #       sh_test %q{
+    #   echo goodnight moon
+    #   goodnight moon
+    #   }
+    #     end
+    #
+    #     def test_sh_command_alias
+    #       sh_test("% inspect_env") do |output|
+    #         assert output !~ /NEW_ENV_VAR/
+    #       end
+    #
+    #       sh_test("NEW_ENV_VAR=blue % inspect_env") do |output|
+    #         assert output =~ /NEW_ENV_VAR=blue/
+    #       end
+    #     end
+    #   end
+    #
+    module Test
+      include Linecook::Test
+    
+      def setup
+        super
+        @notify_method_name = true
+      end
+    
+      # Sets the specified ENV variables and returns the *current* env.
+      # If replace is true, current ENV variables are replaced; otherwise
+      # the new env variables are simply added to the existing set.
+      def set_env(env={}, replace=false)
+        current_env = {}
+        ENV.each_pair do |key, value|
+          current_env[key] = value
+        end
+
+        ENV.clear if replace
+
+        env.each_pair do |key, value|
+          if value.nil?
+            ENV.delete(key)
+          else
+            ENV[key] = value
+          end
+        end if env
+
+        current_env
+      end
+
+      # Sets the specified ENV variables for the duration of the block.
+      # If replace is true, current ENV variables are replaced; otherwise
+      # the new env variables are simply added to the existing set.
+      #
+      # Returns the block return.
+      def with_env(env={}, replace=false)
+        current_env = nil
+        begin
+          current_env = set_env(env, replace)
+          yield
+        ensure
+          if current_env
+            set_env(current_env, true)
+          end
+        end
+      end
+
+      # Returns true if the ENV variable 'VERBOSE' is true.
+      def verbose?
+        verbose = ENV['VERBOSE']
+        verbose && verbose =~ /^true$/i ? true : false
+      end
+
+      # Returns true if the ENV variable 'QUIET' is true or nil. If 'VERBOSE'
+      # and 'QUIET' are both set, verbose wins.
+      def quiet?
+        return false if verbose?
+
+        quiet = ENV['QUIET']
+        quiet.nil? || quiet =~ /^true$/i ? true : false
+      end
+
+      # Executes the command using IO.popen and returns the stdout content.
+      #
+      # ==== Note
+      # On Windows this method requires the {win32-popen3}[http://rubyforge.org/projects/win32utils]
+      # utility.  If it is not available, it will have to be installed:
+      #
+      #   % gem install win32-open3 
+      # 
+      def sh(cmd, options={})
+        if @notify_method_name && !quiet?
+          @notify_method_name = false
+          puts
+          puts method_name 
+        end
+
+        original_cmd = cmd
+        if cmd_pattern = options[:cmd_pattern]
+          cmd = cmd.sub(cmd_pattern, options[:cmd].to_s)
+        end
+
+        start = Time.now
+        result = with_env(options[:env], options[:replace_env]) do
+          IO.popen(cmd) do |io|
+            yield(io) if block_given?
+            io.read
+          end
+        end
+
+        finish = Time.now
+        elapsed = "%.3f" % [finish-start]
+        puts "  (#{elapsed}s) #{verbose? ? cmd : original_cmd}" unless quiet?
+        result
+      end
+
+      # Peforms a shell test.  Shell tests execute the command and yield the
+      # $stdout result to the block for validation.  The command is executed
+      # through sh, ie using IO.popen.
+      #
+      # Options provided to sh_test are merged with the sh_test_options set
+      # for the class.
+      #
+      # ==== Command Aliases
+      #
+      # The options allow specification of a command pattern that gets
+      # replaced with a command alias.  Only the first instance of the command
+      # pattern is replaced.  In addition, shell tests allow the expected result
+      # to be specified inline with the command.  Used together, these allow
+      # multiple tests of a complex command to be specified easily:
+      #
+      #   opts = {
+      #     :cmd_pattern => '% argv_inspect',
+      #     :cmd => 'ruby -e "puts ARGV.inspect"'
+      #   }
+      #
+      #   sh_test %Q{
+      #   % argv_inspect goodnight moon
+      #   ["goodnight", "moon"]
+      #   }, opts
+      #
+      #   sh_test %Q{
+      #   % argv_inspect hello world
+      #   ["hello", "world"]
+      #   }, opts
+      #
+      # ==== Indents
+      #
+      # To improve the readability of tests, sh_test will lstrip each line in the
+      # expected output to the same degree as the command line.  So for instance
+      # these all pass:
+      #
+      #   sh_test %Q{
+      #   % argv_inspect hello world
+      #   ["hello", "world"]
+      #   }, opts
+      #
+      #   sh_test %Q{
+      #       % argv_inspect hello world
+      #       ["hello", "world"]
+      #   }, opts
+      #
+      #       sh_test %Q{
+      #       % argv_inspect hello world
+      #       ["hello", "world"]
+      #       }, opts
+      #
+      # Turn off indent stripping by specifying :indent => false.
+      #
+      # ==== ENV variables
+      #
+      # Options may specify a hash of env variables that will be set in the
+      # subprocess.
+      #
+      #   sh_test %Q{
+      #   ruby -e "puts ENV['SAMPLE']"
+      #   value
+      #   }, :env => {'SAMPLE' => 'value'}
+      #
+      # Note it is better to specify env variables in this way rather than
+      # through the command trick 'VAR=value cmd ...', as that syntax does
+      # not work on Windows.  As a point of interest, see
+      # http://gist.github.com/107363 for a demonstration of ENV
+      # variables being inherited by subprocesses.
+      # 
+      def sh_test(cmd, options={})
+        options = sh_test_options.merge(options)
+
+        # strip indentiation if possible
+        if cmd =~ /\A(?:\s*?\n)?( *)(.*?\n)(.*)\z/m
+          indent, cmd, expected = $1, $2, $3
+          cmd.strip!
+
+          if indent.length > 0 && options[:indents]
+            expected.gsub!(/^ {0,#{indent.length}}/, '')
+          end
+        end
+
+        result = sh(cmd, options)
+
+        assert_equal(expected, result, cmd) if expected
+        yield(result) if block_given?
+        result
+      end
+
+      # Similar to sh_test, but matches the output against each of the
+      # regexps.  A hash of sh options can be provided as the last argument;
+      # it will be merged with the default sh_test_options.
+      #
+      # The output is yielded to the block, if given, for further validation.
+      # Returns the sh output.
+      def sh_match(cmd, *regexps)
+        options = regexps.last.kind_of?(Hash) ? regexps.pop : {}
+        options = sh_test_options.merge(options)
+        result = sh(cmd, options)
+
+        regexps.each do |regexp|
+          assert_match regexp, result, cmd
+        end
+        yield(result) if block_given?
+        result
+      end
+
+      # Returns a hash of default sh_test options.
+      def sh_test_options
+        {
+          :cmd_pattern => '% ',
+          :cmd => '2>&1 ',
+          :indents => true,
+          :env => {},
+          :replace_env => false
+        }
+      end
+    end
+  end
+end

data/lib/linecook/shell/unix.rb

@@ -0,0 +1,117 @@
+require 'erb'
+
+# Generated by Linecook, do not edit.
+module Linecook
+module Shell
+module Unix
+require 'linecook/shell/posix'
+include Posix
+# :stopdoc:
+CAT_LINE = __LINE__ + 2
+CAT = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+cat<% sources.each do |source| %> "<%= source %>"<% end %>
+END_OF_TEMPLATE
+# :startdoc:
+
+def cat(*sources)
+  eval(CAT, binding, __FILE__, CAT_LINE)
+  nil
+end
+
+def _cat(*args, &block) # :nodoc:
+  capture { cat(*args, &block) }
+end
+
+# :stopdoc:
+CHMOD_LINE = __LINE__ + 2
+CHMOD = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+<% if mode %>
+chmod <%= mode %> "<%= target %>"
+<% check_status %>
+<% end %>
+END_OF_TEMPLATE
+# :startdoc:
+
+def chmod(target, mode=nil)
+  eval(CHMOD, binding, __FILE__, CHMOD_LINE)
+  nil
+end
+
+def _chmod(*args, &block) # :nodoc:
+  capture { chmod(*args, &block) }
+end
+
+# :stopdoc:
+CHOWN_LINE = __LINE__ + 2
+CHOWN = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+<% if user || group %>
+chown <%= user %>:<%= group %> "<%= target %>"
+<% check_status %>
+<% end %>
+END_OF_TEMPLATE
+# :startdoc:
+
+def chown(target, user=nil, group=nil)
+  eval(CHOWN, binding, __FILE__, CHOWN_LINE)
+  nil
+end
+
+def _chown(*args, &block) # :nodoc:
+  capture { chown(*args, &block) }
+end
+
+# :stopdoc:
+ECHO_LINE = __LINE__ + 2
+ECHO = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+echo '<%= args.join(" ") %>'
+END_OF_TEMPLATE
+# :startdoc:
+
+# Echos input
+def echo(*args)
+  eval(ECHO, binding, __FILE__, ECHO_LINE)
+  nil
+end
+
+def _echo(*args, &block) # :nodoc:
+  capture { echo(*args, &block) }
+end
+
+# :stopdoc:
+LN_S_LINE = __LINE__ + 2
+LN_S = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+ln -sf "<%= source %>" "<%= target %>"
+<% check_status %>
+
+END_OF_TEMPLATE
+# :startdoc:
+
+def ln_s(source, target)
+  eval(LN_S, binding, __FILE__, LN_S_LINE)
+  nil
+end
+
+def _ln_s(*args, &block) # :nodoc:
+  capture { ln_s(*args, &block) }
+end
+
+# :stopdoc:
+RM_LINE = __LINE__ + 2
+RM = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+<% only_if %Q{ls -l "#{path}"} do %>
+rm <% if opts %><%= opts %> <% end %>"<%= path %>"
+<% end %>
+END_OF_TEMPLATE
+# :startdoc:
+
+def rm(path, opts=nil)
+  eval(RM, binding, __FILE__, RM_LINE)
+  nil
+end
+
+def _rm(*args, &block) # :nodoc:
+  capture { rm(*args, &block) }
+end
+end
+end
+end

data/lib/linecook/shell/utils.rb

@@ -0,0 +1,138 @@
+require 'erb'
+
+# Generated by Linecook, do not edit.
+module Linecook
+module Shell
+module Utils
+require 'linecook/shell/posix'
+include Posix
+
+DEFAULT_SHELL_PATH = '/bin/sh'
+DEFAULT_ENV_PATH   = '/usr/bin/env'
+
+TARGET_PATH = '$LINECOOK_DIR/%s'
+
+attr_writer :shell_path
+attr_writer :env_path
+
+def shell_path
+  @shell_path ||= DEFAULT_SHELL_PATH
+end
+
+def env_path
+  @env_path ||= DEFAULT_ENV_PATH
+end
+
+def target_path(source_path)
+  TARGET_PATH % super(source_path)
+end
+
+def close
+  unless closed?
+    break_line " (#{target_name}) "
+  end
+  
+  super
+end
+# :stopdoc:
+BREAK_LINE_LINE = __LINE__ + 2
+BREAK_LINE = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+<% n = (76 - comment.length)/2 %>
+<%= "#" * n %><%= comment %><%= "#" * n %>
+
+END_OF_TEMPLATE
+# :startdoc:
+
+def break_line(comment="")
+  eval(BREAK_LINE, binding, __FILE__, BREAK_LINE_LINE)
+  nil
+end
+
+def _break_line(*args, &block) # :nodoc:
+  capture { break_line(*args, &block) }
+end
+
+# :stopdoc:
+CHECK_STATUS_LINE = __LINE__ + 2
+CHECK_STATUS = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+check_status <%= status %> $? $LINENO
+END_OF_TEMPLATE
+# :startdoc:
+
+# Adds a check after a command that ensures the status is as indicated
+def check_status(status=0)
+  eval(CHECK_STATUS, binding, __FILE__, CHECK_STATUS_LINE)
+  nil
+end
+
+def _check_status(*args, &block) # :nodoc:
+  capture { check_status(*args, &block) }
+end
+
+# :stopdoc:
+CHECK_STATUS_FUNCTION_LINE = __LINE__ + 2
+CHECK_STATUS_FUNCTION = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+function check_status { if [ $1 -ne $2 ]; then echo "[$2] $0:$3"; exit $2; fi }
+END_OF_TEMPLATE
+# :startdoc:
+
+# Adds the check status function.
+def check_status_function
+  eval(CHECK_STATUS_FUNCTION, binding, __FILE__, CHECK_STATUS_FUNCTION_LINE)
+  nil
+end
+
+def _check_status_function(*args, &block) # :nodoc:
+  capture { check_status_function(*args, &block) }
+end
+
+# :stopdoc:
+SHEBANG_LINE = __LINE__ + 2
+SHEBANG = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+#! <%= shell_path %>
+
+<%= break_line %>
+<%= check_status_function %>
+
+export -f check_status
+export LINECOOK_DIR=$(dirname $0)
+export LINECOOK_OPTIONS=
+
+while getopts bhvx opt
+do
+  case $opt in
+  v)  LINECOOK_OPTIONS="$LINECOOK_OPTIONS -v";;
+  x)  LINECOOK_OPTIONS="$LINECOOK_OPTIONS -x";;
+  h)  printf "Usage: %s: [-hvx]\n" $0
+      printf "  -h    prints this help\n"
+      printf "  -v    verbose (set -v)\n"
+      printf "  -x    xtrace  (set -x)\n"
+      exit 0;;
+  ?)  printf "Usage: %s: [-hvx]\n" $0
+      exit 2;;
+  esac
+done
+
+set $LINECOOK_OPTIONS > /dev/null
+<%= break_line " #{target_name} " %>
+
+END_OF_TEMPLATE
+# :startdoc:
+
+# == Notes
+
+# Use dev/null on set such that no options will not dump ENV into stdout.
+
+def shebang(shell_path=DEFAULT_SHELL_PATH, env_path=DEFAULT_ENV_PATH)
+  @shell_path = shell_path
+  @env_path  = env_path
+  eval(SHEBANG, binding, __FILE__, SHEBANG_LINE)
+  nil
+end
+
+def _shebang(*args, &block) # :nodoc:
+  capture { shebang(*args, &block) }
+end
+end
+end
+end

data/lib/linecook/shell.rb

@@ -0,0 +1,11 @@
+require 'linecook/shell/posix'
+require 'linecook/shell/unix'
+require 'linecook/shell/utils'
+
+module Linecook
+  module Shell
+    include Posix
+    include Unix
+    include Utils
+  end
+end

data/lib/linecook/template.rb

@@ -0,0 +1,111 @@
+require 'ostruct'
+require 'stringio'
+require 'erb'
+
+module Linecook
+  class Template
+    class << self
+      def build(template, locals, template_path=nil)
+        ERB.new(template).result(OpenStruct.new(locals).send(:binding))
+      end
+    end
+    
+    attr_reader :erbout
+    
+    def initialize
+      @erbout = StringIO.new
+    end
+    
+    # Returns self (not the underlying erbout storage that actually receives
+    # the output lines).  In the ERB context, this method directs erb outputs
+    # to Template#concat and into the redirect mechanism.
+    def _erbout
+      self
+    end
+    
+    # Sets the underlying erbout storage to input.
+    def _erbout=(input)
+    end
+    
+    # Concatenates the specified input to the underlying erbout storage.
+    def concat(input)
+      erbout << input
+      self
+    end
+    
+    def capture(strip=true)
+      current, redirect = erbout, StringIO.new
+      
+      begin
+        @erbout = redirect
+        yield
+      ensure
+        @erbout = current
+      end
+      
+      str = redirect.string
+      str.strip! if strip
+      str
+    end
+    
+    def indent(indent='  ', &block)
+      capture(&block).split("\n").each do |line|
+        concat "#{indent}#{line}\n"
+      end
+      self
+    end
+    
+    def nest(*nestings)
+      options  = nestings.last.kind_of?(Hash) ? nestings.pop : {}
+      indent   = options[:indent] || "  "
+      line_sep = options[:line_sep] || "\n"
+      
+      content = capture { yield }
+      return content if nestings.empty?
+      
+      depth = nestings.length
+      lines = [indent * depth + content.gsub(/#{line_sep}/, line_sep + indent * depth)]
+
+      nestings.reverse_each do |(start_line, end_line)|
+        depth -= 1
+        lines.unshift(indent * depth + start_line)
+        lines << (indent * depth + end_line)
+      end
+
+      concat lines.join(line_sep)
+    end
+    
+    def rstrip(n=10)
+      yield if block_given?
+      
+      pos = erbout.pos
+      n = pos if pos < n
+      start = pos - n
+      
+      erbout.pos = start
+      tail = erbout.read(n).rstrip
+      
+      erbout.pos = start
+      erbout.truncate start
+      
+      tail.length == 0 && start > 0 ? rstrip(n * 2) : concat(tail)
+    end
+    
+    def close
+      erbout.close unless closed?
+      self
+    end
+    
+    def closed?
+      erbout.closed?
+    end
+    
+    def result(&block)
+      instance_eval(&block) if block
+      
+      erbout.flush
+      erbout.rewind
+      erbout.read
+    end
+  end
+end

data/lib/linecook/test/file_test.rb

@@ -0,0 +1,77 @@
+module Linecook
+  module Test
+    module FileTest
+      module ClassMethods
+        attr_accessor :class_dir
+        
+        def self.extended(base)
+          # Infers the test directory from the calling file.
+          #   'some_class_test.rb' => 'some_class_test'
+          calling_file = caller[2].gsub(/:\d+(:in .*)?$/, "")
+          base.class_dir = calling_file.chomp(File.extname(calling_file))
+        end
+      end
+    
+      module ModuleMethods
+        module_function
+      
+        def included(base)
+          base.extend base.kind_of?(Class) ? ClassMethods : ModuleMethods
+          super
+        end
+      end
+    
+      extend ModuleMethods
+    
+      attr_reader :user_dir
+      attr_reader :method_dir
+    
+      def setup
+        super
+        @user_dir   = Dir.pwd
+        @method_dir = File.expand_path(method_name, self.class.class_dir)
+      
+        cleanup method_dir
+        FileUtils.mkdir_p method_dir
+        Dir.chdir method_dir
+      end
+    
+      def teardown
+        Dir.chdir user_dir
+      
+        unless ENV["KEEP_OUTPUTS"] == "true"
+          cleanup class_dir
+        end
+      
+        super
+      end
+    
+      def cleanup(dir)
+        FileUtils.rm_r(dir) if File.exists?(dir)
+      end
+    
+      def path(relative_path)
+        File.expand_path(relative_path, method_dir)
+      end
+      
+      def prepare(relative_path)
+        target = path(relative_path)
+        
+        target_dir = File.dirname(target)
+        FileUtils.mkdir_p(target_dir) unless File.exists?(target_dir)
+        
+        target
+      end
+      
+      def file(relative_path, &block)
+        target = prepare(relative_path)
+        block ? File.open(target, 'w', &block) : FileUtils.touch(target)
+        target
+      end
+    
+      def class_dir
+        self.class.class_dir
+      end
+    end
+  end
+end