ratch 1.1.0 → 1.2.0

data/lib/ratch/console.rb

@@ -0,0 +1,199 @@
+module Ratch
+
+  # Ratch Shell Console
+  #
+  # NOTE: Console class is still a work in progress.
+  class Console
+
+		attr_accessor :suppress_output
+
+		# Set up the user's environment, including a pure binding into which
+		# env.rb and commands.rb are mixed.
+		def initialize
+      require 'readline'
+			#root = Rush::Dir.new('/')
+			#home = Rush::Dir.new(ENV['HOME']) if ENV['HOME']
+			#pwd = Rush::Dir.new(ENV['PWD']) if ENV['PWD']
+
+			#@config = Rush::Config.new
+
+			@config.load_history.each do |item|
+				Readline::HISTORY.push(item)
+			end
+
+			Readline.basic_word_break_characters = ""
+			Readline.completion_append_character = nil
+			Readline.completion_proc = completion_proc
+
+			@shell = Ratch::Shell.new
+
+			@pure_binding = @shell.instance_eval("binding")
+
+			$last_res = nil
+
+			#eval @config.load_env, @pure_binding
+
+			#commands = @config.load_commands
+			#Rush::Dir.class_eval commands
+			#Array.class_eval commands
+		end
+
+    # Run the interactive shell using readline.
+    def run
+      loop do
+        cmd = Readline.readline('ratch> ')
+     
+        finish if cmd.nil? or cmd == 'exit'
+
+        next if cmd == ""
+
+        Readline::HISTORY.push(cmd)
+     
+        execute(cmd)
+      end
+    end
+
+		# Run a single command.
+		def execute(cmd)
+			res = eval(cmd, @pure_binding)
+			$last_res = res
+			eval("_ = $last_res", @pure_binding)
+			print_result(res)
+		#rescue Rush::Exception => e
+		#	puts "Exception #{e.class} -> #{e.message}"
+		rescue ::Exception => e
+			puts "Exception #{e.class} -> #{e.message}"
+			e.backtrace.each do |t|
+				puts "   #{::File.expand_path(t)}"
+			end
+		end
+
+     # Save history to ~/.config/ratch/history when the shell exists.
+    def finish
+      @config.save_history(Readline::HISTORY.to_a)
+      puts
+      exit
+    end
+
+# TODO: FIX ALL BELOW
+
+		# Nice printing of different return types, particularly Rush::SearchResults.
+		def print_result(res)
+			return if self.suppress_output
+			if res.kind_of? String
+				puts res
+			elsif res.kind_of? Rush::SearchResults
+				widest = res.entries.map { |k| k.full_path.length }.max
+				res.entries_with_lines.each do |entry, lines|
+					print entry.full_path
+					print ' ' * (widest - entry.full_path.length + 2)
+					print "=> "
+					print res.colorize(lines.first.strip.head(30))
+					print "..." if lines.first.strip.length > 30
+					if lines.size > 1
+						print " (plus #{lines.size - 1} more matches)"
+					end
+					print "\n"
+				end
+				puts "#{res.entries.size} matching files with #{res.lines.size} matching lines"
+			elsif res.respond_to? :each
+				counts = {}
+				res.each do |item|
+					puts item
+					counts[item.class] ||= 0
+					counts[item.class] += 1
+				end
+				if counts == {}
+					puts "=> (empty set)"
+				else
+					count_s = counts.map do |klass, count|
+						"#{count} x #{klass}"
+					end.join(', ')
+					puts "=> #{count_s}"
+				end
+			else
+				puts "=> #{res.inspect}"
+			end
+		end
+
+		def path_parts(input)		# :nodoc:
+			case input
+			when /((?:@{1,2}|\$|)\w+(?:\[[^\]]+\])*)([\[\/])(['"])([^\3]*)$/
+				$~.to_a.slice(1, 4).push($~.pre_match)
+			when /((?:@{1,2}|\$|)\w+(?:\[[^\]]+\])*)(\.)(\w*)$/
+				$~.to_a.slice(1, 3).push($~.pre_match)
+			when /((?:@{1,2}|\$|)\w+)$/
+				$~.to_a.slice(1, 1).push(nil).push($~.pre_match)
+			else
+				[ nil, nil, nil ]
+			end
+		end
+
+		def complete_method(receiver, dot, partial_name, pre)
+			path = eval("#{receiver}.full_path", @pure_binding) rescue nil
+			box = eval("#{receiver}.box", @pure_binding) rescue nil
+			if path and box
+				(box[path].methods - Object.methods).select do |e|
+					e.match(/^#{Regexp.escape(partial_name)}/)
+				end.map do |e|
+					(pre || '') + receiver + dot + e
+				end
+			end
+		end
+
+		def complete_path(possible_var, accessor, quote, partial_path, pre)		# :nodoc:
+			original_var, fixed_path = possible_var, ''
+			if /^(.+\/)([^\/]*)$/ === partial_path
+				fixed_path, partial_path = $~.captures
+				possible_var += "['#{fixed_path}']"
+			end
+			full_path = eval("#{possible_var}.full_path", @pure_binding) rescue nil
+			box = eval("#{possible_var}.box", @pure_binding) rescue nil
+			if full_path and box
+				Rush::Dir.new(full_path, box).entries.select do |e|
+					e.name.match(/^#{Regexp.escape(partial_path)}/)
+				end.map do |e|
+					(pre || '') + original_var + accessor + quote + fixed_path + e.name + (e.dir? ? "/" : "")
+				end
+			end
+		end
+
+		def complete_variable(partial_name, pre)
+			lvars = eval('local_variables', @pure_binding)
+			gvars = eval('global_variables', @pure_binding)
+			ivars = eval('instance_variables', @pure_binding)
+			(lvars + gvars + ivars).select do |e|
+				e.match(/^#{Regexp.escape(partial_name)}/)
+			end.map do |e|
+				(pre || '') + e
+			end
+		end
+
+		# Try to do tab completion on dir square brackets and slash accessors.
+		#
+		# Example:
+		#
+		# dir['subd    # presing tab here will produce dir['subdir/ if subdir exists
+		# dir/'subd    # presing tab here will produce dir/'subdir/ if subdir exists
+		#
+		# This isn't that cool yet, because it can't do multiple levels of subdirs.
+		# It does work remotely, though, which is pretty sweet.
+		def completion_proc
+			proc do |input|
+				receiver, accessor, *rest = path_parts(input)
+				if receiver
+					case accessor
+					when /^[\[\/]$/
+						complete_path(receiver, accessor, *rest)
+					when /^\.$/
+						complete_method(receiver, accessor, *rest)
+					when nil
+						complete_variable(receiver, *rest)
+					end
+				end
+			end
+		end
+
+  end
+
+end

data/lib/ratch/core_ext.rb

@@ -1,6 +1,3 @@
-__DIR__ = File.dirname(__FILE__)
-
-Dir[File.join(__DIR__, 'core_ext', '*.rb')].each do |file|
+Dir[File.dirname(__FILE__) + '/core_ext/**/*.rb'].each do |file|
   require file
 end
-

data/lib/ratch/core_ext/facets.rb

@@ -1 +1,15 @@
-require 'facets'
+# I know some people will be deterred by the dependency on Facets b/c they
+# see it as a "heavy" dependency. But really that is far from true, consider
+# the following libs are all that it used.
+
+require 'facets/array/not_empty'
+require 'facets/dir/multiglob'            # DEPRECATE: when new #glob is working.
+require 'facets/module/basename'
+require 'facets/module/alias_accessor'
+require 'facets/kernel/yes'               # pulls in #ask and #no? too.
+require 'facets/kernel/silence'           # FIXME ???
+require 'facets/kernel/disable_warnings'
+
+require 'facets/pathname'
+require 'facets/filetest'
+require 'facets/fileutils'

data/lib/ratch/core_ext/filetest.rb

@@ -0,0 +1,29 @@
+module FileTest
+
+  # Return a cached list of the PATH environment variable.
+  # This is a support method used by #bin?
+  def command_paths
+    @command_paths ||= ENV['PATH'].split(/[:;]/)
+  end
+
+  # Is a file a bin/ executable?
+  #
+  # TODO: Make more robust. Probably needs to be fixed for Windows.
+  def bin?(fname)
+    is_bin = command_paths.any? do |f|
+      FileTest.exist?(File.join(f, fname))
+    end
+    #is_bin ? File.basename(fname) : false
+    is_bin ? fname : false
+  end
+
+  ## Is a file a task?
+  #
+  #def task?(path)
+  #  task = File.dirname($0) + "/#{path}"
+  #  task.chomp!('!')
+  #  task if FileTest.file?(task) && FileTest.executable?(task)
+  #end
+
+end
+

data/lib/ratch/core_ext/{string.rb → to_actual_filename.rb}

@@ -1,7 +1,5 @@
 class String
 
-  attr_accessor :color
-
   # Find actual filename (casefolding) and returns it.
   # Returns nil if no file is found.
 
@@ -17,26 +15,5 @@ class String
     replace(filename) if filename
   end
 
-  #
-  def unfold_paragraphs
-    blank = false
-    text  = ''
-    split(/\n/).each do |line|
-      if /\S/ !~ line
-        text << "\n\n"
-        blank = true
-      else
-        if /^(\s+|[*])/ =~ line 
-          text << (line.rstrip + "\n")
-        else
-          text << (line.rstrip + " ")
-        end
-        blank = false
-      end
-    end
-    text = text.gsub("\n\n\n","\n\n")
-    return text
-  end
-
 end
 

data/lib/ratch/core_ext/to_console.rb

@@ -1,18 +1,29 @@
+# TODO: Improve the naming scheme of these methods.
+
 #
-class Array
+class Array #:nodoc:
 
   # Convert an array into commandline parameters.
   # The array is accepted in the format of Ruby
   # method arguments --ie. [arg1, arg2, ..., hash]
 
   def to_console
-    flags = (Hash===last ? pop : {})
-    flags = flags.to_console
-    flags + ' ' + join(" ")
+    #flags = (Hash===last ? pop : {})
+    #flags = flags.to_console
+    #flags + ' ' + join(" ")
+    to_argv.join(' ')
   end
 
+  # TODO: DEPRECATE
   alias_method :to_params, :to_console
 
+  #
+  def to_argv
+    flags = (Hash===last ? pop : {})
+    flags = flags.to_argv
+    flags + self
+  end
+
 #   def to_console
 #     flags = (Hash===last ? pop : {})
 #     flags = flags.collect do |f,v|
@@ -35,25 +46,32 @@ end
 
 class Hash
 
-  # Convert an array into command line parameters.
+  # Convert a Hash into command line arguments.
   # The array is accepted in the format of Ruby
   # method arguments --ie. [arg1, arg2, ..., hash]
-
   def to_console
-    flags = collect do |f,v|
+    to_argv.join(' ')
+  end
+
+  # Convert a Hash into command line parameters.
+  # The array is accepted in the format of Ruby
+  # method arguments --ie. [arg1, arg2, ..., hash]
+  def to_argv
+    flags = []
+    each do |f,v|
       m = f.to_s.size == 1 ? '-' : '--'
       case v
       when Array
-        v.collect{ |e| "#{m}#{f}='#{e}'" }.join(' ')
+        v.each{ |e| flags << "#{m}#{f}='#{e}'" }
       when true
-        "#{m}#{f}"
+        flags << "#{m}#{f}"
       when false, nil
-        ''
+        # nothing
       else
-        "#{m}#{f}='#{v}'"
+        flags << "#{m}#{f}='#{v}'"
       end
     end
-    flags.join(" ")
+    flags
   end
 
   # Turn a hash into arguments.

data/lib/ratch/core_ext/{object.rb → to_yamlfrag.rb}

@@ -1,5 +1,6 @@
 class Object
 
+  #
   def to_yamlfrag
     to_yaml.sub("---",'').rstrip
   end

data/lib/ratch/core_ext/unfold_paragraphs.rb

@@ -0,0 +1,27 @@
+# TODO: Replace with facets/string/unfold
+
+class String
+
+  #
+  def unfold_paragraphs
+    blank = false
+    text  = ''
+    split(/\n/).each do |line|
+      if /\S/ !~ line
+        text << "\n\n"
+        blank = true
+      else
+        if /^(\s+|[*])/ =~ line
+          text << (line.rstrip + "\n")
+        else
+          text << (line.rstrip + " ")
+        end
+        blank = false
+      end
+    end
+    text = text.gsub("\n\n\n","\n\n")
+    return text
+  end
+
+end
+

data/lib/ratch/file_list.rb

@@ -0,0 +1,411 @@
+#require 'rake/file_utils_ext'
+
+module Ratch
+
+  # A FileList is essentially an array with a few helper methods defined to
+  # make file manipulation a bit easier.
+  #
+  # FileLists are lazy.  When given a list of glob patterns for possible files
+  # to be included in the file list, instead of searching the file structures
+  # to find the files, a FileList holds the pattern for latter use.
+  #
+  # This allows us to define a number of FileList to match any number of
+  # files, but only search out the actual files when then FileList itself is
+  # actually used.  The key is that the first time an element of the
+  # FileList/Array is requested, the pending patterns are resolved into a real
+  # list of file names.
+  #
+  class FileList
+
+    # == Method Delegation
+    #
+    # The lazy evaluation magic of FileLists happens by implementing all the
+    # array specific methods to call +resolve+ before delegating the heavy
+    # lifting to an embedded array object (@items).
+    #
+    # In addition, there are two kinds of delegation calls.  The regular kind
+    # delegates to the @items array and returns the result directly.  Well,
+    # almost directly.  It checks if the returned value is the @items object
+    # itself, and if so will return the FileList object instead.
+    #
+    # The second kind of delegation call is used in methods that normally
+    # return a new Array object.  We want to capture the return value of these
+    # methods and wrap them in a new FileList object.  We enumerate these
+    # methods in the +SPECIAL_RETURN+ list below.
+
+    # List of array methods (that are not in +Object+) that need to be
+    # delegated.
+    ARRAY_METHODS = (Array.instance_methods - Object.instance_methods).map { |n| n.to_s }
+
+    # List of additional methods that must be delegated.
+    MUST_DEFINE = %w[to_a inspect <=>]
+
+    # List of methods that should not be delegated here (we define special
+    # versions of them explicitly below).
+    MUST_NOT_DEFINE = %w[to_a to_ary partition *]
+
+    # List of delegated methods that return new array values which need
+    # wrapping.
+    SPECIAL_RETURN = %w[
+      map collect sort sort_by select find_all reject grep
+      compact flatten uniq values_at
+      + - & |
+    ]
+
+    DELEGATING_METHODS = (ARRAY_METHODS + MUST_DEFINE - MUST_NOT_DEFINE).collect{ |s| s.to_s }.sort.uniq
+
+    # Now do the delegation.
+    DELEGATING_METHODS.each_with_index do |sym, i|
+      if SPECIAL_RETURN.include?(sym)
+        ln = __LINE__+1
+        class_eval %{
+          def #{sym}(*args, &block)
+            resolve
+            result = @items.send(:#{sym}, *args, &block)
+            FileList.new.import(result)
+          end
+        }, __FILE__, ln
+      else
+        ln = __LINE__+1
+        class_eval %{
+          def #{sym}(*args, &block)
+            resolve
+            result = @items.send(:#{sym}, *args, &block)
+            result.object_id == @items.object_id ? self : result
+          end
+        }, __FILE__, ln
+      end
+    end
+
+    # Create a new file list including the files listed. Similar to:
+    #
+    #   FileList.new(*args)
+    def self.[](*args)
+      new(*args)
+    end
+
+    # Same a #new but removes the default exclusions.
+    def self.all(*args)
+      obj = new(*args)
+      obj.clear_exclude
+      obj
+    end
+
+    # Create a file list from the globbable patterns given.  If you wish to
+    # perform multiple includes or excludes at object build time, use the
+    # "yield self" pattern.
+    #
+    # Example:
+    #   file_list = FileList.new('lib/**/*.rb', 'test/test*.rb')
+    #
+    #   pkg_files = FileList.new('lib/**/*') do |fl|
+    #     fl.exclude(/\bCVS\b/)
+    #   end
+    #
+    def initialize(*patterns)
+      @pending_add = []
+      @pending = false
+      @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
+      @exclude_procs    = DEFAULT_IGNORE_PROCS.dup
+      @items = []
+      patterns.each { |pattern| include(pattern) }
+      yield self if block_given?
+    end
+
+    # Add file names defined by glob patterns to the file list.  If an array
+    # is given, add each element of the array.
+    #
+    # Example:
+    #   file_list.include("*.java", "*.cfg")
+    #   file_list.include %w( math.c lib.h *.o )
+    #
+    def include(*filenames)
+      # TODO: check for pending
+      filenames.each do |fn|
+        if fn.respond_to? :to_ary
+          include(*fn.to_ary)
+        else
+          @pending_add << fn
+        end
+      end
+      @pending = true
+      self
+    end
+    alias :add :include
+
+    # Register a list of file name patterns that should be excluded from the
+    # list.  Patterns may be regular expressions, glob patterns or regular
+    # strings.  In addition, a block given to exclude will remove entries that
+    # return true when given to the block.
+    #
+    # Note that glob patterns are expanded against the file system. If a file
+    # is explicitly added to a file list, but does not exist in the file
+    # system, then an glob pattern in the exclude list will not exclude the
+    # file.
+    #
+    # Examples:
+    #   FileList['a.c', 'b.c'].exclude("a.c") => ['b.c']
+    #   FileList['a.c', 'b.c'].exclude(/^a/)  => ['b.c']
+    #
+    # If "a.c" is a file, then ...
+    #   FileList['a.c', 'b.c'].exclude("a.*") => ['b.c']
+    #
+    # If "a.c" is not a file, then ...
+    #   FileList['a.c', 'b.c'].exclude("a.*") => ['a.c', 'b.c']
+    #
+    def exclude(*patterns, &block)
+      patterns.each do |pat|
+        @exclude_patterns << pat
+      end
+      if block_given?
+        @exclude_procs << block
+      end
+      resolve_exclude if ! @pending
+      self
+    end
+
+
+    # Clear all the exclude patterns so that we exclude nothing.
+    def clear_exclude
+      @exclude_patterns = []
+      @exclude_procs    = []
+      self
+    end
+
+    # Define equality.
+    def ==(array)
+      to_ary == array
+    end
+
+    # Return the internal array object.
+    def to_a
+      resolve
+      @items
+    end
+
+    # Return the internal array object.
+    def to_ary
+      to_a
+    end
+
+    # Lie about our class.
+    def is_a?(klass)
+      klass == Array || super(klass)
+    end
+    alias kind_of? is_a?
+
+    # Redefine * to return either a string or a new file list.
+    def *(other)
+      result = @items * other
+      case result
+      when Array
+        FileList.new.import(result)
+      else
+        result
+      end
+    end
+
+    # Resolve all the pending adds now.
+    def resolve
+      if @pending
+        @pending = false
+        @pending_add.each do |fn| resolve_add(fn) end
+        @pending_add = []
+        resolve_exclude
+      end
+      self
+    end
+
+    def resolve_add(fn)
+      case fn
+      when %r{[*?\[\{]}
+        add_matching(fn)
+      else
+        self << fn
+      end
+    end
+    private :resolve_add
+
+    def resolve_exclude
+      reject! { |fn| exclude?(fn) }
+      self
+    end
+    private :resolve_exclude
+
+    # Return a new FileList with the results of running +sub+ against each
+    # element of the orignal list.
+    #
+    # Example:
+    #   FileList['a.c', 'b.c'].sub(/\.c$/, '.o')  => ['a.o', 'b.o']
+    #
+    def sub(pat, rep)
+      inject(FileList.new) { |res, fn| res << fn.sub(pat,rep) }
+    end
+
+    # Return a new FileList with the results of running +gsub+ against each
+    # element of the original list.
+    #
+    # Example:
+    #   FileList['lib/test/file', 'x/y'].gsub(/\//, "\\")
+    #      => ['lib\\test\\file', 'x\\y']
+    #
+    def gsub(pat, rep)
+      inject(FileList.new) { |res, fn| res << fn.gsub(pat,rep) }
+    end
+
+    # Same as +sub+ except that the oringal file list is modified.
+    def sub!(pat, rep)
+      each_with_index { |fn, i| self[i] = fn.sub(pat,rep) }
+      self
+    end
+
+    # Same as +gsub+ except that the original file list is modified.
+    def gsub!(pat, rep)
+      each_with_index { |fn, i| self[i] = fn.gsub(pat,rep) }
+      self
+    end
+
+    # Apply the pathmap spec to each of the included file names, returning a
+    # new file list with the modified paths.  (See String#pathmap for
+    # details.)
+    def pathmap(spec=nil)
+      collect { |fn| fn.pathmap(spec) }
+    end
+
+    # Return a new FileList with <tt>String#ext</tt> method applied to
+    # each member of the array.
+    #
+    # This method is a shortcut for:
+    #
+    #    array.collect { |item| item.ext(newext) }
+    #
+    # +ext+ is a user added method for the Array class.
+    def ext(newext='')
+      collect { |fn| fn.ext(newext) }
+    end
+
+
+    # Grep each of the files in the filelist using the given pattern. If a
+    # block is given, call the block on each matching line, passing the file
+    # name, line number, and the matching line of text.  If no block is given,
+    # a standard emac style file:linenumber:line message will be printed to
+    # standard out.  Returns the number of matched items.
+    def egrep(pattern, *options)
+      matched = 0
+      each do |fn|
+        begin
+          open(fn, "rb", *options) do |inf|
+            count = 0
+            inf.each do |line|
+              count += 1
+              if pattern.match(line)
+                matched += 1
+                if block_given?
+                  yield fn, count, line
+                else
+                  puts "#{fn}:#{count}:#{line}"
+                end
+              end
+            end
+          end
+        rescue StandardError => ex
+          puts "Error while processing '#{fn}': #{ex}"
+        end
+      end
+      matched
+    end
+    
+    # Return a new file list that only contains file names from the current
+    # file list that exist on the file system.
+    def existing
+      select { |fn| File.exist?(fn) }
+    end
+
+    # Modify the current file list so that it contains only file name that
+    # exist on the file system.
+    def existing!
+      resolve
+      @items = @items.select { |fn| File.exist?(fn) }
+      self
+    end
+
+    # FileList version of partition.  Needed because the nested arrays should
+    # be FileLists in this version.
+    def partition(&block)       # :nodoc:
+      resolve
+      result = @items.partition(&block)
+      [
+        FileList.new.import(result[0]),
+        FileList.new.import(result[1]),
+      ]
+    end
+
+    # Convert a FileList to a string by joining all elements with a space.
+    def to_s
+      resolve
+      self.join(' ')
+    end
+
+    # Add matching glob patterns.
+    def add_matching(pattern)
+      Dir[pattern].each do |fn|
+        self << fn unless exclude?(fn)
+      end
+    end
+    private :add_matching
+
+    # Should the given file name be excluded?
+    def exclude?(fn)
+      return true if @exclude_patterns.any? do |pat|
+        case pat
+        when Regexp
+          fn =~ pat
+        when /[*?]/
+          File.fnmatch?(pat, fn, File::FNM_PATHNAME)
+        else
+          fn == pat
+        end
+      end
+      @exclude_procs.any? { |p| p.call(fn) }
+    end
+
+    def import(array)
+      @items = array
+      self
+    end
+
+    # Clone an object by making a new object and setting all the instance
+    # variables to the same values.
+    def dup
+      sibling = self.class.new
+      instance_variables.each do |ivar|
+        value = self.instance_variable_get(ivar)
+        new_value = value.clone rescue value
+        sibling.instance_variable_set(ivar, new_value)
+      end
+      sibling.taint if tainted?
+      sibling
+    end
+
+    def clone
+      sibling = dup
+      sibling.freeze if frozen?
+      sibling
+    end
+
+    #
+    DEFAULT_IGNORE_PATTERNS = [
+      /(^|[\/\\])CVS([\/\\]|$)/,
+      /(^|[\/\\])\.svn([\/\\]|$)/,
+      /\.bak$/,
+      /~$/
+    ]
+
+    #
+    DEFAULT_IGNORE_PROCS = [
+      proc { |fn| fn =~ /(^|[\/\\])core$/ && ! File.directory?(fn) }
+    ]
+
+  end 
+end
+