linecook 0.6.2 → 1.0.0

data/lib/linecook/shell.rb

@@ -1,11 +0,0 @@
-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/shell/posix.rb

@@ -1,145 +0,0 @@
-require 'erb'
-
-# Generated by Linecook, do not edit.
-module Linecook
-module Shell
-module Posix
-# :stopdoc:
-COMMENT_LINE = __LINE__ + 2
-COMMENT = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
-# <%= str %>
-END_OF_TEMPLATE
-# :startdoc:
-
-# Writes a comment
-def comment(str)
-  eval(COMMENT, binding, __FILE__, COMMENT_LINE)
-  nil
-end
-
-def _comment(*args, &block) # :nodoc:
-  capture { comment(*args, &block) }
-end
-
-# :stopdoc:
-HEREDOC_LINE = __LINE__ + 2
-HEREDOC = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
-<<<%= options[:indent] ? '-' : ' '%><%= options[:quote] ? "\"#{delimiter}\"" : delimiter %>
-<% yield %>
-<%= delimiter %>
-
-END_OF_TEMPLATE
-# :startdoc:
-
-# Makes a heredoc statement surrounding the contents of the block.  Options:
-
-# 
-
-#   delimiter   the delimiter used, by default HEREDOC_n where n increments
-
-#   indent      add '-' before the delimiter
-
-#   quote       quotes the delimiter
-
-def heredoc(options={})
-  delimiter = options[:delimiter] || begin
-    @heredoc_count ||= -1
-    "HEREDOC_#{@heredoc_count += 1}"
-  end
-  eval(HEREDOC, binding, __FILE__, HEREDOC_LINE)
-  nil
-end
-
-def _heredoc(*args, &block) # :nodoc:
-  capture { heredoc(*args, &block) }
-end
-
-# :stopdoc:
-NOT_IF_LINE = __LINE__ + 2
-NOT_IF = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
-only_if("! #{cmd}", &block)
-END_OF_TEMPLATE
-# :startdoc:
-
-def not_if(cmd, &block)
-  eval(NOT_IF, binding, __FILE__, NOT_IF_LINE)
-  nil
-end
-
-def _not_if(*args, &block) # :nodoc:
-  capture { not_if(*args, &block) }
-end
-
-# :stopdoc:
-ONLY_IF_LINE = __LINE__ + 2
-ONLY_IF = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
-if <%= cmd %>
-then
-<% indent { yield } %>
-fi
-
-END_OF_TEMPLATE
-# :startdoc:
-
-def only_if(cmd)
-  eval(ONLY_IF, binding, __FILE__, ONLY_IF_LINE)
-  nil
-end
-
-def _only_if(*args, &block) # :nodoc:
-  capture { only_if(*args, &block) }
-end
-
-# :stopdoc:
-SET_LINE = __LINE__ + 2
-SET = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
-<% if block_given? %>
-<% reset_file = "LINECOOK_RESET_OPTIONS_#{next_count}" %>
-<%= reset_file %>=`mktemp /tmp/line_cook_reset_fileXXXXXX`
-set -o | sed 's/\(.*\)	on/set -o \1/' | sed 's/\(.*\)	off/set +o \1/' > $<%= reset_file %>
-<% end %><% options.keys.sort_by {|opt| opt.to_s }.each do |opt| %>
-set <%= options[opt] ? '-' : '+' %>o <%= opt %>
-<% end %>
-<% if block_given? %>
-
-<% indent { yield }  %>
-
-source $<%= reset_file %>
-<% end %>
-
-END_OF_TEMPLATE
-# :startdoc:
-
-# Sets bash options for the duration of a block.  If no block is given,
-
-# set simply sets the options as specified.
-def set(options)
-  eval(SET, binding, __FILE__, SET_LINE)
-  nil
-end
-
-def _set(*args, &block) # :nodoc:
-  capture { set(*args, &block) }
-end
-
-# :stopdoc:
-UNSET_LINE = __LINE__ + 2
-UNSET = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
-<% keys.each do |key| %>
-unset <%= key %>
-<% end %>
-END_OF_TEMPLATE
-# :startdoc:
-
-# Unsets a list of variables.
-def unset(*keys)
-  eval(UNSET, binding, __FILE__, UNSET_LINE)
-  nil
-end
-
-def _unset(*args, &block) # :nodoc:
-  capture { unset(*args, &block) }
-end
-end
-end
-end

data/lib/linecook/shell/test.rb

@@ -1,254 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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