gorillib 0.4.1pre → 0.4.2pre

data/lib/gorillib/some.rb

@@ -14,3 +14,5 @@ require 'gorillib/string/constantize'
 require 'gorillib/hash/mash'
 require 'gorillib/metaprogramming/delegation'
 require 'gorillib/metaprogramming/concern'
+
+require 'gorillib/logger/log'

data/lib/gorillib/string/constantize.rb

@@ -1,28 +1,35 @@
 require 'gorillib/string/inflector'
 class String
 
-  # +constantize+ tries to find a declared constant with the name specified
-  # in the string. It raises a NameError when the name is not in CamelCase
-  # or is not initialized.  See Gorillib::Inflector.constantize
+  # Find a declared constant with the name specified in the string, or raise.
   #
-  # Examples
+  # @example
   #   "Module".constantize  # => Module
   #   "Class".constantize   # => Class
   #   "blargle".constantize # => NameError: wrong constant name blargle
+  #
+  # @raise [NameError] when the name is not in CamelCase or is not initialized.
+  # @return [Module,Class] the specified class
+  # @see Gorillib::Inflector.constantize
   def constantize
     Gorillib::Inflector.constantize(self)
-  end unless method_defined?(:constantize)
+  end
 
-  # +safe_constantize+ tries to find a declared constant with the name specified
-  # in the string. It returns nil when the name is not in CamelCase
-  # or is not initialized.  See Gorillib::Model::Inflector.safe_constantize
+  # Find a declared constant with the name specified in the string, or return nil.
+  #
+  # @return [Module,Class] the specified class, or nil when the name is not in
+  # CamelCase or is not initialized.
   #
-  # Examples
+  # @example
   #   "Module".safe_constantize  # => Module
   #   "Class".safe_constantize   # => Class
   #   "blargle".safe_constantize # => nil
+  #
+  # @see Gorillib::Model::Inflector.safe_constantize
+  # @return [Module,Class] the specified constant,
+  #   or nil when the name is not in CamelCase or is not initialized.
   def safe_constantize
     Gorillib::Inflector.safe_constantize(self)
-  end unless method_defined?(:safe_constantize)
+  end
 
 end

data/lib/gorillib/string/inflector.rb

@@ -120,14 +120,16 @@ module Gorillib::Inflector
     Object.module_eval("::#{$1}", __FILE__, __LINE__)
   end
 
-  # Tries to find a constant with the name specified in the argument string:
+  # Tries to find a declared constant with the name specified in the string, or return nil.
   #
-  #   "Module".safe_constantize     # => Module
-  #   "Test::Unit".safe_constantize # => Test::Unit
+  # @example
+  #   "Module".safe_constantize  # => Module
+  #   "Class".safe_constantize   # => Class
   #
-  # The name is assumed to be the one of a top-level constant, no matter whether
+  # The `name` is assumed to be the one of a top-level constant, no matter whether
   # it starts with "::" or not. No lexical context is taken into account:
   #
+  # @example finds the top-level constant `::C`, not `::M::C`
   #   C = 'outside'
   #   module M
   #     C = 'inside'
@@ -135,13 +137,15 @@ module Gorillib::Inflector
   #     "C".safe_constantize # => 'outside', same as ::C
   #   end
   #
-  # nil is returned when the name is not in CamelCase or the constant (or part of it) is
-  # unknown.
-  #
+  # @example nil is returned when the name is not in CamelCase or the constant (or part of it) is unknown.
   #   "blargle".safe_constantize  # => nil
   #   "UnknownModule".safe_constantize  # => nil
   #   "UnknownModule::Foo::Bar".safe_constantize  # => nil
   #
+  #
+  # @see String.safe_constantize
+  # @return [Module,Class] the specified constant,
+  #   or nil when the name is not in CamelCase or is not initialized.
   def safe_constantize(camel_cased_word)
     begin
       constantize(camel_cased_word)

data/lib/gorillib/type/boolean.rb

@@ -0,0 +1,40 @@
+
+# require 'gorillib/metaprogramming/delegation'
+#
+# class ::Boolean < ::Object
+#   attr_accessor :val
+#   def initialize(val=nil)
+#     self.val = val
+#   end
+#
+#   delegate :!,  :to_s, :blank?, :frozen?, :nil?, :present?, :to => :val
+#   delegate :!=, :&, :<=>, :=~, :^, :|, :to => :val
+#
+#   def inspect()
+#     "<Boolean #{val.inspect}>"
+#   end
+#   def try_dup()
+#     ::Boolean.new(val)
+#   end
+#
+#   def self.true  ; self.new(true)  ; end
+#   def self.false ; self.new(false) ; end
+#
+#   def is_a?(klass)        val.is_a?(klass)        || super ; end
+#   def kind_of?(klass)     val.kind_of?(klass)     || super ; end
+#   def instance_of?(klass) val.instance_of?(klass) || super ; end
+#
+#   def     !=(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val     != other_val) ; end
+#   def     ==(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val     == other_val) ; end
+#   def    ===(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val    === other_val) ; end
+#   def    <=>(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val    <=> other_val) ; end
+#   def   eql?(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val.eql?   other_val) ; end
+#   def equal?(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val.equal? other_val) ; end
+#
+# end
+
+# Datamapper also defines:
+#
+#  Apikey BCryptHash Decimal URI UUID Slug CommaSeparatedList Csv IpAddress Json Yaml Enum Flag Discriminator
+#
+# maybe someday we will too...

data/lib/gorillib/type/extended.rb

@@ -1,5 +1,7 @@
 require 'pathname'
-require 'time'
+require 'date'
+require 'set'
+require 'gorillib/factories'
 
 class ::Long      < ::Integer ; end
 class ::Double    < ::Float   ; end
@@ -9,42 +11,76 @@ class ::Guid      < ::String  ; end
 class ::IpAddress < ::String  ; end
 class ::Hostname  < ::String  ; end
 
-# require 'gorillib/metaprogramming/delegation'
-#
-# class ::Boolean < ::Object
-#   attr_accessor :val
-#   def initialize(val=nil)
-#     self.val = val
-#   end
-#
-#   delegate :!,  :to_s, :blank?, :frozen?, :nil?, :present?, :to => :val
-#   delegate :!=, :&, :<=>, :=~, :^, :|, :to => :val
-#
-#   def inspect()
-#     "<Boolean #{val.inspect}>"
-#   end
-#   def try_dup()
-#     ::Boolean.new(val)
-#   end
-#
-#   def self.true  ; self.new(true)  ; end
-#   def self.false ; self.new(false) ; end
-#
-#   def is_a?(klass)        val.is_a?(klass)        || super ; end
-#   def kind_of?(klass)     val.kind_of?(klass)     || super ; end
-#   def instance_of?(klass) val.instance_of?(klass) || super ; end
-#
-#   def     !=(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val     != other_val) ; end
-#   def     ==(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val     == other_val) ; end
-#   def    ===(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val    === other_val) ; end
-#   def    <=>(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val    <=> other_val) ; end
-#   def   eql?(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val.eql?   other_val) ; end
-#   def equal?(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val.equal? other_val) ; end
-#
-# end
-
-# Datamapper also defines:
-#
-#  Apikey BCryptHash Decimal URI UUID Slug CommaSeparatedList Csv IpAddress Json Yaml Enum Flag Discriminator
-#
-# maybe someday we will too...
+class ::EpochTime < ::Integer   ; end
+class ::IntTime   < ::EpochTime ; end
+
+module Gorillib
+  module Factory
+    class GuidFactory      < StringFactory ; self.product = ::Guid      ; register_factory! ; end
+    class HostnameFactory  < StringFactory ; self.product = ::Hostname  ; register_factory! ; end
+    class IpAddressFactory < StringFactory ; self.product = ::IpAddress ; register_factory! ; end
+
+    class DateFactory  < ConvertingFactory
+      self.product = Date
+      FLAT_DATE_RE = /\A\d{8}Z?\z/
+      register_factory!
+      #
+      def convert(obj)
+        case obj
+        when FLAT_DATE_RE  then product.new(obj[0..3].to_i, obj[4..5].to_i, obj[6..7].to_i)
+        when Time          then Date.new(obj.year, obj.month, obj.day)
+        when String        then Date.parse(obj)
+        else                    mismatched!(obj)
+        end
+      rescue ArgumentError => err
+        raise if err.is_a?(TypeMismatchError)
+        warn "Cannot parse time #{obj}: #{err}"
+        return nil
+      end
+    end
+
+    class EpochTimeFactory < ConvertingFactory
+      self.product = Integer
+      def self.typename() :epoch_time ; end
+      register_factory!   :epoch_time, EpochTime
+      #
+      def convert(obj)
+        case obj
+        when Numeric           then obj.to_f
+        when Time              then obj.to_f
+        when /\A\d{14}Z?\z/    then Time.parse(obj)
+        when String            then Time.parse_safely(obj).to_f
+        end
+      end
+    end
+
+    class IntTimeFactory < EpochTimeFactory
+      def self.typename() :int_time ; end
+      register_factory!   :int_time, IntTime
+      #
+      def convert(obj)
+        result = super
+        result.nil? ? nil : result.to_i
+      end
+    end
+
+    class Boolean10Factory < BooleanFactory
+      def self.typename() :boolean_10 ; end
+      register_factory!   :boolean_10
+      #
+      def convert(obj)
+        case obj.to_s
+        when "0" then false
+        when "1" then true
+        else          super
+        end
+      end
+    end
+
+    class SetFactory < EnumerableFactory
+      self.product = Set
+      register_factory!
+    end
+
+  end
+end

data/lib/gorillib/type/url.rb

@@ -2,8 +2,10 @@ require 'addressable/uri'
 
 class ::Url < Addressable::URI ; end
 
-class UrlFactory < Gorillib::Factory::ConvertingFactory
-  self.product = ::Url
-  def convert(obj)      product.parse(obj) ; end
-  register_factory!
+module Gorillib::Factory
+  class UrlFactory < Gorillib::Factory::ConvertingFactory
+    self.product = ::Url
+    def convert(obj)      product.parse(obj) ; end
+    register_factory!
+  end
 end

data/lib/gorillib/utils/console.rb

@@ -36,7 +36,7 @@ class ItsATrap < BasicObject
   alias_method :pretty_inspect, :inspect
   def methods() @obj.methods ; end
 
-  # @returns the proxied object
+  # @return the proxied object
   def __obj__ ; @obj ; end
 
   # These are defined on BasicObject, delegate them along with the rest
@@ -70,23 +70,6 @@ private
   end
 end
 
-module Test
-  module_function
-
-  def create_class(name, *args, &block)
-    Object.class_eval do
-      remove_const(name) if self.const_defined?(name)
-      const_set(name, Class.new(*args, &block))
-    end
-  end
-
-  def example_singleton(name, *args)
-    require 'singleton'
-    create_class(name, *args){ include ::Singleton }
-  end
-
-end
-
 class Module
 
   #

data/lib/gorillib/utils/edge_cases.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+module Gorillib
+  module Utils
+    module EdgeCases
+      # Thanks http://www.geertvanderploeg.com/unicode-gen/ !
+      # For more fun, see http://www.tamasoft.co.jp/en/general-info/unicode.html
+      STRINGS = {
+        :unicode_smileys => '٩(-̮̮̃-̃)۶ ٩(●̮̮̃•̃)۶ ٩(͡๏̯͡๏)۶ ٩(-̮̮̃•̃).',
+        :internationalization => 'Iｎｔèｒｎａｔｉòｎãｌïｚãｔíｏｎ',
+        :html_unsafe => 'Testing «Mònkêy Sí Monkè Dü»: 1<2 & 4+1>3, now 20% off!',
+
+        :eastern_arabic_digits => '٠١٢٣٤٥٦٧٨٩',
+        :bengali_digits        => '০১২৩৪৫৬৭৮৯',
+      }
+
+    end
+  end
+end

data/spec/examples/builder/ironfan_spec.rb

@@ -1,21 +1,16 @@
 require 'spec_helper'
-# related libs
-require 'gorillib/model'
-require 'gorillib/model/field'
-require 'gorillib/model/defaults'
-# libs under test
-require 'gorillib/builder'
-require 'gorillib/builder/field'
-require 'gorillib/string/simple_inflector'
-# testing helpers
 
-load GORILLIB_ROOT_DIR('examples/builder/ironfan.rb')
+require 'gorillib/builder'
 
 module Gorillib::Test       ; end
 module Meta::Gorillib::Test ; end
 
 describe Gorillib::Builder, :model_spec => true do
+  before do
+    require_relative '../../../examples/builder/ironfan.rb'
+  end
   after(:each){   Gorillib::Test.nuke_constants ; Meta::Gorillib::Test.nuke_constants }
+
   def example_cluster
     Gorillib::Test.cluster
   end

data/spec/gorillib/array/compact_blank_spec.rb

@@ -1,37 +1,52 @@
 require 'spec_helper'
 require 'gorillib/array/compact_blank'
 
-describe Array, :simple_spec => true do
+describe Array, :simple_spec do
+  let(:blankish){ mock('blankish', :blank? => true) }
+  let(:nonblank){ mock('nonblank', :blank? => false) }
 
   describe '#compact_blank' do
-    it 'with empty' do
-      [ [nil], [nil, false, {}, ""] ].each do |arr|
-        arr.compact_blank.should == []
-        arr.length.should_not    == 0
-      end
+    it 'omits nils, like #compact' do
+      arr = [nil]
+      arr.compact_blank.should == []
+      arr.length.should == 1
+    end
+    it "also omits false, {}, '' and anything else #blank\?" do
+      arr = [nil, false, {}, "", blankish]
+      arr.compact_blank.should == []
+      arr.length.should == 5
     end
 
-    it 'with full' do
-      [ [nil, 1, nil, 2], [nil, 1, false, 2, {}, ""] ].each do |arr|
-        arr.compact_blank.should == [1, 2]
-      end
+    it 'preserves non-blank elements' do
+      arr = [nil, 1, nil, 2]
+      arr.compact_blank.should == [1, 2]
+      arr.length.should == 4
+      arr = [nil, 1, false, 2, {}, ""]
+      arr.compact_blank.should == [1, 2]
+      arr.length.should == 6
     end
   end
 
   describe '#compact_blank!' do
-    it 'with empty' do
-      [].compact_blank!.should == []
-      [ [nil], [nil, false, {}, ""] ].each do |arr|
-        arr.compact_blank!.should == []
-        arr.length.should         == 0
-      end
+    it 'removes nils in-place, like #compact!' do
+      arr = [nil]
+      arr.compact_blank!.should == []
+      arr.length.should == 0
     end
-
-    it 'with full' do
-      [ [nil, 1, nil, 2], [nil, 1, false, 2, {}, ""] ].each do |arr|
-        arr.compact_blank!.should == [1, 2]
-      end
+    it "removes false, {}, '' and anything else #blank\?" do
+      arr = [nil, false, {}, "", blankish]
+      arr.compact_blank!.should == []
+      arr.length.should == 0
     end
 
+    it 'preserves non-blank elements' do
+      arr = [nil, 1, nil, 2]
+      arr.compact_blank!.should == [1, 2]
+      arr.length.should == 2
+      arr = [nil, 1, false, 2, {}, ""]
+      arr.compact_blank!.should == [1, 2]
+      arr.length.should == 2
+    end
   end
+
 end

data/spec/gorillib/array/simple_statistics_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+require 'gorillib/array/simple_statistics'
+
+describe Array, :simple_spec do
+  let(:seven_squares){ [ 1, 4, 9, 16, 25, 36, 49] }
+  let(:five_squares ){ [   1, 4,  16,  36, 49   ] }
+  let(:one_element  ){ [          16            ] }
+  subject{ seven_squares }
+
+  describe '#average' do
+    it('is nil for empty array'){ [].average.should be_nil }
+    it('is the numeric mean') do
+      five_squares.average.should  eql 21.2
+      seven_squares.average.should eql 20.0
+      one_element.average.should   eql 16.0
+    end
+    it('is is uptyped by its elements') do
+      five_squares.map(&:to_f).average.should eql 21.2
+      [ Complex(1.0,2.0), Complex(3,4), Complex(5) ].average.should eql Complex(3.0,2.0)
+      [ Complex(1,2),     Complex(3,4), Complex(5) ].average.should eql (Complex(9,6) / 3.0)
+    end
+    context 'on non-float array element' do
+      it 'raises error' do
+        expect{ [0.0, :b, 1.0].average }.to raise_error(TypeError, /:b can\'t be coerced into Float/)
+      end
+    end
+    context 'with empty' do
+      it 'returns nil' do
+        [].average.should be_nil
+      end
+    end
+    context 'given a numerical array' do
+      it 'returns the average of the elements' do
+        (1..10).to_a.average.should == 5.5
+      end
+    end
+  end
+
+  describe '#at_fraction' do
+    it('is nil for empty array'){ [].at_fraction(0.5).should be_nil }
+    it 'indexes correctly' do
+      seven_squares.at_fraction(0  ).should == 1
+      seven_squares.at_fraction(0.5).should == 16
+      seven_squares.at_fraction(1.0).should == 49
+      five_squares.at_fraction(0.75).should == 36
+    end
+    it 'returns the value the nth of the way along' do
+      (0..6).map{|nth| seven_squares.at_fraction(nth/6.0).should == seven_squares[nth] }
+    end
+
+    it 'raises if the fraction is not a number between 0.0 and 1.0' do
+      expect{ subject.at_fraction(1.0001) }.to raise_error(ArgumentError, /between 0.0 and 1\.0: got 1\.0001/)
+      expect{ subject.at_fraction(-1)     }.to raise_error(ArgumentError, /between 0.0 and 1\.0: got -1/)
+      expect{ subject.at_fraction('1.1')  }.to raise_error(ArgumentError, /between 0.0 and 1\.0: got \"1.1\"/)
+    end
+  end
+
+  describe '#take_nths' do
+    it 'gives elements at 0.5/n, 1.5/n, 2.5/n ... n-0.5/n' do
+      five_squares.take_nths(2).should   == [   4,         36   ]
+      five_squares.take_nths(3).should   == [   4,   16,   36   ]
+      five_squares.take_nths(4).should   == [   4,   16,   36,49]
+      five_squares.take_nths(5).should   == [1, 4,   16,   36,49]
+      seven_squares.take_nths(1).should  == [        16         ]
+      seven_squares.take_nths(2).should  == [      9,      36   ]
+      seven_squares.take_nths(3).should  == [   4,   16,   36   ]
+      seven_squares.take_nths(4).should  == [   4, 9,   25,36   ]
+      seven_squares.take_nths(5).should  == [   4, 9,16,25,36   ]
+      seven_squares.take_nths(6).should  == [   4, 9,16,25,36,49]
+      seven_squares.take_nths(99).should == seven_squares
+      seven_squares.take_nths(0).should  == []
+      [].take_nths(3).should == []
+    end
+    context 'with empty' do
+      it 'returns an empty array' do
+        [].take_nths(1).should be_empty
+      end
+    end
+    context 'given any array' do
+      it ('returns a sample of the given size as close to evenly ' \
+          'distributed over the array as possible') do
+        nths = (1..100).to_a.take_nths(26)
+        deltas = nths[0..-2].zip(nths[1..-1]).map{|a,b| b-a}
+        deltas.max.should <= 4
+        deltas.min.should >= 3
+      end
+    end
+    context 'given an undersized array' do
+      it 'does not return the same element more than once' do
+        ("a".."z").to_a.take_nths(27).should == ("a".."z").to_a
+      end
+    end
+  end
+
+  describe '#sorted_median' do
+    it 'takes the halfway-th element' do
+      five_squares.sorted_median.should eql 16
+      seven_squares.sorted_median.should eql 16
+    end
+    context 'with empty' do
+      it 'returns nil' do
+        [].sorted_median.should be_nil
+      end
+    end
+    context 'given any array' do
+      it 'returns the middle element of odd-sized arrays' do
+        ("a".."y").to_a.sorted_median.should == "m"
+      end
+    end
+  end
+
+  describe '#sorted_percentile' do
+    context 'with empty' do
+      it 'returns nil' do
+        [].sorted_percentile(0.0).should be_nil
+      end
+    end
+
+    context 'given any array' do
+      it 'returns the element closest to the given percentile' do
+        ("a".."y").to_a.sorted_percentile(  0.0).should == "a"
+        ("a".."y").to_a.sorted_percentile( 50.0).should == "m"
+        ("a".."y").to_a.sorted_percentile(100.0).should == "y"
+      end
+    end
+
+    # (Please do not define behavior for two elements equally close to
+    # a given percentile.)
+
+    it 'takes fractional index at pct/100' do
+      five_squares .sorted_percentile(50).should eql 16
+      seven_squares.sorted_percentile(10).should eql  4
+      seven_squares.sorted_percentile(50).should eql 16
+      seven_squares.sorted_percentile(90).should eql 36
+      seven_squares.sorted_percentile(100).should eql 49
+    end
+    it 'returns nil on empty array' do
+      [].sorted_median.should be nil
+    end
+  end
+
+
+end