facets 2.4.4 → 2.4.5

data/lib/core/facets/integer/odd.rb

@@ -1,6 +1,6 @@
-unless (RUBY_VERSION[0,3] == '1.9')
+class Integer
 
-  class Integer
+  if RUBY_VERSION < '1.9'
 
     # Returns true if this integer is odd, false otherwise.
     #
@@ -10,10 +10,11 @@ unless (RUBY_VERSION[0,3] == '1.9')
     #   -99.odd?          # -> true
     #   -98.odd?          # -> false
     #
-    #   CREDIT: Gavin Sinclair
+    #  CREDIT: Daniel Schierbeck
 
     def odd?
-      self % 2 == 1
+      #self % 2 == 1
+      self & 1 == 1
     end
 
     # Returns true if this integer is even, false otherwise.
@@ -21,10 +22,11 @@ unless (RUBY_VERSION[0,3] == '1.9')
     #   2.even?  #=> true
     #   3.even?  #=> false
     #
-    #   CREDIT: Gavin Sinclair
+    #   CREDIT: Daniel Schierbeck
 
     def even?
-      self % 2 == 0
+      #self % 2 == 0
+      self & 1 == 0
     end
 
   end

data/lib/core/facets/module/class.rb

@@ -4,9 +4,7 @@ class Module
   # for inquery.
   #
   #   s = "HELLO"
-  #   s.class? String   #=> true
-  #
-  #  CREDIT: Trans
+  #   String.class?(s)  #=> true
 
   alias_method :class?, :===
 

data/lib/core/facets/module/conflict.rb

@@ -19,10 +19,14 @@ class Module
   #  CREDIT: Robert Dober
 
   def conflict?(other)
+    common_ancestor = (ancestors & other.ancestors).first
     c = []
     c += (public_instance_methods(true) & other.public_instance_methods(true))
     c += (private_instance_methods(true) & other.private_instance_methods(true))
     c += (protected_instance_methods(true) & other.protected_instance_methods(true))
+    c -= common_ancestor.public_instance_methods(true)
+    c -= common_ancestor.private_instance_methods(true)
+    c -= common_ancestor.protected_instance_methods(true)
     c.empty? ? false : c
   end
 
@@ -32,23 +36,26 @@ class Module
   #end
 
   # Like #conflict?, but checks only public methods.
-
   def public_conflict?(other)
+    common_ancestor = (ancestors & other.ancestors).first
     c = public_instance_methods(true) & other.public_instance_methods(true)
+    c -= common_ancestor.public_instance_methods(true)
     c.empty? ? false : c
   end
 
   # Like #conflict?, but checks only private methods.
-
   def private_conflict?(other)
+    common_ancestor = (ancestors & other.ancestors).first
     c = private_instance_methods(true) & other.private_instance_methods(true)
+    c -= common_ancestor.private_instance_methods(true)
     c.empty? ? false : c
   end
 
   # Like #conflict?, but checks only protected methods.
-
   def protected_conflict?(other)
+    common_ancestor = (ancestors & other.ancestors).first
     c = protected_instance_methods(true) & other.protected_instance_methods(true)
+    c -= common_ancestor.protected_instance_methods(true)
     c.empty? ? false : c
   end
 

data/lib/core/facets/module/prepend.rb

@@ -1,6 +1,7 @@
 class Module
 
   # Prepend an +aspect+ module to a module.
+  # This only works at the module level.
   #
   #   module X
   #     def x; "x"; end

data/lib/core/facets/string/methodize.rb

@@ -5,8 +5,13 @@ class String
   #   My::CoolClass.name.methodize => "my__cool_class"
   #
   def methodize
-    gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').gsub('::','__').downcase
+    gsub(/([A-Z]+)([A-Z])/,'\1_\2').
+    gsub(/([a-z])([A-Z])/,'\1_\2').
+    gsub('/','__').
+    gsub('::','__').
+    downcase
   end
 
 end
 
+

data/lib/core/facets/string/modulize.rb

@@ -0,0 +1,21 @@
+class String
+
+  # Converts a string to module name representation.
+  #
+  # This is essentially #camelcase. It also converts
+  # '/' to '::' which is useful for converting
+  # paths to namespaces.
+  #
+  # Examples
+  #   "method_name".modulize    #=> "MethodName"
+  #   "method/name".modulize    #=> "Method::Name"
+  #
+  def modulize
+    gsub('__','/').
+    gsub(/\/(.?)/){ "::#{$1.upcase}" }.
+    gsub(/(?:_+|-+)([a-z])/){ $1.upcase }.
+    gsub(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+  end
+
+end
+

data/lib/core/facets/string/pathize.rb

@@ -2,10 +2,14 @@ class String
 
   # Converts a (class or module) name to a unix path.
   #
-  #   My::CoolClass.name.pathize  #=> "/my/cool_class"
+  #   My::CoolClass.name.pathize  #=> "my/cool_class"
   #
   def pathize
-    gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').gsub('::','/').downcase
+    gsub(/([A-Z]+)([A-Z])/,'\1_\2').
+    gsub(/([a-z])([A-Z])/,'\1_\2').
+    gsub('__','/').
+    gsub('::','/').
+    downcase
   end
 
 end

data/lib/core/facets/string/splice.rb

@@ -1,8 +1,15 @@
 class String
 
-  # Like #slice, but writes rather than reads.
-  # Like #store, but acts like slice!
-  # when given only one argument.
+  # This is basically the same as #store,
+  # but it acts like slice! when given only
+  # one argument.
+  #
+  # Essentlay #slice, but writes rather than
+  # reads.
+  #
+  #   a = "HELLO"
+  #   a.splice("X", 1)
+  #   a                #=> "HXLLO"
   #
   #   a = "HELLO"
   #   a.splice(1)    #=> "E"
@@ -10,11 +17,16 @@ class String
   #
   #   CREDIT: Trans
 
-  def splice(*args)
-    if args.size == 1
-      slice!(*args)
+  def splice(idx, sub=nil)
+    if sub
+      store(idx, sub)
     else
-      store(*args)
+      case idx
+      when Range
+        slice!(idx) 
+      else
+        slice!(idx,1)
+      end
     end
   end
 

data/lib/core/facets/string/variablize.rb

@@ -5,7 +5,8 @@ class String
   # non-valid characters with underscores.
 
   def variablize
-    "@#{self}".gsub(/\W/, '_').to_s
+    v = gsub(/\W/, '_')
+    "@#{v}"
   end
 
 end

data/lib/core/facets/symbol/plain.rb

@@ -15,30 +15,3 @@ class Symbol
 
 end
 
-
-=begin :spec:
-
-  Quarry.spec Symbol do
-
-    ensure "plain? works" do
-      :try.plain?.assert  == true
-      :try=.plain?.assert == false
-      :try?.plain?.assert == false
-    end
-
-    ensure "setter? works" do
-      :try.setter?.assert  == false
-      :try=.setter?.assert == true
-      :try?.setter?.assert == false
-    end
-
-    ensure "query? works" do
-      :try.query?.assert  == false
-      :try=.query?.assert == false
-      :try?.query?.assert == true
-    end
-
-  end
-
-=end
-

data/lib/core/facets/symbol/re_s.rb

@@ -0,0 +1,18 @@
+require 'facets/functor'
+
+class Symbol
+
+  # Convert symbol to string, apply string method
+  # and convert back to symbol via a fluent
+  # interface.
+  #
+  #   :HELLO.re_s.downcase
+  #
+  def re_s
+    @re_s ||= Functor.new do |op, *a|
+      to_s.send(op, *a).to_sym
+    end
+  end
+
+end
+

data/lib/lore/facets/ostruct.rb

@@ -28,13 +28,12 @@ require 'ostruct'
 
 class OpenStruct
 
+  # Allows the initialization of an OpenStruct with a setter block:
   #
-  # Allows the initialization of an OpenStruct with a block:
-  #
-  #   person = OpenStruct.new do |p|
-  #     p.name    = 'John Smith'
-  #     p.gender  = :M
-  #     p.age     = 71
+  #   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
@@ -44,18 +43,35 @@ class OpenStruct
   #     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
   #   CREDIT Gavin Sinclair
-
-  def initialize(hash=nil) # :yield: self
-    @table = {}
+  #   CREDIT 7rans
+  #
+  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
-    yield self if block_given?
+    if block && block.arity==1
+      yield self
+    end
   end
 
   #

data/lib/lore/facets/pathname.rb

@@ -142,7 +142,7 @@ class Pathname
     flags = 0
     opts.each do |opt|
       case opt when Symbol, String
-        flags += File.const_get("FNM_#{opt}".upcase)
+        flags += ::File.const_get("FNM_#{opt}".upcase)
       else
         flags += opt
       end

data/lib/lore/facets/zlib.rb

@@ -0,0 +1,38 @@
+# A convenient wrapper for the zlib standard library that allows
+# compression/decompression of strings with gzip.
+
+module Zlib
+
+  #class Stream < StringIO
+  #  def close; rewind; end
+  #end
+
+  # Decompresses a gzipped string.
+  def self.decompress(source)
+    GzipReader.new(StringIO.new(source)).read
+  end
+
+  # Compresses a string using gzip.
+  def self.compress(source)
+    output = StringIO.new
+    class << output
+      def close; rewind; end
+    end
+    gz = GzipWriter.new(output)
+    gz.write(source)
+    gz.close
+    output.string
+  end
+
+  # Inflate a deflated sting.
+  def self.inflate(string)
+    Inflate.inflate(string)
+  end
+
+  # Deflate a string.
+  def self.deflate(string, level=DEFAULT_COMPRESSION)
+    Deflate.deflate(string, level)
+  end
+
+end
+

data/lib/more/facets/ansicode.rb

@@ -313,8 +313,3 @@ module ANSICode
 
 end
 
-#module Console #:nodoc:
-#  # For backward compatability
-#  ANSICode = ::ANSICode
-#end
-

data/lib/more/facets/opencascade.rb

@@ -1,31 +1,4 @@
-# = OpenCascade
-#
-# OpenCascade is a subclass of OpenObject. It differs in a few
-# significant ways, in particular entries cascade to new entries.
-#
-# The main reason this class is labeled "cascade", every internal
-# Hash is trandformed into an OpenCascade dynamically upon access.
-# This makes it easy to create "cascading" references.
-#
-#   h = { :x => { :y => { :z => 1 } } }
-#   c = OpenCascade[h]
-#   c.x.y.z  #=> 1
-#
-# == Authors
-#
-# * Thomas Sawyer
-#
-# == Todo
-#
-# * Think about this more!
-# * What about parent when descending downward?
-#   Should parent even be part of OpenObject?
-#   Maybe that should be in a differnt class?
-# * Should cascading work via hash on the fly like this?
-#   Or perhaps converted all at once?
-# * Returning nil doesn't work if assigning!
-#
-# == Copying
+# = opencascade.rb
 #
 # Copyright (c) 2006 Thomas Sawyer
 #
@@ -48,13 +21,34 @@ require 'facets/openobject'
 # significant ways.
 #
 # The main reason this class is labeled "cascade", every internal
-# Hash is trandformed into an OpenCascade dynamically upon access.
+# Hash is transformed into an OpenCascade dynamically upon access.
 # This makes it easy to create "cascading" references.
 #
 #   h = { :x => { :y => { :z => 1 } } }
 #   c = OpenCascade[h]
 #   c.x.y.z  #=> 1
 #
+# As soon as you access a node it automatically becomes an OpenCascade.
+#
+#   c = OpenCascade.new   #=> #<OpenCascade:0x7fac3680ccf0 {}>
+#   c.r                   #=> #<OpenCascade:0x7fac368084c0 {}>
+#   c.a.b                 #=> #<OpenCascade:0x7fac3680a4f0 {}>
+#
+# But if you set a node, then that will be it's value.
+#
+#   c.a.b = 4             #=> 4
+#
+# To query a node without causing the auto-creation of an OpenCasade
+# object, use the ?-mark.
+#
+#   c.a.z?                #=> nil
+#
+# Finally, you can set a node and get the reciever back using
+# the !-mark.
+#
+#   c = OpenCascade.new   #=> #<OpenCascade:0x7fac3680ccf0 {}>
+#   c.x!(4).y!(3)         #=> #<OpenCascade:0x7fac3680ccf0 {:x=>4, :y=>3}>
+#
 #--
 # Last, when an entry is not found, 'null' is returned rather then 'nil'.
 # This allows for run-on entries withuot error. Eg.
@@ -81,10 +75,18 @@ class OpenCascade < OpenObject
     elsif type == '!'
       self[name] = arg
       self
+    elsif type == '?'
+      self[name]
     else
-      val = self[name]
-      val = object_class[val] if Hash === val
-      val
+      if val = self[name]
+        if Hash === val
+          self[name] = self.class.new(val)
+        else
+          self[name]
+        end
+      else
+        self[name] = self.class.new
+      end
     end
   end