facets 1.4.0 → 1.4.1

data/lib/facet/enumerable/mode.rb

@@ -0,0 +1 @@
+require 'facets/core/enumerable/mode.rb'

data/lib/facets/core/enumerable/mode.rb

@@ -0,0 +1,13 @@
+
+module Enumerable
+
+  # In Statistics mode is the value that occurs most
+  # frequently in a given set of data.
+
+  def mode
+    count = Hash.new(0)
+    each {|x| count[x] += 1 }
+    count.sort_by{|k,v|v}.last[0]
+  end
+
+end

data/lib/facets/core/hash/to_ostruct.rb

@@ -8,7 +8,7 @@ class Hash
   #   o.a  #=> 1
   #
   def to_ostruct
-    ::OpenStruct.new( self )
+    OpenStruct.new( self )
   end
 
 end

data/lib/facets/core/hash/to_ostruct_recurse.rb

@@ -1,19 +1,32 @@
 
 require 'ostruct'
+require 'facets/core/ostruct/__update__'
 
 class Hash
 
   # Like to_ostruct but recusively objectifies all hash elements as well.
   #
-  #   o = { 'a' => { 'b' => 1 } }.to_ostruct_recurse
-  #   o.a.b  #=> 1
+  #     o = { 'a' => { 'b' => 1 } }.to_ostruct_recurse
+  #     o.a.b  #=> 1
   #
-  def to_ostruct_recurse
-    o = self.dup
+  # 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
+  #
+  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|
-      o[k] = v.to_ostruct_recurse if v.respond_to?( :to_ostruct_recurse )
+      h[k] = v.to_ostruct_recurse( exclude ) if v.respond_to?( :to_ostruct_recurse )
     end
-    ::OpenStruct.new( o )
+    o.__update__( h )
   end
 
 end
@@ -40,6 +53,20 @@ end
       assert_equal(  a[:c][:x], ao.c.x )
     end
 
+    def test_to_ostruct_recurse_with_recursion
+      a = {}
+      a[:a] = a
+      ao = a.to_ostruct_recurse
+      assert_equal( ao, ao.a )
+    end
+
+    def test_to_ostruct_advanced
+      h = { 'a' => { 'b' => 1 } }
+      o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
+      assert_equal( 1, o.a['b'] )
+      assert( Hash === o.a )
+    end
+
   end
 
 =end

data/lib/facets/core/ostruct/__update__.rb

@@ -16,6 +16,7 @@ class OpenStruct
     for k,v in hash
       @table[k.to_sym] = v
     end
+    self
   end
 
 end

data/lib/facets/more/binaryreader.rb

@@ -79,7 +79,7 @@ module BinaryReader
 
   # == 8 bit
 
-  # no byteorder for 8 bit! 
+  # no byteorder for 8 bit!
 
   def read_word8
     ru(1, 'C')
@@ -157,7 +157,7 @@ module BinaryReader
 
   alias read_uint8 read_word8
 
-  # add some short-cut functions 
+  # add some short-cut functions
   %w(word16 int16 word32 int32).each do |typ|
     eval %{
       alias read_#{typ}_network read_#{typ}_big
@@ -166,7 +166,7 @@ module BinaryReader
         when ByteOrder::Native  then read_#{typ}_native
         when ByteOrder::Little  then read_#{typ}_little
         when ByteOrder::Network then read_#{typ}_network
-        else raise ArgumentError 
+        else raise ArgumentError
         end
       end
     }

data/lib/facets/more/taskable.rb

@@ -211,6 +211,17 @@ module Taskable
         end
       end
       instance_task_table![name] = Task.new( name, self, deps, desc!, &action )
+    elsif !instance_task_table![name]
+      #define_method( "->#{name}", lambda{} )  # empty action
+      define_method( name ) do
+        # ensure no cycles in the graph and extract call graph
+        #own = (class << self; self; end) # in case there are singletons?
+        todolist = Task::Graph.new( self, name )
+        todolist.each_strongly_connected_component_from( name ) do |c|
+          send("->#{c}") unless "#{c}" == "#{name}"
+        end
+      end
+      instance_task_table![name] = Task.new( name, self, deps, desc!, &action )
     else
       m = instance_task_table![name]
       #m.description = desc!  # TODO should this apply only if there is an action?
@@ -291,6 +302,14 @@ end
       task :m5 do @x << 'm5' end
     end
 
+    class B
+      attr :x
+      def initialize ; @x = [] ; end
+
+      task :b1 do @x << "b1" end
+      task :b2 => [ :b1 ]
+    end
+
     class C
       include M
       attr :x
@@ -335,6 +354,16 @@ end
 
     # tests
 
+    def test_B1
+      b = B.new ; b.b1
+      assert_equal( [ 'b1' ], b.x )
+    end
+
+    def test_B2
+      b = B.new ; b.b2
+      assert_equal( [ 'b1' ], b.x )
+    end
+
     def test_C1
       c = C.new ; c.c1
       assert_equal( [ 'c1' ], c.x )

data/note/CHANGELOG

@@ -0,0 +1,294 @@
+= Facets Change Log
+
+== 1.4.0
+* Added Cookie, HTTP and HTTPAccess of ...'s library.
+* OpenObject's __get__ and __set__ methods have been changed
+  to __fetch__ and __store__ to correspond to the Hash methods.
+* Added OpenCascade, which is like OpenObject but chains access.
+* Added ...'s lazy.rb which include's Future and Promise classes.
+* Added task.rb, which provides a Rake interface compatible task
+  system, but that can be used in any code.
+* Improved Hash#traverse (it now does all traversing before yielding).
+
+== 1.3.1
+* Deprecated string/to_arr, and slightly adjusted string#to_a.
+  (Not commonly used so not a major change.)
+* Minor bug fixes.
+
+== 1.3.0
+* Ported parts of Nitro's Glue library to Facets.
+  * more/aspects.rb
+  * core/module/on_included.rb
+  * core/module/expirable.rb
+  * core/enumerable/accumulate.rb
+* Added xoxo.rb, json.rb and rtals.rb.
+* Repaired missing data files for units.rb.
+* Moved cattr methods from module/ to class/.
+* mattr methods are in limbo at the moment.
+  (They were aliases for cattr.)
+
+== 1.2.1
+* kernel/meta has been renamed to kernel/instance
+
+== 1.2.0
+* Added zimba.tm's string/modulize, pathize and methodize.
+* Added some Gem methods, self/active?, self/gemspec, self/gempath.
+
+== 1.0.3
+* A last ditch attempt to keep facets and calibre as one project.
+
+== 1.0.2
+* Added _why's Array modulo.
+
+== 1.0.0
+* Sped up string#similarity.
+* By popular protest deprecated usage of "AClass.use Facets, :amethod".
+* Created nicer layout of facets/support, /group, /english (one day /method).
+* Odd sets of facets have been move to facets/group/, eg. facets/group/inflect.
+* All is now well preped for a Rolls release shoud that come about.
+
+== v0.10.30  Halloween
+* Change OrderedHash (ohash.rb) to Dictionary (dictionary.rb).
+* Change BlankSlate (blankslate.rb) to BasicObject (basicobject.rb).
+* Old versions of the above should still work, but throw warnings
+  and will stop working come next version.
+* 1.rb has been renamed to one.rb (I know, two more characters,
+  but you can do it! ;)
+* Methods enumerable/op_mod (%) and enumerable/eF are deprecated.
+  Use #every or #ew instead.
+
+== v0.10.11  Palapable
+* Merged Mega into Facets. I put the old Mega ChangeLog at
+  the bottom of this document.
+* This represents the One-Point-Oh realease (albeit RC1) of
+  Facets, but from now on I'll be using date versioning
+  --if you look at the versions below you may understand why.
+  The versioning sequence has no real rationality.
+  Instead I will use this simple Rational Versioning Policy:
+  * If YYYY-MM-DD it's a development release.
+  * If YYYY-MM it's an official release.
+  * If just YYYY it's hella stable.
+  One might argue this is not as robust as a compatability
+  significant point-based versioning system, but I'd say that's
+  all well and good in theory, now give me something that actually
+  works in practice.
+
+== v0.9.5  Rebirth
+* Rebirth of Facets! As cool as the name Nano is, it became clear
+  that most people are drawn toward the name Facets. So we are
+  reverting back. Nonetheless Nano will remain a viable alias for
+  Facets.
+* Must now use <code>require 'facets'</code> prior to using
+  other Facets. This does two things. First it loads the 
+  base methods, which ensures that all programs have them 
+  readibly available when using Facets. Secondly it supplements
+  #require to handle aliases. In essence, require 'facet/...',
+  require 'facets/...' and require 'nano/...' all point to the
+  same place(s). (NOTE This is a precursor to a more universal
+  system that will handle aliasing automatically.)
+* kernel/require_esc has been removed. #require_nano will be also
+  in the next release. These will no longer be needed thanks to 
+  the aliasing system.
+
+== v0.9.2  Littles
+* Added string/starts_with? and string/ends_with?
+* Fixed module/memoize to cache on a per class/module bases.
+* Added module/is as an alias for /include.
+* Added module/shadow_method and shadow_all.
+* Renamed module/superup (which was module/supers) to module/as. And defined a new
+  method called /superior which is like /super but skips to a sepecified ancestor.
+* Renamed module/super_send to module/send_as.
+
+== v0.9.1  Wraps
+* Added module/nesting (not to be confused with the class method Module::nesting).
+* Thanks goes to Gavien Kistner for new string/word_wrap methods 
+  (with additioanl thanks to Dyane Borderson for his suggestions).
+* Added hash/each_with_key and each_with_index, as well as array/each_with_key;
+  increasing polymorphism between the two classes.
+* Moved array/each_pair to enumerable/each_pair and changed how it worked to 
+  what one might expect.
+
+== v0.9.0  NotUorI
+* Deprecated object#special_class, which was a method for (class<<self;self;end).
+  Already have too many aliases for this, and though the name is fitting, the simpler
+  method #own is better (alternative: #singleton).
+* Fixed enumerable/uniq_by file which was misnamed 'unique_by.rb'.
+* BIG CHANGE! Got rid of URI encoding on file names and sub'd a converson table
+  of english readable names. Thanks Jeff Wood, Florain Gross, Dav Burt,
+  Gavin Kistner, James Edward Gray II, Brian Schröder, Mauricio Fernández,
+  David A. Black, Gavin Sinclair, Nikolai Weibull and Christian Neukirchen.
+
+== v0.8.3  UorI
+* Added kernel/uri and kernel/unuri
+* (Good idea?) removed methods module/sattr, sattr_reader, &c. Instead created object/meta
+  in which attr, attr_reader, &c. are made public. So, sattr -> meta.attr.
+* Added array/unzip
+* Added logger/format and logger/format_message (stub).
+* Added string/dequote.
+* Class method file names now begin with '::' to separate them from instance methods.
+
+== v0.8.2  Nano Revolution
+* Name Change! What was Ruby Facets is now Nano Methods!
+* New minor version as there has been a change of plans with the integration of what was Carats.
+  The classes and modules have been reseperated into their own project called Mega Modules.
+* Modified the #firstxxx/#lastxxx methods to be more congruent and comprehensible.
+* Renamed object/supers to object/superup. Better!
+* Got rid ot symbol/gen. Use object/generate_method_name or  module#generate_instance_method_name
+  instead ( Is that the longest non-foo method name ever? :)
+* The file 1st.rb has moved to object/method. This modifies #method to persist the returned
+  Method object. The original non-persitent version of #method is aliased to #original_method.
+  (This arrangement is not set in stone though, and is still be considered.)
+* Added module/clone_using, module/clone_ranaming and module/clone_removing.
+* Added module/integrate (I love this one!)
+* Added many new enumerable methods: #filter_map, #compact_map, #commonality, #frequency,
+  #probability and #find_collisions.
+* Moved some methods from array to enumerable: #each_permutation, #each_combination, 
+  #each_unique_pair and the class method ::combinations.
+* Added string/bytes per ruby-dev summary 26385-26467.
+* Moved #cattr_reader, #cattr_writer and #cattr_accessor from Class to Module.
+* Renamed numeric/octet_units to numeric/bytes_to_s and added a #bits_to_s as well.
+* Added class/descendants (alias subclasses) and class/remove_descendents, as well as
+  object/descendents_of and object/remove_descendents_of.
+* Added methods to comparable: #cap, #clip. There are also #at_least and
+  #at_most, although FYI #cap and #clip handle the same functionality.
+* Removed string/table_name and string/class_name (they were too Rails specific).
+  Note: A new module has been added to Mega Modules, called orm-inflect.rb. It contains numerous
+  methods for doing this sort of thing.
+* Added numeric/ceil_multiple (not sure about name though, perhaps a better name like "ceil_to"?).
+* Added string/soundex for calculating the soundex code of a word/name.
+* Added io/expect. I thought Ruby already had this but can't find it, so here it is for now.
+* Placed Florian's binding-of-caller.rb in binding/of_caller. Makes more sense there.
+* Fixed bug with Continuation::create (it wasn't defined as a class method and should have been).
+* Fixed bug with string/capitalized? which wasn't always giving the correct result.
+
+== v0.7.2  George II
+* Added a class method dir/recurse which allows one to loop through a dir and all its
+  subdirs, etc. It also has an alias #ls_r. Thanks goes to George Maschovitis for this.
+* Changed array/permute to array/each_permutation.
+
+== v0.7.1  Quick George
+* Added facet.rb, although expiremental it makes it possible to use atomic methods without
+  specificaly requiring them. It uses Object#method_missing to require them as needed.
+* Improved on "molecules", i.e. files that require numerous related atoms in a single go.
+  These will see a great deal of continued improvement in the future.
+
+== v0.7.0  Georgian Transform
+* All methods with names containing non-alphanumeric characters now have facet
+  files without those special characters. This removes some incompatibilites with 
+  certain systems (including Windows). All such symbols have been replaced with
+  CGI escape sequences, for instance 'in?.rb' becomes 'in%3F.rb'. To avoid having
+  to use these "ugly" names, a new method has been added, kernel/require_facet.
+* Methods that were grouped together in the same file have been separated 
+  into their own files. Pure Atomicity has been achieved!
+* The method array/put has been dropped in favor of array/top (as a better alias for #unshift).
+* Methods #matchdata/post_match_from and #matchdata/pre_match_from have deprecated
+  in favor of more generalized methods that serves the same purposes,
+  matchdata/matchtree and matchdata/matchset.
+* Added module/include_as.
+* Added array/permute.
+
+== v0.6.3  Gemstone
+* Gem is now avaliable!
+* Added kernel/require_all which allows one to require a pattern of files,
+  making it easy to require every file in a directory.
+* Added hash/traverse and hash/traverse!, which takes a block and iterates over
+  each key-value pair descending into subhash values and applying the block.
+  (Thanks goes to Ara T. Howard and robert for their help.)
+* Added hash/collect. This uses enumerable/graph so that
+  hash/collect will return a hash rather then an array.
+* Added numeric/before and numeric/after in place of #ago and #since
+  and aliased #ago and #since to them, per the suggestions of
+  Francis Hwang.
+* Added "poor man's profiler", time/elapse. (Thanks goes to Hal Fulton).
+* Changed enumerable/build_hash to enumerable/graph. The method #build_hash
+  has been aliased to #graph for the time being for backward compatability.
+* Added array/last_index. (Thanks goes to Jabari)
+
+== v0.6.2  Refinement I
+* Added kernel/resc as a shortcut for Regexp.escape.
+* Renamed hash/keys_to_string to hash/key_to_s and  
+  hash/keys_to_symbol to hash/keys_to_sym to be more consistant
+  with other methods and what these methods specifically do.
+  The old names have been deprecated.
+* Added hash/has_keys?, which allows for checking mutliple keys at once.
+  Also includes #has_only_keys?
+* Added Rail's Time and Byte modules for Numeric with
+  numeric/times.rb and numeric/bytes.rb (I've been informed that
+  thanks go to Richard Kilmer for this. Thanks!)
+* Added numeric/octet_unit which utilizes numeric/bytes.
+  (The name of this method may change in the future though.)
+* Added enumerable/uniq_by.
+* Added module/abstract.
+* Added module/redirect which is similar to alias, but does not
+  copy the method, but rather wraps it. It also takes a hash so
+  multiple methods can be redirected all at once.
+* Added string/shatter which is similar to split but includes
+  the matched portions of text.
+
+== v0.6.1  Florian's Mixes
+* Updated the current set of mix files which were still from 
+  version 0.5.0. (2004-12-31)
+
+== v0.6.0  Florian's Onslaught
+* Major revisions made by Florian's onslaught. (2004-12-28) 
+* First general public release.
+
+== v0.5.0  Fit for First
+* This is the beginning of offical releases. (2004-12-23)
+* Now called Facets.
+* Changed layout to be completely atomic! (2004-10-30)
+
+== v0.4.0  Raspberry
+* Scoured the Ruby world for useful additions.
+* Changed name again from A.B.C. to Raspberry.
+  I can't seem to settle on a name. Even the new 
+  subsections have changed five times. (2004-08-08)
+
+== v0.3.0  ABC
+* Reorganinzed all of this together in a nice neat way.
+* Changed name of library from Succ to A.B.C. 
+  which stands for All Base Common. (2004-02-02)
+
+== v0.2.0  Succ
+* A number of new methods added.
+* Renamed it Succ for "successor". (2003-05-31)
+
+== v0.1.0  TomsLib
+* Tomslib's just a few useful methods. (2002-07-01)
+
+
+== Old Mega/Carats ChangeLog
+
+== v0.4.0
+* Adjusted Tuple to use Tuple::[*args] instead of ::new, which now takes
+  a single argument instead, either an Array or a String which it splits.
+* Removed services.rb unitl in gets fixed and a better name.
+
+== v0.3.3
+* Added inheritable.rb, a lib for creating class vars inherit from ancestors
+* Addes annotations.rb, a lightweight metadata system good for annotating
+  methods esspecially. It is built on top of inheritable.rb.
+
+== 0.3.2
+* Added services.rb, a lib for managing methods as first class objects
+* Fixed/cleaned-up orm_supprt.rb
+
+== 0.3.1
+* Aliased #autoload_classes with #autorequire.
+* Added #strfbits and #strfbytes to binary_multiplers.rb.
+
+== 0.3.0
+* Name change to Mega Modules!
+* Added a few important files: multipliers.rb, binary_multipliers.rb,
+  time_in_english.rb and orm_inlectors.rb.
+* Each one of these is a "Methods Module", i.e. They are a collection of
+  closely related methods that modify one or more core classes/modules.
+  Individually these methods could have very well ended up in Nano Methods,
+  but given there quantity and interrelation they were more suitable to a
+  module, and thus placed here.
+
+== 0.2.0
+* Initial public release
+
+== 0.1.0
+* Early Development as Ruby Carats