facets 3.1.0 → 3.2.1

data/lib/standard/facets/getoptlong.rb

@@ -1,59 +1,3 @@
-require 'getoptlong'
-
-# = GetoptLong
-#
-# Ruby's standard GetoptLong class with an added DSL.
-#
-#   opts = GetoptLong.new do
-#     reqs '--expect', '-x'
-#     flag '--help', '-h'
-#   end
-#
-# See GetoptLong::DSL for details.
-
-class GetoptLong
-
-  alias :init :initialize
-
-  #
-  def initialize(*arguments, &block)
-    if block_given?
-      raise ArgumentError unless arguments.empty?
-      arguments = DSL.new(&block).arguments
-    end
-    init(*arguments)
-  end
-
-  # DSL-mode parser.
-  class DSL
-    attr :arguments
-
-    def initialize(&block)
-      @arguments = []
-      instance_eval(&block)
-    end
-
-    #
-    def flag(*opts)
-      @arguments << (opts << GetoptLong::NO_ARGUMENT)
-    end
-
-    #
-    def required(*opts)
-      @arguments << (opts <<  GetoptLong::REQUIRED_ARGUMENT)
-    end
-
-    #
-    alias :reqs :required
-
-    #
-    def optional(*opts)
-      @arguments << (opts << GetoptLong::OPTIONAL_ARGUMENT)
-    end
-
-    #
-    alias :opts :optional
-  end
-
-end
-
+# @deprecated GetoptLong is a bundled gem heading for removal.
+#   Consider using OptionParser or a modern CLI library instead.
+warn "facets/getoptlong is deprecated. Consider OptionParser instead.", uplevel: 1

data/lib/standard/facets/load_monitor.rb

@@ -1,26 +1,2 @@
-module ::Kernel
-  class << self
-    alias_method :require_without_monitor, :require
-    alias_method :load_without_monitor, :load
-  end
-
-  alias_method :require_without_monitor, :require
-  alias_method :load_without_monitor, :load
-
-  # Require script and print what is being require.
-  def require(file)
-    $stderr.puts "monitor require: #{file}\n#{caller.inspect}\n\n"
-    require_without_monitor(file)
-  end
-
-  module_function :require
-
-  # Load script and print what is being loaded.
-  def load(file, wrap=false)
-    $stderr.puts "monitor load: #{file}\n#{caller.inspect}\n\n"
-    load_without_monitor(file, wrap)
-  end
-
-  module_function :load
-end
-
+# @deprecated Monkey-patching require/load globally is dangerous.
+warn "facets/load_monitor is deprecated. It monkey-patches require/load globally.", uplevel: 1

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

@@ -1,4 +1,5 @@
 require 'facets/math/approx_equal'
+require 'facets/math/mean'
 
 module Math
 
@@ -13,11 +14,11 @@ module Math
   #   GC = \frac{\sum_{i=1}^N (2i-N-1)x_i}{N^2-\bar{x}}
   #
   def self.gini_coefficient(array)
-    return -1 if size <= 0 or any? { |x| x < 0 }
-    return 0 if size < 2 or all? { |x| approx_equal(x,0) }
+    return -1 if array.size <= 0 or array.any? { |x| x < 0 }
+    return 0 if array.size < 2 or array.all? { |x| approx_equal(x,0) }
     s = 0
-    sort.each_with_index { |li,i| s += (2*i+1-size)*li }
-    s.to_f/(size**2*mean).to_f
+    array.sort.each_with_index { |li,i| s += (2*i+1-array.size)*li }
+    s.to_f/(array.size**2*mean(array)).to_f
   end
 
   ## OLD WAY

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

@@ -1,19 +1,20 @@
 module Math
 
-  # The Kullback-Leibler divergence from this array to that of +q+.
+  # The Kullback-Leibler divergence from distribution +p+ to distribution +q+.
+  #
+  # Both arrays must be the same size and represent probability distributions
+  # (values should be positive).
   #
   # NB: You will possibly want to sort both P and Q before calling this
   # depending on what you're actually trying to measure.
   #
   # http://en.wikipedia.org/wiki/Kullback-Leibler_divergence
   #
-  def self.kldivergence(array, q)
-    fail "Buggy."
-    fail "Cannot compare differently sized arrays." unless size = q.size
-    kld = 0
-    each_with_index { |pi,i| kld += pi*Math::log(pi.to_f/q[i].to_f) }
+  def self.kldivergence(p, q)
+    raise ArgumentError, "Cannot compare differently sized arrays." unless p.size == q.size
+    kld = 0.0
+    p.each_with_index { |pi, i| kld += pi * Math.log(pi.to_f / q[i].to_f) }
     kld
   end
 
 end
-

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

@@ -13,7 +13,7 @@ module Math
   # CREDIT: Ben Koski
   #
   # @non-core
-  #   require 'facets/array/precentile'
+  #   require 'facets/math/percentile'
   #
   def self.percentile(array, pcnt)
     sorted_array = array.sort

data/lib/standard/facets/multiton.rb

@@ -76,7 +76,7 @@
 #
 # Copyright (c) 2007 Christoph Rippel, Thomas Sawyer
 #
-# Ruby License
+# Ruby License / BSD-2 License
 #
 # This module is free software. You may use, modify, and/or redistribute this
 # software under the same terms as Ruby.

data/lib/standard/facets/opendsl.rb

@@ -0,0 +1,33 @@
+# OpenDSL is a clever way to create a plugable
+# free-form domain specific language.
+#
+#   Example = OpenDSL.new do
+#     size do
+#       100
+#     end
+#   end
+#
+#   class Foo
+#     include Example
+#   end
+#
+#   Foo.new.size  #=> 100
+#
+class OpenDSL < Module
+
+  #
+  def initialize(&block)
+    instance_eval(&block) if block_given?
+  end
+
+  #
+  def method_missing(s, *a, &b)
+    if block_given?
+      define_method(s, &b)
+    else
+      super(s, *a, &b)
+    end
+  end
+
+end
+

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

@@ -17,30 +17,15 @@ 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 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
+    @table = {}
     if hash
-      for k,v in hash
-        @table[k.to_sym] = v
-        new_ostruct_member(k)
+      hash.each_pair do |k, v|
+        self[k.to_sym] = v
       end
     end
-    if block && block.arity==1
+    if block && block.arity == 1
       yield self
     end
   end

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

@@ -52,7 +52,8 @@ class Hash
     each_pair do |k,v|
       h[k] = v.to_ostruct_recurse( exclude ) if v.respond_to?(:to_ostruct_recurse)
     end
-    o.merge!(h)
+    h.each_pair { |k, v| o[k.to_sym] = v }
+    o
   end
 end
 

data/lib/standard/facets/ostruct.rb

@@ -1,91 +1,3 @@
 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
-
-  #--
-  # 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.
-  #
-  #   o = OpenStruct.new
-  #   o.a = 1
-  #   o.b = 2
-  #   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.
-  #
-  #   o = OpenStruct.new
-  #   o.ostruct_update(:a => 2)
-  #   o.a  #=> 2
-  #
-  # @deprecated Use #merge! instead.
-  #
-  def ostruct_update(other)
-    warn "OpenSrtuct#ostruct_update has been deprecated. Use #merge! instead."
-    merge!(other)
-  end
-
-  # 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 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 ostruct_merge(other)
-    o = dup
-    o.merge!(other)
-    o
-  end
-
-  # Merge hash data creating a new OpenStruct object.
-  #
-  #   o = OpenStruct.new
-  #   x = o.__merge__(:a => 2)
-  #   x.a  #=> 2
-  #
-  def __merge__(other)
-    o = dup
-    o.merge!(other)
-    o
-  end
-
-end
-
-# Copyright (c) 2005 Thomas Sawyer (Ruby License)

data/lib/standard/facets/pathname/empty.rb

@@ -1,10 +1,2 @@
-class Pathname
-
-  # Is a directory path empty?
-  #
-  # Returns [Boolean]
-  def empty?
-    Dir.glob(::File.join(to_s, '*')).empty?
-  end
-
-end
+# Pathname#empty? is now built into Ruby.
+# This file is kept for backward compatibility but does nothing.

data/lib/standard/facets/pathname/glob.rb

@@ -1,16 +1,26 @@
 class Pathname
 
-  # Glob pathnames.
+  # Extends Ruby's built-in Pathname#glob to accept symbol-based
+  # flags in addition to the standard File::FNM_* constants.
+  #
+  #   Pathname.new('/tmp').glob('*', :dotmatch)
+  #
+  # Supported symbols: :noescape, :pathname, :dotmatch, :casefold
+  #
+  alias_method :_glob_original, :glob
+  private :_glob_original
+
   def glob(match, *opts)
-    flags = glob_flags(opts)
-    Dir.glob(::File.join(self.to_s, match), flags).collect{ |m| self.class.new(m) }
+    if opts.any? { |o| o.is_a?(Symbol) || o.is_a?(String) }
+      flags = glob_flags(opts)
+      Dir.glob(::File.join(self.to_s, match), flags).map { |m| self.class.new(m) }
+    else
+      _glob_original(match, *opts)
+    end
   end
 
   # Return the first glob match.
   #
-  # DEPRECATE: While slightly faster then glob().first, not really worth it
-  # unless this can be rewritten to shortcut on first match (using fnmatch?).
-  # In wich case, is there a better name for this method?
   def glob_first(match, *opts)
     flags = glob_flags(opts)
     file = ::Dir.glob(::File.join(self.to_s, match), flags).first
@@ -28,15 +38,12 @@ class Pathname
   # Does a directory contain a matching entry?
   # Or if the pathname is a file, same as #fnmatch.
   #
-  # TODO: Move to own file? Better name?
-  #
   # Returns [Pathname]
-
-  def include?(pattern,*opts)
+  def include?(pattern, *opts)
     if directory?
-      glob_first(pattern,*opts)
+      glob_first(pattern, *opts)
     else
-      fnmatch(pattern,*opts)
+      fnmatch(pattern, *opts)
     end
   end
 

data/lib/standard/facets/pathname/null.rb

@@ -1,20 +1,9 @@
 class Pathname
 
-  # Platform dependent null device.
-  #
-  # CREDIT: Daniel Burger
-
+  # @deprecated Use Pathname.new(File::NULL) instead.
   def self.null
-    case RUBY_PLATFORM
-    when /mswin/i
-      'NUL'
-    when /amiga/i
-      'NIL:'
-    when /openvms/i
-      'NL:'
-    else
-      '/dev/null'
-    end
+    warn "Pathname.null is deprecated. Use Pathname.new(File::NULL) instead.", uplevel: 1
+    new(File::NULL)
   end
 
 end

data/lib/standard/facets/pic.rb

@@ -0,0 +1,173 @@
+# PIC - Pattern matching based on COBOL-style Edited Pictures.
+#
+# PIC provides a simple alternative to regular expressions for common
+# data format matching. It uses single-character codes to describe the
+# expected format of a string, inspired by COBOL's PICTURE clause.
+#
+# == Picture Characters
+#
+# The following picture characters are supported:
+#
+#   X - Any character (equivalent to regex `.`)
+#   9 - Any digit (equivalent to regex `\d`)
+#   Z - Zero or more digits (equivalent to regex `\d*`)
+#   0 - Any digit (equivalent to regex `\d`)
+#   A - Any letter, upper or lower case (equivalent to regex `[A-Za-z]`)
+#   W - Any word character (equivalent to regex `\w`)
+#   . - Literal period
+#   , - Literal comma
+#   - - Literal hyphen
+#   / - Literal forward slash
+#
+# == Repetition
+#
+# Any picture character can be followed by a count in brackets:
+#
+#   9[3]       - Exactly 3 digits (e.g. `\d{3}`)
+#   9[2,4]     - Between 2 and 4 digits (e.g. `\d{2,4}`)
+#   9[2..4]    - Same as above, alternate syntax
+#
+# == Usage
+#
+#   require 'pic'
+#
+#   # Simple currency pattern
+#   PIC['Z.99'].to_re        #=> /\d*\.\d\d/
+#
+#   # US phone number
+#   PIC['9[3]-9[3]-9[4]'].to_re  #=> /\d{3}\-\d{3}\-\d{4}/
+#
+#   # Match against a string
+#   PIC['99/99/9999'] =~ '12/25/2025'  #=> 0 (match)
+#
+# == Reference
+#
+# Based on the concept of Edited Pictures from COBOL.
+# See: http://www.csis.ul.ie/cobol/course/EditedPics.htm
+#
+# Copyright (c) 2011 Rubyworks (BSD-2-Clause)
+#
+module PIC
+
+  # Shortcut to `PIC::Template.new(pic)`.
+  #
+  # @param [String] pic
+  #   A picture string describing the expected format.
+  #
+  # @return [PIC::Template]
+  #
+  # @example
+  #   PIC['Z.99'].to_re  #=> /\d*\.\d\d/
+  #
+  def self.[](pic)
+    Template.new(pic)
+  end
+
+  # Template class encapsulates a picture string, converts it to a
+  # regular expression, and delegates to it for matching.
+  #
+  # @example
+  #   t = PIC::Template.new('9[3]-9[3]-9[4]')
+  #   t.to_re  #=> /\d{3}\-\d{3}\-\d{4}/
+  #   t =~ '555-123-4567'  #=> 0
+  #
+  class Template
+
+    # New pic template.
+    #
+    # @param [String] pic
+    #   Picture string to use for matching.
+    #
+    def initialize(pic)
+      @pic = pic
+    end
+
+    # The picture string.
+    #
+    # @return [String]
+    #
+    attr :pic
+
+    # Convert picture to a regular expression.
+    #
+    # @return [Regexp]
+    #
+    # @example
+    #   PIC::Template.new('99/99/9999').to_re  #=> /\d\d\/\d\d\/\d\d\d\d/
+    #
+    def to_re
+      re = ''
+      pic.scan(SCAN) do |s,c|
+        re << remap(s) + recnt(c)
+      end
+      Regexp.new(re)
+    end
+
+    # Alias for `#to_re`.
+    alias_method :to_regexp, :to_re
+
+    # Match picture against a given string.
+    #
+    # @param [String] string
+    #   String to match picture against.
+    #
+    # @return [Integer, nil] index position of match, or nil.
+    #
+    def =~(string)
+      to_re =~ string.to_str
+    end
+
+    alias === =~
+
+    # Check for non-match of the picture against a given string.
+    #
+    # @param [String] string
+    #   String to match picture against.
+    #
+    # @return [Boolean]
+    #
+    def !~(string)
+      to_re !~ string.to_str
+    end
+
+  private
+
+    # Map a picture character to its regex equivalent.
+    def remap(s)
+      REMAP[s] || raise(ArgumentError, "unknown picture character: #{s}")
+    end
+
+    # Convert a bracket count to a regex quantifier.
+    def recnt(c)
+      return '' unless c
+
+      case c
+      when /\[(\d+)\.\.(\d+)\]/
+        '{'+$1+','+$2+'}'
+      when /\[(\d+)\,(\d+)\]/
+        '{'+$1+','+$2+'}'
+      when /\[(\d+)\]/
+        '{'+$1+'}'
+      end
+    end
+
+    # Scan pattern for parsing picture strings.
+    SCAN = /(\S)(\[.*?\])?/
+
+    # Mapping of picture characters to regex fragments.
+    REMAP = {
+      'X' => '.',
+      '9' => '\d',
+      'Z' => '\d*',
+      '0' => '\d',
+      'A' => '[A-Za-z]',
+      'W' => '\w',
+      '.' => '\.',
+      ',' => '\,',
+      '-' => '\-',
+      '/' => '\/'
+    }
+
+  end
+
+end