carats 0.3.0

data/lib/carat/dynamic-mixin.rb

@@ -0,0 +1,71 @@
+=begin :rdoc:
+
+= DynamicMixin
+
+== Example
+
+module Mixin
+  extend DynamicMixin
+  def self.default_options
+    { :name => "Buffalo" }
+  end
+  def hello
+    puts "Hello from #{dynamic_options[:name]}!"
+  end
+end
+
+class T
+  include Mixin[ :name => "Test" ]
+end
+t = T.new
+t.hello
+
+class S
+  include Mixin[ :name => "Sister" ]
+end
+s = S.new
+s.hello
+
+module Mixin2
+  extend DynamicMixin
+  include Mixin[ :name => "Flo"]
+end
+
+class R
+  include Mixin2[ :name => "Bruce"]
+end
+r = R.new
+r.hello
+
+=end
+
+module DynamicMixin
+
+  def self.extended( mod )
+    mod.class_eval do
+      define_method(:dynamic_options) {
+        mod.respond_to?(:default_options) ? mod.default_options : {}
+      } 
+    end
+  end
+
+  def [](options = {})
+    @cache ||= {} # Not really needed, but not much work either
+
+    defaults = self.respond_to?( :default_options ) ? self.default_options : {}
+    options = defaults.merge(options)
+
+    mod = self.name
+    opt_str = options.map { |pair| pair.join(" => ") }.join(", ")
+    name = "#{self.name}[#{opt_str}]"
+
+    @cache[options] ||= self.dup
+    @cache[options].class_eval {
+      meta = class << self; self; end
+      meta.send(:define_method, :name) { name }
+      define_method(:dynamic_options) { options }
+    }
+    return @cache[options]
+  end
+
+end

data/lib/carat/enumerable-args.rb

@@ -0,0 +1,125 @@
+=begin rdoc
+
+= EnumerableWithArgs
+
+This is a simple reimplementation of the core Enumerable module 
+to allow the methods to take and pass-on arbitrary arguments to the
+underlying #each call.
+
+== Synopsis
+
+  require 'carat/enumerable-args'
+
+  class T
+    include Enumerable
+    def initialize(arr)
+      @arr = arr
+    end
+    def each(n)
+      arr.each{ |e| yield(e+n) }
+    end
+  end
+  
+  t = T.new([1,2,3])
+  t.collect(4)
+  #=> [5,6,7]
+
+== Note
+
+The #sort method still needs to be done.
+  
+== Legal
+
+  Copyright (c) 2004 Thomas Sawyer, Pancakes License
+
+== History
+
+  $Id: enumerable.rb,v 1.0 2004/11/30 transami Exp $
+
+=end
+
+module EnumerableWithArgs
+    
+  def collect(*args)  # :yield:
+    a = []
+    each(*args){ |n| a << yield(n) }
+    a
+  end
+  alias_method( :map, :collect )
+  
+  def detect(*args)  # :yield:
+    each(*args){ |n| return n if yield(n) }
+    nil
+  end
+  alias_method( :find, :detect )
+
+  # problematic for multiple arity on block
+  #def each_with_index(*args)
+  #  i=0
+  #  each(*args){ |n,i| yield(n); i+=1 }
+  #  self
+  #end
+
+  def to_a(*args)
+    a = []
+    each(*args){ |n| a << n }
+    a
+  end
+  alias_method( :entries, :to_a )
+
+  # An additional method not part of standard Enumerable.
+  # The regular version of this method can be found in Facets,
+  # but it is a bit more advanced then this one.
+  # At some point they need to be put into sync.
+  def each_slice(*args, &yld)
+    a = []; s = []
+    ar = yld.arity.abs
+    each(*args){ |n|
+      s << n
+      if s.length >= ar
+        yld.call(*s)
+        s = []
+      end
+    }
+    a
+  end
+  alias_method( :each_by, :each_slice ) 
+  
+  def select(*args)  # :yield:
+    a = []
+    each(*args){ |n| a << n if yield(n) }
+    a
+  end
+  alias_method( :find_all, :select )
+  
+  def grep(pattern, *args)
+    a = []
+    each(*args){ |n| a << (block_given? ? yield(n) : n) if pattern === n }
+    a  
+  end
+  
+  def include?(anObj, *args)
+    each(*args){ |n| return true if anObj == n }
+    false
+  end
+  alias_method( :member?, :include? )
+  
+  def max(*args)
+    to_a(*args).max
+  end
+  
+  def min(*args)
+    to_a(*args).min
+  end
+  
+  def reject(*args)
+    a = []
+    each(*args){ |n| a << n if ! yield(n) }
+    a
+  end
+  
+  def sort(*args)
+    # TODO
+  end
+  
+end 

data/lib/carat/expect.rb

@@ -0,0 +1,192 @@
+=begin rdoc
+
+= Expect
+
+Given an IO object, read data from that object and expect certain data.
+
+All expected data is expected in 'chains'.  When a message is received, it
+is compared to the pattern at the top of each chain.  If it matches one of
+the patterns, then all is well, but an error message is printed otherwise.
+
+A message can match patterns in more than one chain.
+
+== Synopsis
+
+  require 'carat/expect'
+
+  # to do
+
+== Legal
+
+Adopted from Ruby Treasures 0.4
+Copyright (C) 2002 Paul Brannan <paul@atdesk.com>
+ 
+You may distribute this software under the same terms as Ruby (see the file
+COPYING that was distributed with this library).
+
+== History
+
+  $Id: expect.rb, v0.4 2004/11/30 transami Exp $
+
+=end
+
+class Expect
+public
+
+  VERSION = "0.4"
+
+  class UnmatchedMessage < Exception
+    attr_reader :msg
+
+    def initialize(msg)
+      @msg = msg
+      super("Message not matched: `#{msg}'")
+    end
+  end
+
+  class Timeout < Exception
+    attr_reader :chain
+    attr_reader :pattern
+
+    def initialize(chain, pattern)
+      @chain = chain
+      @pattern = pattern
+      
+      super("Timed out waiting for #{pattern.inspect} in chain #{chain.inspect}")
+    end
+  end
+
+  ##
+  # A special type of pattern that matches a list of patterns, separated
+  # by a given separator, in any order.
+  #
+  # Example:
+  # <pre>
+  #   # matches 'foo,bar' and 'bar,foo'
+  #   p = Expect::SeparatedPattern.new(['foo', 'bar'])
+  #   
+  #   e = Expect.new(nil, nil)
+  #   e.expect(p)
+  # </pre>
+  #
+  class SeparatedPattern
+    attr_accessor :separator
+
+    def initialize(message, separator = ',')
+      @message = message
+      @separator = separator
+    end
+
+    def ===(line)
+      message = @message.dup
+
+      # Iterate through each field to make sure it matches.  When
+      # we find a match, delete that field so we never check it
+      # again.
+      for field in fields do
+        message.each_index do |index|
+          if message[index] === field then
+            message.delete_at(index)
+          end
+        end
+      end
+
+      # If there are no more fields, then we deleted all of them,
+      # and we got a match
+      return message.length == 0
+    end
+  end
+
+  class DefaultChain
+  end
+
+  ##
+  # It is highly recommended that this be an immutable object.
+  #
+  attr_accessor :timeout
+
+  ##
+  # Create a new Expect_Test object.
+  #
+  # @param io_object an IO object to read from.
+  # @param reactor a reactor to use
+  #
+  def initialize(io_object, reactor)
+    @io_object = io_object
+    @reactor = reactor
+    @reactor.register_read(@io_object, method(:handle_event))
+    reset()
+  end
+
+  ##
+  # Reset the the ignore chain and all expect chains.
+  #
+  def reset()
+    @expect_chain = Hash.new
+    @ignore_chain = Array.new
+    @expects_left = 0
+  end
+
+  ##
+  # Expect a message matching pattern in a certain chain.
+  #
+  # @param pattern the pattern to expect.
+  # @param chain the chain in which to expect the message.
+  #
+  def expect(pattern, chain=DefaultChain)
+    @expect_chain[chain] ||= Array.new
+    @expect_chain[chain].push(pattern)
+    @expects_left += 1
+  end
+
+  ##
+  # Ignore a pattern in all chains.
+  #
+  # @param pattern the pattern to ignore.
+  #
+  def ignore(pattern)
+    @ignore_chain.push(pattern)
+  end
+
+  def run(timeout = nil)
+    return if @expects_left == 0
+    catch :expect_loop_done do
+      @reactor.run_event_loop(timeout)
+      for key, chain in @expect_chain do
+        next if chain.length == 0
+        raise Timeout.new(key, chain.first)
+      end
+      # TODO: What does it mean if we got here?
+    end
+  end
+
+  def handle_event(io_object)
+    handle_line(io_object.gets())
+  end
+
+  def handle_line(line)
+    line.chomp!()
+
+    # Check each element in the ignore chain
+    for pattern in @ignore_chain do
+      return if pattern === line
+    end
+
+    # Check the first element of each expect chain to see if
+    # the message matches
+    match = false
+    for key, chain in @expect_chain do
+      next if chain.length == 0
+      if chain.first() === line then
+        chain.shift()
+        @expects_left -= 1
+        match = true
+      end
+    end
+
+    throw :expect_loop_done if @expects_left == 0
+
+    raise UnmatchedMessage.new(line) if match == false
+  end
+end
+

data/lib/carat/filelist.rb

@@ -0,0 +1,277 @@
+=begin rdoc
+ 
+  = FileList
+
+  A FileList is essentially an array with a few helper methods
+  defined to make file manipulation a bit easier. It works in
+  a fashion similar to Dir.glob.
+    
+  == Synopsis
+ 
+    require 'trix/filelist'
+    
+    fl = FileList.new
+    fl.include('./**/*')
+    fl.exclude('./*~')
+ 
+  == Legal
+
+  Ported from Rake
+  Copyright (C) 2002 Jim Welch
+ 
+  You may distribute this software under the same terms as Ruby (see the file
+  COPYING that was distributed with this library).
+
+  == History
+  
+    $id: filelist.rb 2004/11/27 10:00:01 transami Exp $
+    
+=end
+
+class FileList < Array
+
+  # Rewrite all array methods (and to_s) to resolve the list before
+  # running.
+  methods = Array.instance_methods - Object.instance_methods
+  methods << "to_a"
+  methods.each_with_index do |sym, i|
+    alias_method "array_#{i}", sym
+    class_eval %{
+      def #{sym}(*args, &block)
+        resolve if @pending
+        array_#{i}(*args, &block)
+      end
+    }
+  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_re = nil
+#     @extent_only = false
+    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| @pending_add << fn end
+    @pending = true
+    self
+  end
+  alias :add :include
+  
+  
+#   def extent_only?
+#     @extent_only
+#   end
+#   
+#   def extent_only=(x)
+#     @extent_only = x ? true : false
+#   end
+  
+  # Register a list of file name patterns that should be excluded
+  # from the list.  Patterns may be regular expressions, glob
+  # patterns or regular strings.
+  #
+  # 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)
+    # TODO: check for pending
+    patterns.each do |pat| @exclude_patterns << pat end
+    if ! @pending
+      calculate_exclude_regexp
+      reject! { |fn| fn =~ @exclude_re }
+    end
+  end
+
+  
+  def clear_exclude
+    @exclude_patterns = []
+    calculate_exclude_regexp if ! @pending
+  end
+
+  # Resolve all the pending adds now.
+  def resolve
+    @pending = false
+    @pending_add.each do |fn| resolve_add(fn) end
+    @pending_add = []
+    resolve_exclude
+    self
+  end
+
+  def calculate_exclude_regexp
+    ignores = []
+    @exclude_patterns.each do |pat|
+      case pat
+      when Regexp
+        ignores << pat
+      when /[*.]/
+        Dir[pat].each do |p| ignores << p end
+      else
+        ignores << Regexp.quote(pat)
+      end
+    end
+    if ignores.empty?
+      @exclude_re = /^$/
+    else
+      re_str = ignores.collect { |p| "(" + p.to_s + ")" }.join("|")
+      @exclude_re = Regexp.new(re_str)
+    end
+  end
+
+  def resolve_add(fn)
+    case fn
+    when NilClass
+      # ignore
+    when Array
+      fn.each { |f| self.resolve_add(f) }
+    when %r{[*?]}
+      add_matching(fn)
+    else
+      self << fn if FileTest.exists?( fn )
+    end
+  end
+
+  def resolve_exclude
+    @exclude_patterns.each do |pat|
+      case pat
+      when Regexp
+        reject! { |fn| fn =~ pat }
+      when /[*.]/
+        reject_list = Dir[pat]
+        reject! { |fn| reject_list.include?(fn) }
+      else
+        reject! { |fn| fn == pat }
+      end
+    end
+    self
+  end
+  
+  # Return a new FileList with the results of running +sub+ against
+  # each element of the oringal 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
+
+  # Convert a FileList to a string by joining all elements with a space.
+  def to_s
+    resolve
+    self.join(' ')
+  end
+
+  # Convert a FileList to a string prior to resolving.
+  def to_str
+    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)
+    calculate_exclude_regexp unless @exclude_re
+    fn =~ @exclude_re
+  end
+
+  DEFAULT_IGNORE_PATTERNS = [
+    /(^|[\/\\])CVS([\/\\]|$)/,
+    /\.bak$/,
+    /~$/,
+    /(^|[\/\\])core$/
+  ]
+  @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
+
+  class << self
+    # Create a new file list including the files listed. Similar to:
+    #
+    #   FileList.new(*args)
+    def [](*args)
+      new(*args)
+    end
+
+    # Set the ignore patterns back to the default value.  The
+    # default patterns will ignore files 
+    # * containing "CVS" in the file path
+    # * ending with ".bak"
+    # * ending with "~"
+    # * named "core"
+    #
+    # Note that file names beginning with "." are automatically
+    # ignored by Ruby's glob patterns and are not specifically
+    # listed in the ignore patterns.
+    def select_default_ignore_patterns
+      @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
+    end
+
+    # Clear the ignore patterns.  
+    def clear_ignore_patterns
+      @exclude_patterns = [ /^$/ ]
+    end
+  end
+  
+end # class FileList