facets-glimmer 3.2.0

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

@@ -0,0 +1,99 @@
+class Integer
+
+  # Set a bit.
+  #
+  #   0.bit(4)  #=> 16
+  #
+  # Using a negative figure will clear a bit.
+  #
+  #   10.bit(-4)      #=> 2
+  #
+  # This is more easily seen using binary.
+  #
+  #   0b0100.bit(-3)  #=> 0
+  #
+  # CREDIT: Thomas Sawyer, George Moschovitis
+
+  def bit(bit)
+    if bit < 0
+      mask = (1 << ~bit)
+      self & ~mask
+    else
+      mask = (1 << bit)
+      self | mask
+    end
+  end
+
+  # Clear bit.
+  #
+  # CREDIT: George Moschovitis
+
+  def bit_clear(bit)
+    mask = (1 << bit)
+    self & ~mask
+  end
+
+  # Is a bit set?
+  #
+  #   8.bit?(3)  #=> true
+  #   8.bit?(2)  #=> false
+  #
+  # CREDIT: Thomas Sawyer, George Moschovitis
+
+  def bit?(bit)
+    mask = (1 << bit)
+    (self & mask) != 0
+  end
+
+  # Apply a bitmask.
+  #
+  #   1.bitmask(6) #=> 7
+  #
+  # Using a inverted bitmask clears bits.
+  #
+  #   7.bitmask(~2) #=> 5
+  #   5.bitmask(~2) #=> 5
+  #
+  # CREDIT: George Moschovitis
+
+  def bitmask(mask)
+    if mask < 0
+      self & mask
+    else
+      self | mask
+    end
+  end
+
+  # Is bitmask set?
+  #
+  #   7.bitmask?(7) #=> true
+  #   7.bitmask?(5) #=> true
+  #   8.bitmask?(3) #=> false
+  #
+  # CREDIT: George Moschovitis
+
+  def bitmask?(mask)
+    (self & mask) != 0
+  end
+
+end
+
+
+module Kernel
+
+  # Create a single bit bitmask.
+  #
+  #   Bit(0)  #=> 1
+  #   Bit(1)  #=> 2
+  #   Bit(2)  #=> 4
+  #
+  # This is equivalent to n-shift: "1 << n".
+  #
+  # CREDIT: Thomas Sawyer, George Moschovitis
+
+  def Bit(n)
+    1 << Integer(n)
+  end
+
+end
+

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

@@ -0,0 +1,21 @@
+class Integer
+
+  # Calculate the factorial of an integer.
+  #
+  #   2.factorial  #=> 2
+  #   3.factorial  #=> 6
+  #   4.factorial  #=> 24
+  #
+  # CREDIT: Malte Milatz
+
+  def factorial
+    return 1 if zero?
+    f = 1
+    2.upto(self) { |n| f *= n }
+    f
+  end
+
+  alias_method( :fac, :factorial )
+
+end
+

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

@@ -0,0 +1,19 @@
+class Integer
+
+  # Is +self+ a multiple of a given number?
+  #
+  #   7.multiple?(2)  #=> false
+  #   8.multiple?(2)  #=> true
+  #
+  # CREDIT: Trans
+
+  def multiple?(number)
+    if number.zero?
+      zero? ? true : false
+    else
+      self % number == 0
+    end
+  end
+
+end
+

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

@@ -0,0 +1,18 @@
+class Integer
+
+  # Like #times but returns a collection of the yield results.
+  #
+  #   a = 3.of { |i| "#{i+1}" }
+  #   a #=> [ "1", "2", "3" ]
+  #
+
+  def of(&block)
+    Array.new(self, &block)
+  end
+
+  # Time warn aliases for #of.
+  alias_method :times_collect, :of
+  alias_method :times_map, :of
+
+end
+

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

@@ -0,0 +1,24 @@
+class Integer
+
+  def ordinal
+    if [11,12,13].include?(self % 100)
+      "#{self}th"
+    else
+      case (self % 10)
+      when 1
+        "#{self}st"
+      when 2
+        "#{self}nd"
+      when 3
+        "#{self}rd"
+      else
+        "#{self}th"
+      end
+    end
+  end
+
+  # Rails term.
+  alias_method :ordinalize, :ordinal
+
+end
+

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

@@ -0,0 +1 @@
+require 'facets/roman'

data/lib/core/facets/integer.rb

@@ -0,0 +1,8 @@
+require_relative 'integer/bit.rb'
+require_relative 'integer/bitmask.rb'
+require_relative 'integer/factorial.rb'
+require_relative 'integer/multiple.rb'
+require_relative 'integer/of.rb'
+require_relative 'integer/ordinal.rb'
+#require_relative 'integer/roman.rb'     # uncommon
+

data/lib/core/facets/kernel/__class__.rb

@@ -0,0 +1,9 @@
+module Kernel
+
+  # Defines core method __class__ as an alias of class.
+  # This allows you to use #class as your own method, without
+  # loosing the ability to determine the object's class.
+
+  alias_method :__class__, :class
+
+end

data/lib/core/facets/kernel/__dir__.rb

@@ -0,0 +1,28 @@
+module Kernel
+
+  # Similar to __FILE__, __DIR__ provides the directory
+  # path to the current executing script.
+  #
+  # DEPRECATED: As of Ruby 2.0, which will have #__dir__ method.
+  #
+  # CREDIT: Trans
+
+  def __DIR__(*paths)
+    c = caller.first
+    return nil unless c.rindex(/:\d+(:in `.*')?$/)
+    file = $` # File.dirname(c)
+    return nil if /\A\((.*)\)/ =~ file # eval, etc.
+    #File.expand_path(File.join(File.dirname(file), paths))
+    File.join(File.dirname(file), paths)
+  end
+
+  #--
+  # Old defintion ...
+  #
+  #  def __DIR__
+  #    (/^(.+)?:\d+/ =~ caller[0]) ? File.dirname($1) : nil
+  #  end
+  #++
+
+end
+

data/lib/core/facets/kernel/__get__.rb

@@ -0,0 +1,15 @@
+module Kernel
+
+  # Shadow method for instance_variable_get.
+  def __get__(ivar)
+    #ivar = "@#{ivar}" unless ivar.to_s[0,1] == '@'
+    instance_variable_get(ivar)
+  end
+
+  # Shadow method for instance_variable_set.
+  def __set__(ivar, val)
+    #ivar = "@#{ivar}" unless ivar.to_s[0,1] == '@'
+    instance_variable_set(ivar, val)
+  end
+
+end

data/lib/core/facets/kernel/__set__.rb

@@ -0,0 +1 @@
+require 'facets/kernel/__get__'

data/lib/core/facets/kernel/as.rb

@@ -0,0 +1,116 @@
+require 'facets/functor'
+
+module Kernel
+
+  # Returns a As-functor that allows one to call any
+  # ancestor's method directly of the given object.
+  #
+  #   class AsExample1
+  #     def x ; 1 ; end
+  #   end
+  #
+  #   class AsExample2 < AsExample1
+  #     def x ; 2 ; end
+  #   end
+  #
+  #   class AsExample3 < AsExample2
+  #     def x ; as(AsExample1).x ; end
+  #   end
+  #
+  #   AsExample1.new.x  #=> 1
+  #
+  def as(ancestor, &blk)
+    ##this = self
+    r = As.new(self, ancestor)
+    ##unless r
+    ##  r = As.cache[self][ancestor] = Functor.new do |op, *a, &b|
+    ##    ancestor.instance_method(op).bind(this).call(*a,&b)
+    ##  end
+    ##end
+    r.instance_eval(&blk) if block_given? #yield(r) if block_given?
+    r
+  end
+
+  # Call parent class/module methods once bound to self.
+  #
+  # TODO: Does this have the proper scope for #send?
+  def send_as(ancestor, sym, *args, &blk)
+    ancestor.instance_method(sym).bind(self).call(*args,&blk)
+  end
+
+  #--
+  # Old version ...
+  #
+  #   def send_as(klass, meth, *args, &blk)
+  #     selfclass = Kernel.instance_method(:class).bind(self).call
+  #     raise ArgumentError if ! selfclass.ancestors.include?(klass)
+  #     klass.instance_method(meth).bind(self).call(*args, &blk)
+  #   end
+  #++
+
+  ## DEPRECATED: There's no reliable way to get method name of caller.
+  ## This needs to have the same knowledge that #super itself has and
+  ## I do not thin that is possbile in pure Ruby.
+  ##
+  ## Like super but skips to a specific ancestor module or class.
+  ##
+  ##   class SuperAsExample1
+  ##     def x ; 1 ; end
+  ##   end
+  ##
+  ##   class SuperAsExample2 < SuperAsExample1
+  ##     def x ; 2 ; end
+  ##   end
+  ##
+  ##   class SuperAsExample3 < SuperAsExample2
+  ##     def x ; super_as(SuperAsExample1) ; end
+  ##   end
+  ##
+  ##   SuperAsExample3.new.x  #=> 1
+  ##
+  ##def super_as(klass=self.class.superclass, *args, &blk)
+  ##  unless self.class.ancestors.include?(klass)
+  ##    raise ArgumentError
+  ##  end
+  ##  #called = /\`([^\']+)\'/.match(caller(1).first)[1].to_sym
+  ##  called = File.basename(caller(1).first)
+  ##  klass.instance_method(called).bind(self).call(*args,&blk)
+  ##end
+end
+
+# Support class for Kernel#as.
+#
+# TODO: Deprecate this and use Functor (HigherOrderMessage) instead ?
+
+class As #:nodoc:
+ 
+  class << self
+    alias_method :_new, :new
+
+    def new(subject, ancestor)
+      cache[subject][ancestor] ||= _new(subject, ancestor)
+    end
+    
+    def cache
+      @cache ||= Hash.new{|h,k| h[k]={} }
+    end
+
+    private :_new
+    private :cache
+  end
+
+  # Privatize all methods except #binding an operators.
+  private(*instance_methods.select { |m| m !~ /(^__|^\W|^binding$)/ })
+
+  def initialize(subject, ancestor)
+    @subject = subject
+    @ancestor = ancestor
+  end
+
+  private
+
+  def method_missing(sym, *args, &blk)
+    @ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
+  end
+
+end

data/lib/core/facets/kernel/ask.rb

@@ -0,0 +1,28 @@
+module Kernel
+
+  module_function
+
+  # Very simple convenience method to get user input
+  # via the console. A prompt will be sent to $stdout,
+  # if given, and the input taken from $stdin...
+  #
+  #   ask "Are you happy? [Yn]"
+  #
+  # On the command line one would see...
+  #
+  #   Are you happy? [Yn]
+  #
+  # Responding...
+  #
+  #   Are you happy? [Yn] Y <ENTER>
+  #
+  # The ask method would return "Y".
+
+  def ask(prompt=nil)
+    $stdout << "#{prompt}"
+    $stdout.flush
+    $stdin.gets.chomp!
+  end
+
+end
+

data/lib/core/facets/kernel/assign.rb

@@ -0,0 +1,74 @@
+require 'facets/na'
+
+module Kernel
+
+  # Assign via writer using arguments, hash or associative array.
+  #
+  # Using name-value arguments:
+  #
+  #   object = Object.new
+  #
+  #   object.assign(:a, 1)
+  #   object.assign(:b, 2)
+  #
+  # Using a hash:
+  #
+  #   object.assign(:a => 1, :b => 2)
+  #
+  # Use an associative array:
+  #
+  #   object.assign([[:a, 1], [:b, 2]])
+  #
+  # These are all equivalent to:
+  #
+  #   object.a = 1 if object.respond_to?(:a=)
+  #   object.b = 2 if object.respond_to?(:b=)
+  #
+  # Using an associative array instead of a hash guarantees order of assignment
+  # for older versions of Ruby (< 1.8.7).
+  #
+  # TODO: Should this be called #set instead? Consider Module#set in this
+  # question, and also #set_from as the alias of #assign_from.
+
+  def assign(data=nil, value=NA)
+    return self unless data
+
+    if value==NA
+      data.each do |(k,v)|
+        __send__("#{k}=", v) if respond_to?("#{k}=")
+      end
+    else
+      __send__("#{data}=", value) if respond_to?("#{data}=")
+    end
+    self
+  end
+
+  # Set attribute writers using like readers from another object.
+  #
+  #   class AssignExample
+  #     attr_accessor :a, :b
+  #     def initialize(a, b)
+  #        @a, @b = a, b
+  #     end
+  #   end
+  #
+  #   obj1 = AssignExample.new(1,2)
+  #   obj2 = AssignExample.new(3,4)
+  #
+  #   obj2.assign_from(obj1, :a, :b)
+  #
+  #   obj2.a  #=> 1
+  #   obj2.b  #=> 2
+  #
+  # TODO: Should this be called #set_from ?
+
+  def assign_from(obj, *fields)
+    fields.flatten.each do |k|
+      send("#{k}=", obj.__send__("#{k}"))  #if self.respond_to?("#{k}=") && obj.respond_to?("#{k}")
+    end
+  end
+
+  ## DEPRECATED: Original name for #assign_from.
+  ##alias_method :set_from, :assign_from
+end
+

data/lib/core/facets/kernel/assign_from.rb

@@ -0,0 +1 @@
+require 'facets/kernel/assign'

data/lib/core/facets/kernel/attr_singleton.rb

@@ -0,0 +1,59 @@
+module Kernel
+
+  # Creates singleton attr_readers.
+  #
+  #   obj = Object.new
+  #
+  #   obj.attr_singleton_reader :x, :y
+  #
+  #   attr_singleton_reader :x, :y
+  #
+  # CREDIT: Trans
+
+  def attr_singleton_reader(*args)
+    #h, a = *args.partition{|a| Hash===a}
+    (class << self ; self ; end).send( :attr_reader, *args )
+    #(class << self ; self ; end).send( :attr_reader, *h.keys )
+    #h.each { |k,v| instance_variable_set("@#{k}", v) }
+  end
+
+  # Create singleton attr_writers.
+  #
+  #   obj = Object.new
+  #
+  #   obj.attr_singleton_writer :x, :y
+  #
+  #   obj.x = 3
+  #   obj.y = 4
+  #
+  # CREDIT: Trans
+
+  def attr_singleton_writer(*args)
+    #h, a = *args.partition{|a| Hash===a}
+    (class << self ; self ; end).send( :attr_writer, *args )
+    #(class << self ; self ; end).send( :attr_writer, *h.keys )
+    #h.each { |k,v| instance_variable_set("@#{k}", v) }
+  end
+
+  # Create singleton attr_accessors.
+  #
+  #   obj = Object.new
+  #
+  #   obj.attr_singleton_accessor :x, :y
+  #
+  #   obj.x = 3
+  #   obj.y = 4
+  #   obj.x      #=> 3
+  #   obj.y      #=> 4
+  #
+  # CREDIT: Trans
+
+  def attr_singleton_accessor(*args)
+    #h, a = *args.partition{|a| Hash===a}
+    (class << self ; self ; end).send( :attr_accessor, *args )
+    #(class << self ; self ; end).send( :attr_accessor, *h.keys )
+    #h.each { |k,v| instance_variable_set("@#{k}", v) }
+  end
+
+end
+

data/lib/core/facets/kernel/blank.rb

@@ -0,0 +1,84 @@
+module Kernel
+  # An object is blank if it's nil, empty, or a whitespace string.
+  # For example, "", "   ", nil, [], and {} are blank.
+  #
+  # This simplifies...
+  #
+  #   if !address.nil? && !address.empty?
+  #
+  # to...
+  #
+  #   if !address.blank?
+  #
+  def blank?
+    return empty? if respond_to?(:empty?)
+    !self
+  end
+
+  # An object is present if it's not blank.
+  def present?
+    !blank?
+  end
+
+  # Returns object if it's #present? otherwise returns nil.
+  # object.presence is equivalent to object.present? ? object : nil.
+  #
+  # This is handy for any representation of objects where blank is the same
+  # as not present at all.  For example, this simplifies a common check for
+  # HTTP POST/query parameters...
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # becomes...
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  #
+  def presence
+    self if present?
+  end
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  def blank?
+    false
+  end
+end
+
+class Array
+  alias_method :blank?, :empty?
+end
+
+class Hash
+  alias_method :blank?, :empty?
+end
+
+class String
+  # Is this string just whitespace?
+  #
+  #   "abc".blank?  #=> false
+  #   "   ".blank?  #=> true
+  def blank?
+    /\S/ !~ self
+  end
+end
+
+class Numeric
+  def blank?
+    false
+  end
+end
+

data/lib/core/facets/kernel/call_stack.rb

@@ -0,0 +1 @@
+require 'facets/kernel/callstack'

data/lib/core/facets/kernel/callstack.rb

@@ -0,0 +1,56 @@
+module Kernel
+
+  alias_method :pp_callstack, :caller
+  alias_method :pp_call_stack, :caller
+
+  # Parse a caller string and break it into its components,
+  # returning an array composed of:
+  #
+  # * file (String)
+  # * lineno (Integer)
+  # * method (Symbol)
+  #
+  # For example, from irb
+  #
+  #     callstack(1)
+  #
+  # _produces_ ...
+  #
+  #     [["(irb)", 2, :irb_binding],
+  #       ["/usr/lib/ruby/1.8/irb/workspace.rb", 52, :irb_binding],
+  #       ["/usr/lib/ruby/1.8/irb/workspace.rb", 52, nil]]
+  #
+  # Note: If the user decides to redefine caller() to output data
+  # in a different format, _prior_ to requiring this, then the
+  # results will be indeterminate.
+  #
+  # CREDIT: Trans
+
+  def callstack(level = 1)
+    call_str_array = pp_callstack(level)
+    stack = []
+    call_str_array.each{ |call_str|
+      file, lineno, method = call_str.split(':')
+      if method =~ /in `(.*)'/ then
+        method = $1.intern()
+      end
+      stack << [file, lineno.to_i, method]
+    }
+    stack
+  end
+
+  alias_method :call_stack, :callstack
+
+end
+
+
+class Binding
+
+  # Returns the call stack, in array format.
+  def callstack(level=1)
+    eval( "callstack( #{level} )" )
+  end
+
+  alias_method :call_stack, :callstack
+end
+

data/lib/core/facets/kernel/case.rb

@@ -0,0 +1,8 @@
+module Kernel
+
+  def case?(*matchers)
+    matchers.all?{ |m| m === self }
+  end unless method_defined?(:case?)
+
+end
+