facets 2.9.3 → 3.0.0

data/lib/standard/facets/math/tau.rb

@@ -0,0 +1,5 @@
+module Math
+  # See http://tauday.com/tau-manifesto
+  TAU = 2 * PI
+end
+

data/lib/standard/facets/math/tgamma.rb

@@ -4,7 +4,7 @@ module Math
 
   # Exp of LGamma.
   def self.tgamma(x)
-    exp(lgamma(x))
+    exp(lngamma(x)) #exp(log(gamma(x).abs)
   end
 
 end

data/lib/standard/facets/memoizer.rb

@@ -0,0 +1,63 @@
+# Memoizer wraps objects to provide cached method calls.
+#
+#   class X
+#     def initialize ; @tick = 0 ; end
+#     def tick; @tick + 1; end
+#     def memo; @memo ||= Memoizer.new(self) ; end
+#   end
+#
+#   x = X.new
+#   x.tick       #=> 1
+#   x.memo.tick  #=> 2
+#   x.tick       #=> 3
+#   x.memo.tick  #=> 2
+#   x.tick       #=> 4
+#   x.memo.tick  #=> 2
+#
+# You can also use to cache collections of objects to gain code speed ups.
+#
+#   points = points.collect{|point| Memoizer.cache(point)}
+#
+# After our algorithm has finished using points, we want to get rid of
+# these Memoizer objects. That's easy:
+#
+#    points = points.collect{|point| point.__self__ }
+#
+# Or if you prefer (it is ever so slightly safer):
+#
+#    points = points.collect{|point| Memoizer.uncache(point)}
+#
+# Memoizer is the work of Erik Veenstra
+#
+# Copyright (c) 2006 Erik Veenstra
+#
+# See http://javathink.blogspot.com/2008/09/what-is-memoizer-and-why-should-you.html
+
+class Memoizer
+
+  #private :class, :clone, :display, :type, :method, :to_a, :to_s
+  private *instance_methods(true).select{ |m| m.to_s !~ /^__/ }
+
+  def initialize(object)
+    @self  = object
+    @cache = {}
+  end
+
+  def __self__ ; @self ; end
+
+  # Not thread-safe! Speed is important in caches... ;]
+  def method_missing(method_name, *args, &block)
+    @cache[[method_name, args, block]] ||= @self.__send__(method_name, *args, &block)
+  end
+
+  #def self; @self; end
+
+  def self.cache(object)
+    new(object)
+  end
+
+  def self.uncache(cached_object)
+    cached_object.instance_variable_get('@self')
+  end
+
+end

data/lib/standard/facets/ostruct.rb

@@ -1,83 +1,19 @@
 require 'ostruct'
+require 'facets/ostruct/initialize'
+require 'facets/ostruct/to_h'
+require 'facets/ostruct/merge'
+require 'facets/ostruct/each'
+require 'facets/ostruct/to_ostruct'
+require 'facets/ostruct/op_fetch'
+require 'facets/ostruct/op_store'
 
 class OpenStruct
 
-  # Allows the initialization of an OpenStruct with a setter block:
-  #
-  #   person = OpenStruct.new do |o|
-  #     o.name    = 'John Smith'
-  #     o.gender  = :M
-  #     o.age     = 71
-  #   end
-  #
-  # You can still provide a hash for initialization purposes, and even combine
-  # the two approaches if you wish.
-  #
-  #   person = OpenStruct.new(:name => 'John Smith', :age => 31) do |p|
-  #     p.gender = :M
-  #   end
-  #
-  # Alternatively you can provide a default block:
-  #
-  #   stuff = OpenStruct.new{ |o,k| o[k] = [] }
-  #   stuff.place << :a
-  #   stuff.place << :b
-  #   stuff.place #=> [:a, :b]
-  #
-  # A setter block versus a defualt block is determined by the arity of
-  # the block. You can not provide both at the same time.
-  #
-  # CREDIT: Noah Gibbs, Gavin Sinclair
-  def initialize(hash=nil, &block)
-    if block && block.arity==2
-      @table = Hash.new(&block)
-    else
-      @table = {}
-    end
-    if hash
-      for k,v in hash
-        @table[k.to_sym] = v
-        new_ostruct_member(k)
-      end
-    end
-    if block && block.arity==1
-      yield self
-    end
-  end
-
-  #
-  def each(&blk)
-    @table.each(&blk)
-  end
-
-  #
-  def to_h
-    @table.dup
-  end
-
-  # Access a value in the OpenStruct by key, like a Hash.
-  # This increases OpenStruct's "duckiness".
-  #
-  #   o = OpenStruct.new
-  #   o.t = 4
-  #   o['t']  #=> 4
-  #
-  def [](key)
-    key = key.to_sym unless key.is_a?(Symbol)
-    @table[key]
-  end
-
-  # Set a value in the OpenStruct by key, like a Hash.
-  #
-  #   o = OpenStruct.new
-  #   o['t'] = 4
-  #   o.t  #=> 4
-  #
-  def []=(key,val)
-    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
-    key = key.to_sym unless key.is_a?(Symbol)
-    @table[key]=val
-  end
+  #--
+  # TO BE DEPRECATED
+  # Must consider that accessing instance_delegate instead can be dangerous.
+  # Might we us a Functor to ensure the table keys are always symbols?
+  #++
 
   # Provides access to an OpenStruct's inner table.
   #
@@ -87,11 +23,14 @@ class OpenStruct
   #   o.instance_delegate.map { |k, v| "#{k} #{v}" }
   #   #=> ["a 1", "b 2"]
   #
+  # @deprecated Use `#marshal_dump` instead.
+  #
   def instance_delegate
+    warn "OpenStruct#instance_delegate is deprecated, use #marshal_dump instead."
     @table
   end
 
-  #
+  # @deprecated Use `#marshal_dump` instead.
   alias ostruct_delegate instance_delegate
 
   # Insert/update hash data on the fly.
@@ -100,111 +39,53 @@ class OpenStruct
   #   o.ostruct_update(:a => 2)
   #   o.a  #=> 2
   #
-  def ostruct_update(other)
-    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
-    ##other = other.to_hash  #to_h ?
-    for k,v in other
-      @table[k.to_sym] = v
-    end
-    self
-  end
-
-  # Merge hash data creating a new OpenStruct object.
-  #
-  #   o = OpenStruct.new
-  #   x = o.ostruct_merge(:a => 2)
-  #   x.a  #=> 2
+  # @deprecated Use #merge! instead.
   #
-  def ostruct_merge(other)
-    o = dup
-    o.ostruct_update(other)
-    o
+  def ostruct_update(other)
+    warn "OpenSrtuct#ostruct_update has been deprecated. Use #merge! instead."
+    merge!(other)
   end
 
-  #--
-  # TO BE DEPRECATED
-  # Must consider that accessing instance_delegate instead can be dangerous.
-  # Might we us a Functor to ensure the table keys are always symbols?
-  #++
-
   # Insert/update hash data on the fly.
   #
   #   o = OpenStruct.new
   #   o.ostruct_update(:a => 2)
   #   o.a  #=> 2
   #
+  # @deprecated Use #merge! instead.
+  #
   def __update__(other)
-    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
-    ##other = other.to_hash #to_h?
-    for k,v in other
-      @table[k.to_sym] = v
-    end
-    self
+    raise NameError, "OpenSrtuct#__update__ has been deprecated. Use #merge! instead."
+    #merge!(other)
   end
 
+  # TODO: How to handle regular merge, since it lacks punctuation to make it safe.
+  #       Maybe `#update!`? Kind of odd but could work.
+
   # Merge hash data creating a new OpenStruct object.
   #
   #   o = OpenStruct.new
   #   x = o.ostruct_merge(:a => 2)
   #   x.a  #=> 2
   #
-  def __merge__(other)
+  def ostruct_merge(other)
     o = dup
-    o.__update__(other)
+    o.merge!(other)
     o
   end
 
+  # Merge hash data creating a new OpenStruct object.
   #
-  def to_ostruct
-    self
-  end
-
-end
-
-
-class Hash
-
-  # Turns a hash into a generic object using an OpenStruct.
-  #
-  #   o = {'a' => 1}.to_ostruct
-  #   o.a  #=> 1
-  #
-  def to_ostruct
-    OpenStruct.new(self)
-  end
-
-  # Like to_ostruct but recusively objectifies all hash elements as well.
-  #
-  #   o = {'a' => { 'b' => 1 }}.to_ostruct_recurse
-  #   o.a.b  #=> 1
-  #
-  # The +exclude+ parameter is used internally to prevent infinite
-  # recursion and is not intended to be utilized by the end-user.
-  # But for more advance use, if there is a particular subhash you
-  # would like to prevent from being converted to an OpoenStruct
-  # then include it in the +exclude+ hash referencing itself. Eg.
-  #
-  #   h = { 'a' => { 'b' => 1 } }
-  #   o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
-  #   o.a['b']  #=> 1
+  #   o = OpenStruct.new
+  #   x = o.__merge__(:a => 2)
+  #   x.a  #=> 2
   #
-  # CREDIT: Alison Rowland, Jamie Macey, Mat Schaffer
-  def to_ostruct_recurse(exclude={})
-    return exclude[self] if exclude.key?( self )
-    o = exclude[self] = OpenStruct.new
-    h = self.dup
-    each_pair do |k,v|
-      h[k] = v.to_ostruct_recurse( exclude ) if v.respond_to?(:to_ostruct_recurse)
-    end
-    o.__update__(h)
+  def __merge__(other)
+    o = dup
+    o.merge!(other)
+    o
   end
-end
 
-class NilClass
-  # Create an empty OpenStruct object.
-  def to_ostruct
-    OpenStruct.new
-  end
 end
 
 # Copyright (c) 2005 Thomas Sawyer (Ruby License)

data/lib/standard/facets/ostruct/each.rb

@@ -0,0 +1,11 @@
+require 'ostruct'
+
+class OpenStruct
+
+  # Iterate over key-value pairs.
+  #
+  def each(&blk)
+    @table.each(&blk)
+  end
+
+end

data/lib/standard/facets/ostruct/initialize.rb

@@ -0,0 +1,48 @@
+require 'ostruct'
+
+class OpenStruct
+
+  # Allows the initialization of an OpenStruct with a setter block:
+  #
+  #   person = OpenStruct.new do |o|
+  #     o.name    = 'John Smith'
+  #     o.gender  = :M
+  #     o.age     = 71
+  #   end
+  #
+  # You can still provide a hash for initialization purposes, and even combine
+  # the two approaches if you wish.
+  #
+  #   person = OpenStruct.new(:name => 'John Smith', :age => 31) do |p|
+  #     p.gender = :M
+  #   end
+  #
+  # Alternatively you can provide a default block:
+  #
+  #   stuff = OpenStruct.new{ |o,k| o[k] = [] }
+  #   stuff.place << :a
+  #   stuff.place << :b
+  #   stuff.place #=> [:a, :b]
+  #
+  # A setter block versus a defualt block is determined by the arity of
+  # the block. You cannot provide both at the same time.
+  #
+  # CREDIT: Noah Gibbs, Gavin Sinclair
+  def initialize(hash=nil, &block)
+    if block && block.arity==2
+      @table = Hash.new(&block)
+    else
+      @table = {}
+    end
+    if hash
+      for k,v in hash
+        @table[k.to_sym] = v
+        new_ostruct_member(k)
+      end
+    end
+    if block && block.arity==1
+      yield self
+    end
+  end
+
+end

data/lib/standard/facets/ostruct/merge.rb

@@ -0,0 +1,21 @@
+require 'ostruct'
+
+class OpenStruct
+
+  # Insert/update hash data on the fly.
+  #
+  #   o = OpenStruct.new
+  #   o.merge!(:a => 2)
+  #   o.a  #=> 2
+  #
+  def merge!(other)
+    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
+    ##other = other.to_hash #to_h?
+    for k,v in other
+      @table[k.to_sym] = v
+    end
+    self
+  end
+
+end
+

data/lib/standard/facets/ostruct/op_fetch.rb

@@ -0,0 +1,29 @@
+require 'ostruct'
+
+class OpenStruct
+
+  # Access a value in the OpenStruct by key, like a Hash.
+  # This increases OpenStruct's "duckiness".
+  #
+  #   o = OpenStruct.new
+  #   o.t = 4
+  #   o['t']  #=> 4
+  #
+  def [](key)
+    key = key.to_sym unless key.is_a?(Symbol)
+    @table[key]
+  end
+
+  # Set a value in the OpenStruct by key, like a Hash.
+  #
+  #   o = OpenStruct.new
+  #   o['t'] = 4
+  #   o.t  #=> 4
+  #
+  def []=(key,val)
+    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
+    key = key.to_sym unless key.is_a?(Symbol)
+    @table[key]=val
+  end
+
+end

data/lib/standard/facets/ostruct/op_store.rb

@@ -0,0 +1 @@
+require 'facets/ostruct/op_fetch'

data/lib/standard/facets/ostruct/to_h.rb

@@ -0,0 +1,10 @@
+require 'ostruct'
+
+class OpenStruct
+
+  #
+  def to_h
+    @table.dup
+  end
+
+end