facets 2.7.0 → 2.8.0

data/lib/more/facets/continuation.rb

@@ -1,57 +1,56 @@
-# = Continuation Extension
-#
-# Creates a continuation in a way that is easier to use than callcc.
-# On the initial call this will return the created Continuation and
-# the arguments you gave to Continuation.create in an Array. If you
-# then issue .call() on the Continuation execution will jump back to
-# the point of time where you initially invoked Continuation.create,
-# but this time it will return the Continuation and the arguments
-# you supplied in an Array.
-#
-# You can supply a block instead of default arguments which will
-# cause that block to be executed once and its result to be returned
-# along side the created Continuation, but this form is confusing
-# and does only rarely make sense.
-#
-#   # Count from 0 to 10
-#   cc, counter = Continuation.create(0)
-#   puts counter
-#   cc.call(counter + 1) if counter < 10
-#
-#   # Implement something similar to Array#inject using Continuations.
-#   # For simplicity's sake, this is not fully compatible with the real
-#   # inject. Make sure that you understand Array#inject before you try
-#   # to understand this.
-#   class Array
-#     def cc_inject(value = nil)
-#       copy = self.clone
-#       cc, result, item = Continuation.create(value, nil)
-#       next_item = copy.shift
-#       if result and item
-#         # Aggregate the result using the block.
-#         cc.call(yield(result, item), next_item)
-#       elsif next_item
-#         # item not yet set and Array is not empty:
-#         # This means we did not get a value and thus need to use the
-#         # first item from the Array before we can start using the
-#         # block to aggregate the result.
-#         cc.call(next_item, result)
-#       end
-#
-#       return result
-#    end
-#  end
-#  [1,2,3,4,5].cc_inject { |acc, n| acc + n } # => 15
-#
+if defined?(Continuation)
 
+  # = Continuation Extension
+  #
+  # Creates a continuation in a way that is easier to use than callcc.
+  # On the initial call this will return the created Continuation and
+  # the arguments you gave to Continuation.create in an Array. If you
+  # then issue .call() on the Continuation execution will jump back to
+  # the point of time where you initially invoked Continuation.create,
+  # but this time it will return the Continuation and the arguments
+  # you supplied in an Array.
+  #
+  # You can supply a block instead of default arguments which will
+  # cause that block to be executed once and its result to be returned
+  # along side the created Continuation, but this form is confusing
+  # and does only rarely make sense.
+  #
+  #   # Count from 0 to 10
+  #   cc, counter = Continuation.create(0)
+  #   puts counter
+  #   cc.call(counter + 1) if counter < 10
+  #
+  #   # Implement something similar to Array#inject using Continuations.
+  #   # For simplicity's sake, this is not fully compatible with the real
+  #   # inject. Make sure that you understand Array#inject before you try
+  #   # to understand this.
+  #   class Array
+  #     def cc_inject(value = nil)
+  #       copy = self.clone
+  #       cc, result, item = Continuation.create(value, nil)
+  #       next_item = copy.shift
+  #       if result and item
+  #         # Aggregate the result using the block.
+  #         cc.call(yield(result, item), next_item)
+  #       elsif next_item
+  #         # item not yet set and Array is not empty:
+  #         # This means we did not get a value and thus need to use the
+  #         # first item from the Array before we can start using the
+  #         # block to aggregate the result.
+  #         cc.call(next_item, result)
+  #       end
+  #
+  #       return result
+  #    end
+  #  end
+  #  [1,2,3,4,5].cc_inject { |acc, n| acc + n } # => 15
+  #
+  def Continuation.create(*args, &block)
+    args = [args] if not args.nil? and not args.is_a? Array # 1.6.8 compatibility
+    cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
+    result ||= args
+    return *[cc, *result]
+  end
 
-# There is no continuation in Ruby 1.9.
-
-raise "Ruby 1.9+ does not support continuations." unless Continuation
-
-def Continuation.create(*args, &block)
-  args = [args] if not args.nil? and not args.is_a? Array # 1.6.8 compatibility
-  cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
-  result ||= args
-  return *[cc, *result]
 end
+

data/lib/more/facets/dictionary.rb

@@ -1,50 +1,15 @@
-# = Dictionary
-#
-# The Dictionary class is a Hash that preserves order.
-# So it has some array-like extensions also. By defualt
-# a Dictionary object preserves insertion order, but any
-# order can be specified including alphabetical key order.
-#
-# == Usage
-#
-# Just require this file and use Dictionary instead of Hash.
-#
-#   # You can do simply
-#   hsh = Dictionary.new
-#   hsh['z'] = 1
-#   hsh['a'] = 2
-#   hsh['c'] = 3
-#   p hsh.keys     #=> ['z','a','c']
-#
-#   # or using Dictionary[] method
-#   hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
-#   p hsh.keys     #=> ['z','a','c']
-#
-#   # but this don't preserve order
-#   hsh = Dictionary['z'=>1, 'a'=>2, 'c'=>3]
-#   p hsh.keys     #=> ['a','c','z']
-#
-#   # Dictionary has useful extensions: push, pop and unshift
-#   p hsh.push('to_end', 15)       #=> true, key added
-#   p hsh.push('to_end', 30)       #=> false, already - nothing happen
-#   p hsh.unshift('to_begin', 50)  #=> true, key added
-#   p hsh.unshift('to_begin', 60)  #=> false, already - nothing happen
-#   p hsh.keys                     #=> ["to_begin", "a", "c", "z", "to_end"]
-#   p hsh.pop                      #=> ["to_end", 15], if nothing remains, return nil
-#   p hsh.keys                     #=> ["to_begin", "a", "c", "z"]
-#   p hsh.shift                    #=> ["to_begin", 30], if nothing remains, return nil
+# = Dictionary.rb
 #
-# == Usage Notes
+# Copyright (c) 2005, 2009 Jan Molic, Thomas Sawyer
 #
-# * You can use #order_by to set internal sort order.
-# * #<< takes a two element [k,v] array and inserts.
-# * Use ::auto which creates Dictionay sub-entries as needed.
-# * And ::alpha which creates a new Dictionary sorted by key.
+# Ruby License
 #
-# == Authors
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
 #
-# * Jan Molic
-# * Thomas Sawyer
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
 #
 # == Acknowledgments
 #
@@ -52,26 +17,7 @@
 # * Jeff Sharpe    (reverse and reverse!)
 # * Thomas Leitner (has_key? and key?)
 #
-# Originally ported from OrderHash 2.0, Copyright (c) 2005 jan molic
-#
-# == History
-#
-# * 2007.10.31 trans
-# ** Fixed initialize so the constructor blocks correctly effected dictionary rather then just the internal hash.
-#
-# == Copying
-#
-# Copyright (c) 2005 Jan Molic, Thomas Sawyer
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
-
+# Ported from OrderHash 2.0, Copyright (c) 2005 Jan Molic
 
 # = Dictionary
 #

data/lib/more/facets/erb.rb

@@ -0,0 +1,63 @@
+require 'erb'
+
+# = OpenTemplate
+#
+# The Erb OpenTemplate provides a quick and convenient way to
+# create a clean rendering space with the desired responses.
+#
+# TODO: This might make a good addon library. Just add 
+# require 'erb' to the erb_result method? Call it OpenResponse?
+#
+class ERB::OpenTemplate
+
+  # TODO: Should we do this? Perhaps offer it as an option?
+  instance_methods.each do |m|
+    undef_method(m) unless /^(__|instance_|inspect$|extend$)/ =~ m.to_s
+  end
+
+  #
+  def initialize(*objs_ioc)
+    ioc = Hash===objs_ioc.last ? objs_ioc.pop : {}
+    objs = objs_ioc
+
+    mods = []
+
+    objs.each do |obj|
+      mod = Module.new
+      obj.public_methods.each do |m|
+        mod.module_eval do
+          define_method(m){ |*a,&b| obj.__send__(m,*a,&b) }
+        end
+      end
+      mods << mod
+    end
+
+    mod = Module.new
+    ioc.each do |k,v|
+      mod.module_eval do
+        define_method(k){ v }
+      end
+    end
+    mods << mod
+
+    extend *mods.reverse
+  end
+
+  #
+  def erb_result(str)
+    ERB.new(str).result(binding)
+  end
+
+  #
+  #def method_missing(sym, *args, &block)
+  #  #if @ioc.key?(sym)
+  #  #  @ioc[sym]
+  #  if obj = @objs.find{ |o| o.respond_to?(sym) }
+  #    obj.__send__(sym, *args, &block)
+  #  else
+  #    super
+  #  end
+  #end
+
+end
+

data/lib/more/facets/filelist.rb

@@ -113,14 +113,14 @@ class FileList
 
   # List of array methods (that are not in +Object+) that need to be
   # delegated.
-  ARRAY_METHODS = Array.instance_methods - Object.instance_methods
+  ARRAY_METHODS = (Array.instance_methods - Object.instance_methods).map(&:to_sym)
 
   # List of additional methods that must be delegated.
-  MUST_DEFINE = %w[to_a inspect]
+  MUST_DEFINE = %w[to_a inspect].map(&:to_sym)
 
   # 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 *]
+  MUST_NOT_DEFINE = %w[to_a to_ary partition *].map(&:to_sym)
 
   # List of delegated methods that return new array values which
   # need wrapping.
@@ -128,7 +128,7 @@ class FileList
     map collect sort sort_by select find_all reject grep
     compact flatten uniq values_at
     + - & |
-  ]
+  ].map(&:to_sym)
 
   DELEGATING_METHODS = (ARRAY_METHODS + MUST_DEFINE - MUST_NOT_DEFINE).sort.uniq
 
@@ -486,7 +486,7 @@ end # FileList
       Dir.chdir File.join( $TESTDIR, 'filelist' ) do
         fl = FileList.new
         fl.include('*')
-        assert_equal( ['testfile.txt', 'testfile2.txt'], fl.to_a )
+        assert_equal( ['testfile2.txt', 'testfile.txt'], fl.to_a )
         fl.exclude('*2.txt')
         assert_equal( ['testfile.txt'], fl.to_a )
       end

data/lib/more/facets/hashbuilder.rb

@@ -0,0 +1,101 @@
+# TITLE:
+#
+#   HashBuilder
+#
+# DESCRIPTION:
+#
+#   Build a hash programmatically via missing method calls.
+#
+# COPYRIGHT:
+#
+#   Copyright (c) 2006 Thomas Sawyer
+#
+# LICENSE:
+#
+#   Ruby License
+#
+#   This module is free software. You may use, modify, and/or redistribute this
+#   software under the same terms as Ruby.
+#
+#   This program is distributed in the hope that it will be useful, but WITHOUT
+#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+#   FOR A PARTICULAR PURPOSE.
+#
+# AUTHORS:
+#
+#   - Thomas Sawyer
+#
+# TODO:
+#
+#   - Use BuildingBlock ?
+
+
+# = HashBuilder
+#
+# Build a hash programmatically via a fluent DSL-like syntax.
+# In other words, this uses #method_missing to buld the hash.
+
+class HashBuilder
+
+  # Privatize a few Kernel methods that are most likely to clash,
+  # but arn't essential here. TODO Maybe more in this context?
+
+  alias :__class__ :class
+
+  private *instance_methods.select{ |m| /^__/ !~ m.to_s }
+
+  def self.load( blockstr, &block )
+    new( blockstr, &block ).to_h
+  end
+
+  #def self.build( blockstr=nil, &block )
+  #  self.new.build( blockstr, &block ).to_h
+  #end
+
+  def initialize( blockstr=nil, &block )
+    @hash = {}
+    @flag = {}
+    build!( blockstr, &block )
+  end
+
+  def build!( blockstr=nil, &block )
+    raise "both string and block given" if blockstr and block_given?
+    if blockstr
+      instance_eval blockstr
+    else
+      instance_eval &block
+    end
+    self  # or to_h ?
+  end
+
+  def to_h ; @hash ; end
+
+  def method_missing( sym, *args, &block )
+    sym = sym.to_s.downcase.chomp('=')
+
+    if @hash.key?(sym)
+      unless @flag[sym]
+        @hash[sym] = [ @hash[sym] ]
+        @flag[sym] = true
+      end
+      if block_given?
+        @hash[sym] << self.__class__.new( &block ).to_h
+      else
+        @hash[sym] << args[0]
+      end
+    else
+      if block_given?
+        @hash[sym] = self.__class__.new( &block ).to_h
+      else
+        @hash[sym] = args[0]
+      end
+    end
+
+  end
+
+end
+
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2006 Thomas Sawyer
+# License::   Ruby License

data/lib/more/facets/inheritor.rb

@@ -28,12 +28,16 @@ class Object
   #
   # Create an inheritor "class attribute".
   #
-  # Inheritor providse a means to store and inherit data via
-  # the class heirarchy. An inheritor creates two methods
-  # one named after the key that provides a reader. And one
-  # named after key! which provides the writer. (Because of
-  # the unique nature of inheritor the reader and writer
-  # can't be the same method.)
+  # Inheritor providse a means to store and inherit data via the class
+  # heirarchy. An inheritor creates two methods one named after the key
+  # that provides a reader. And one named after key! which provides the
+  # writer. (Because of the unique nature of inheritor the reader and
+  # writer can't be the same method.)
+  #
+  # The first argument is the inheritor's name. The second argument
+  # is the archtype object. This object must be duplicable (via #dup).
+  # The last argument is either the symbolic operator/method or a block
+  # that specifies how one hierarchical level "integrates" with the next.
   #
   #   class X
   #     inheritor :foo, [], :+
@@ -50,59 +54,46 @@ class Object
   #   X.x => [:a]
   #   Y.x => [:a, :b]
   #
-  # It is interesting to note that the only reason inheritor is needed at all
-  # is becuase Ruby does not allow modules to be "inherited" at the class-level,
-  # or conversely that the class-level is not a module instead.
-  # Otherwise using #super at the class-level would suffice.
+  # It is interesting to note that the only reason inheritor is needed
+  # at all is becuase Ruby does not allow modules to be "inherited" at
+  # the class-level, or conversely that the class-level is not a module
+  # instead. Otherwise using #super at the class-level would suffice.
   #
-  def inheritor(key, obj, op=nil)
+  # NOTE: Adding an inheritor directly to Module or Class will probably
+  # not do what is expected. Thankfully that usecase is likely a YAGNI,
+  # but in anycase it is even more likely that it is not possible with
+  # this code.
 
-    # inhertiance operator
-    op = op ? op.to_sym : :add  #NOTE: why #add ?
+  def inheritor(key, obj, op=nil, &fop)
+    raise ArgumentError if op && fop
 
-    # inheritor store a this level
-    instance_variable_set("@#{key}", obj)
+    if !fop
+      op  = op ? op.to_sym : :+
+      fop = lambda{ |o, x| o.__send__(op, x) }
+    end
 
-    #base = self
-    deflambda = lambda do
+    #(class << self; self; end).module_eval do
+    class_extend do
 
-      define_method( key ) do
-        defined?(super) ? super.__send__(op,obj) : obj.dup
+      define_method(key) do
+        ancestors.reverse.inject(obj.dup) do |o, a|
+          if a.respond_to?("#{key}!")
+            fop.call(o, a.__send__("#{key}!"))
+          else
+            o
+          end
+        end
       end
 
-      define_method( "#{key}!" ) do
+      define_method("#{key}!") do
         if instance_variable_defined?("@#{key}")
           instance_variable_get("@#{key}")
         else
-          inheritor(key, obj.class.new, op)
+          instance_variable_set("@#{key}", obj.dup)
         end
-        # -- old version --
-        #if instance_variables.include?("@#{key}")
-        #  instance_variable_get("@#{key}")
-        #else
-        #  if self != base
-        #    inheritor( key, obj.class.new, op )
-        #  end
-        #end
       end
-    end
-
-    # TODO: This is an issue if you try to include a module
-    #       into Module or Class itself. How to fix?
 
-    # if the object is a module (not a class or other object)
-    if self == Class or self == Module
-      class_eval(&deflambda)
-    elsif is_a?(Class)
-      (class << self; self; end).class_eval(&deflambda)
-    elsif is_a?(Module)
-      #class_inherit &deflambda
-      extend class_extend(&deflambda)
-    else # other Object
-      (class << self; self; end).class_eval(&deflambda)
     end
-
-    obj
   end
 
 end