facets 2.6.0 → 2.7.0

data/lib/more/facets/inheritor.rb

@@ -20,7 +20,7 @@
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.
 
-require 'facets/class_extension'
+require 'facets/class_extend'
 
 class Object
 
@@ -97,7 +97,7 @@ class Object
       (class << self; self; end).class_eval(&deflambda)
     elsif is_a?(Module)
       #class_inherit &deflambda
-      extend class_extension(&deflambda)
+      extend class_extend(&deflambda)
     else # other Object
       (class << self; self; end).class_eval(&deflambda)
     end

data/lib/more/facets/instance_eval.rb

@@ -0,0 +1,50 @@
+require 'facets/functor'
+
+class Object
+
+  # Access private internals of an object with a fluid notation.
+  #
+  #   class X
+  #     attr :a
+  #     private :a
+  #     def initialize
+  #       @a = 1
+  #     end
+  #   end
+  #
+  #   x = X.new
+  #   p x.instance_eval.a  #=> 1
+  #   p x.a                #=> Error
+  #
+  # A useful example might include adding accessors to a metaclass.
+  #
+  #   class X
+  #     metaclass.instance_eval.attr :x
+  #   end
+  #
+  # This method is called #instance to go along with methods
+  # that provide similar access, such as #instance_variables
+  # and #instance_eval. In fact, one could argue this would be
+  # a good return value of #instance_eval is no block is given.
+  #
+  # This method was once called #pry and #privy.
+  #
+  # TODO: Will only support calls with blocks as of Ruby 1.9+.
+  #
+  def instance_eval(&block)
+    return super if block
+    @_instance_eval ||= Functor.new do |op, *a|
+      instance_eval{ send(op, *a) }
+    end
+  end
+
+  # TODO for Ruby 1.9
+  #def instance_eval(&block)
+  #  return super if block
+  #  @_instance_functor ||= Functor.new do |op, *a, &b|
+  #    fcall(op, *a, &b)
+  #  end
+  #end
+
+end
+

data/lib/more/facets/instance_function.rb

@@ -0,0 +1,78 @@
+class Module
+  # Converts module methods into instance methods such that the first parameter
+  # is passed +self+. This promotes DRY programming when wishing to offer both
+  # inheritable and module callable procedures.
+  #
+  # This method is modeled after +module_function+ which essentially has the the
+  # opposite effect. Due to implementation limitations, this must use the callback
+  # #singleton_method_added to emulate +module_function+ when no method names
+  # are given.
+  #
+  #   module MyModule
+  #     instance_function
+  #
+  #     def self.jumble( obj, arg )
+  #       obj + arg
+  #     end
+  #   end
+  #
+  #   class String
+  #     include MyModule
+  #   end
+  #
+  #   MyModule.jumble( "Try", "Me" )  #=> "TryMe"
+  #
+  #   "Try".jumble( "Me" )            #=> 'TryMe'
+  #
+  # Note: This used to be a module called PromoteSelf and later Instantize,
+  # before becoming a method.
+  #
+  def instance_function(*meths)
+    if meths.empty?
+      extend InstanceFunction
+    else
+      meths.each do |meth|
+        class_eval %{
+          def #{meth}(*args)
+            #{self.name}.#{meth}(self,*args)
+          end
+        }
+      end
+    end
+  end
+
+  module InstanceFunction #:nodoc
+    #
+    def singleton_method_added(meth)
+      module_eval %{
+        def #{meth}(*args)
+          #{self.name}.#{meth}(self,*args)
+        end
+      }
+      #self.class_eval d
+      super(meth)
+    end
+  end
+
+end #class Module
+
+=begin
+module Instantize
+
+  def self.append_features(mod)
+    mod.extend self
+  end
+
+  def singleton_method_added( meth )
+    d = %{
+      def #{meth}(*args)
+        #{self.name}.#{meth}(self,*args)
+      end
+    }
+    self.class_eval d
+    super(meth)
+  end
+
+end
+=end
+

data/lib/more/facets/main.rb

@@ -1,30 +1,35 @@
-# = Main as Module
+# Main as Module
+# Copyright (c) 2006 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.
+#
+# == Description
 #
 # Main, ie. the top-level object, is not fully in-sync with
 # Module. So, certain methods like #define_method do not work.
 # This library fixes this.
 #
 # Techinally it is this authors opinion that the top-level object
-# most likely be better-off as a self-extended module, and
-# method defined in it do not automatically get added to the
+# most likely would be better-off as a self-extended module, and
+# methods defined in it do not automatically get added to the
 # Object class.
 #
-# == Copying
+# On the other hand. It is probably best to never use the toplevel
+# except as a jumping in point to youre own namespace.
 #
-# Copyright (c) 2006 Thomas Sawyer
-#
-# Ruby License
+# == Note
 #
-# 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.
+# Noen of this would be needed if Main were just a self extended module.
 #
-# == Authors
+#  == Authors
 #
-# * Thomas Sawyer
+#  * Thomas Sawyer
 
 public
 

data/lib/more/facets/memoize.rb

@@ -1,113 +1 @@
-# = Memoize
-#
-# Directive for making your functions faster by trading
-# space for time. When you "memoize" a method/function
-# its results are cached so that later calls with the
-# same arguments returns results in the cache instead
-# of recalculating them.
-#
-#   class T
-#     def initialize(a)
-#       @a = a
-#     end
-#     def a
-#       "#{@a ^ 3 + 4}"
-#     end
-#     memoize :a
-#   end
-#
-#   t = T.new(1)
-#   t.a.__id__ == t.a.__id__  #=> true
-#
-# == Authors
-#
-# * trans
-# * rtb
-#
-# == Copying
-#
-# Copyright (c) 2005 Robert Feldt
-#
-# 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.
-
-#require 'facets/memoizer'
-
-#
-class Module
-
-  # Directive for making your functions faster by trading
-  # space for time. When you "memoize" a method/function
-  # its results are cached so that later calls with the
-  # same arguments returns results in the cache instead
-  # of recalculating them.
-  #
-  #   class T
-  #     def initialize(a)
-  #       @a = a
-  #     end
-  #     def a
-  #       "#{@a ^ 3 + 4}"
-  #     end
-  #     memoize :a
-  #   end
-  #
-  #   t = T.new
-  #   t.a.__id__ == t.a.__id__  #=> true
-  #
-  def memoize(*meths)
-    meths.each do |meth|
-      old = instance_method(meth)
-      new = proc do |*args|
-        mc = ((@_MEMOIZE_CACHE ||= {})[meth] ||= {})
-        if mc.has_key? args
-          mc[args]
-        else
-          mc[args] = old.bind(self).call(*args)
-        end
-      end
-      send(:define_method, meth, &new)
-    end
-  end
-
-end
-
-# This allows memoize to work in main and instance scope too.
-def memoize(*args)
-  Object.memoize(*args)
-end
-
-module Kernel #:nodoc:
-
-  # Object#cache is essentially like Module#memoize except
-  # it can also be used on singleton/eigen methods.
-  # OTOH, memoize's implementation is arguably better for it's
-  # use of #bind instead of #alias. Eventually the two implmenations
-  # should be reconciled with a single implementation.
-  #
-  def cache m = nil
-    if m
-      (Module === self ? self : (class << self; self; end)).module_eval <<-code
-        alias_method '__#{ m }__', '#{ m }'
-        def #{ m }(*__a__,&__b__)
-          c = cache['#{ m }']
-          k = [__a__,__b__]
-          if c.has_key? k
-            c[k]
-          else
-            c[k] = __#{ m }__(*__a__,&__b__)
-          end
-        end
-      code
-    end
-    @cache ||= Hash::new{|h,k| h[k]={}}
-  end
-
-end
-
+require 'facets/once'

data/lib/more/facets/module/attr.rb

@@ -0,0 +1,83 @@
+class Module
+
+  # Create a toggle attribute. This creates two methods for
+  # each given name. One is a form of tester and the other
+  # is used to toggle the value.
+  #
+  #   attr_accessor! :a
+  #
+  # is equivalent to
+  #
+  #   def a?
+  #     @a
+  #   end
+  #
+  #   def a!(value=true)
+  #     @a = value
+  #     self
+  #   end
+  #
+  # CREDIT: Trans
+
+  def attr_switch_accessor(*args)
+    attr_reader!(*args) + attr_writer!(*args)
+  end
+
+  alias_method :attr_toggler,  :attr_accessor!
+
+  # Create aliases for flag accessors.
+  #
+  # CREDIT: Trans
+
+  def alias_accessor!(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method("#{name}?", "#{orig}?")
+      alias_method("#{name}!", "#{orig}!")
+    end
+  end
+  alias_method :alias_switcher, :alias_accessor!
+  alias_method :alias_toggler,  :alias_accessor!
+
+  # Create a flaggable attribute. This creates a single methods
+  # used to set an attribute to "true".
+  #
+  #   attr_writer! :a
+  #
+  # is equivalent to
+  #
+  #   def a!(value=true)
+  #     @a = value
+  #     self
+  #   end
+  #
+  def attr_writer!(*args)
+    code, made = '', []
+    args.each do |a|
+      code << %{
+        def #{a}!(value=true)
+          @#{a} = value
+          self
+        end
+      }
+      made << "#{a}!".to_sym
+    end
+    module_eval code
+    made
+  end
+
+  # Create aliases for flag writer.
+  #
+  # CREDIT: Trans
+
+  def alias_writer!(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method("#{name}!", "#{orig}!")
+    end
+  end
+
+end
+

data/lib/more/facets/module/attr_tester.rb

@@ -0,0 +1,44 @@
+class Module
+
+  # Create an tester attribute. This creates a single method
+  # used to test the attribute for truth.
+  #
+  #   attr_tester :a
+  #
+  # is equivalent to
+  #
+  #   def a?
+  #     @a ? true : @a
+  #   end
+  #
+  def attr_tester(*args)
+    code, made = '', []
+    args.each do |a|
+      code << %{
+        def #{a}?(truth=nil)
+          @#{a} ? truth || @#{a} : @#{a}
+        end
+      }
+      made << "#{a}?".to_sym
+    end
+    module_eval code
+    made
+  end
+
+  alias_method :attr_reader?, :attr_tester
+
+  # Create aliases for flag reader.
+  #
+  # CREDIT: Trans
+
+  def alias_tester(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method("#{name}?", "#{orig}?")
+    end
+  end
+  alias_method :alias_reader?, :alias_tester
+
+end
+

data/lib/more/facets/module/attr_toggler.rb

@@ -0,0 +1,59 @@
+require 'facets/attr_tester'
+
+class Module
+
+  # Create a flaggable attribute. This creates a single methods
+  # used to set an attribute to "true".
+  #
+  #   attr_toggler :a
+  #
+  # is equivalent to
+  #
+  #   def a?
+  #     @a ? true : @a
+  #   end
+  #
+  #   def a!(value=Exception)
+  #     if Exception
+  #       @a = @a ? false : true
+  #     else 
+  #       @a = value
+  #     end
+  #     self
+  #   end
+  #
+  def attr_toggler(*args)
+    code, made = '', []
+    args.each do |a|
+      code << %{
+        def #{a}!(value=Excception)
+          if Exception
+            @a = @a ? false : true
+          else 
+            @a = value
+          end
+          self
+        end
+      }
+      made << "#{a}!".to_sym
+    end
+    module_eval code
+    made.concat(attr_tester(*args))
+    made
+  end
+
+  # Create aliases for attr_toggler.
+  #
+  # CREDIT: Trans
+
+  def alias_toggler(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method("#{name}!", "#{orig}!")
+      alias_method("#{name}?", "#{orig}?")
+    end
+  end
+
+end
+