mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/here.rb

@@ -0,0 +1,12 @@
+module Kernel
+
+  # A shorthand pronoun for binding().
+  #
+  #   a = 3
+  #   b = here
+  #   eval( "a", b )  #=> 3
+  #
+  alias_method :here, :binding
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/in.rb

@@ -0,0 +1,13 @@
+module Kernel
+
+  # Is self included in other?
+  #
+  #   5.in?(0..10)       #=> true
+  #   5.in?([0,1,2,3])   #=> false
+  #
+  def in?(other)
+    other.include?(self)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/instance.rb

@@ -0,0 +1,19 @@
+require 'facets/functor'
+
+module Kernel
+
+  # Access internals of an object as if with
+  # private access.
+  #
+  #   class X
+  #     metaclass.instance.attr_reader :x
+  #   end
+  #
+  def instance
+    @_instance_functor ||= Functor.new do |op,*args|
+      send(op,*args)
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/instance_assign.rb

@@ -0,0 +1,41 @@
+module Kernel
+
+  # Return instance variable values in an array.
+  #
+  #   class X
+  #     def initialize(a,b)
+  #       @a, @b = a, b
+  #     end
+  #   end
+  #
+  #   x = X.new(1,2)
+  #
+  #   x.instance_values   #=> { "a"=>1, "b"=>2 }
+  #
+  # WARNING: #instance_values will be deprecated. Use instance_vars.to_hash instead.
+
+  def instance_values
+    instance_variables.inject({}) do |values, name|
+      values[name[1..-1]] = instance_variable_get(name)
+      values
+    end
+  end
+
+  # Set instance variables using a hash.
+  #
+  #   instance_assign('@a'=>1, '@b'=>2)
+  #   @a   #=> 1
+  #   @b   #=> 2
+  #
+  # WARNING: #instance_assign will be deprecated. Use instance_vars.update instead.
+
+  def instance_assign(hash)
+    hash.each do |k,v|
+      k = "@#{k}" if k !~ /^@/
+      instance_variable_set(k, v)
+    end
+    return self
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/instance_class.rb

@@ -0,0 +1,24 @@
+module Kernel
+
+  # Kernel extension prefixed by instance_ which provide
+  # internal (eg private) access to the object.
+  # Kernel extension using instance_ prefix which is beneficial
+  # to separation of metaprogramming from general programming.
+  # object_ methods, in contrast to the instance_ methods,
+  # do not access internal state.
+
+  # Easy access to an object qua class, otherwise known
+  # as the object's metaclass or singleton class. This
+  # implemnetation alwasy returns the class, even if a
+  # block is provided to eval against it.
+  #
+  #     It is what it is.
+  #
+  #  CREDIT: Trans
+
+  def instance_class(&block)
+    (class << self; self; end).module_eval(&block) if block
+    (class << self; self; end)
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/instance_exec.rb

@@ -0,0 +1,40 @@
+class Object #module Kernel
+
+  unless defined? instance_exec # 1.9
+
+    module InstanceExecMethods #:nodoc:
+    end
+    include InstanceExecMethods
+
+    # Evaluate the block with the given arguments within the context of
+    # this object, so self is set to the method receiver.
+    #
+    # From Mauricio's http://eigenclass.org/hiki/bounded+space+instance_exec
+    #
+    # This version has been borrowed from Rails for compatibility sake.
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(method_name = "__instance_exec#{n}")
+        InstanceExecMethods.module_eval { define_method(method_name, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+
+      begin
+        send(method_name, *args)
+      ensure
+        InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
+      end
+    end
+
+    # OLD VERSION
+    #def instance_exec(*arguments, &block)
+    #  block.bind(self)[*arguments]
+    #end
+
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/instance_send.rb

@@ -0,0 +1,7 @@
+module Kernel
+
+  # Private send.
+  alias_method :instance_send, :__send__
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/instance_variables.rb

@@ -0,0 +1,99 @@
+module Kernel
+
+  def instance_vars
+    InstanceVariables.new(self)
+  end
+
+end
+
+
+class InstanceVariables
+
+  include Enumerable
+
+  def initialize(delegate)
+    @delegate = delegate
+  end
+
+  def instance_delegate
+    @delegate
+  end
+
+  def each
+    @delegate.instance_variables.each do |name|
+      yield(name[1..-1].to_sym, @delegate.instance_variable_get(name))
+    end
+  end
+
+  def to_hash
+    h = {}
+    each do |name, value|
+      h[name] = value
+    end
+    h
+  end
+
+  def [](name)
+    name = atize(name)
+    @delegate.instance_variable_get(name)
+  end
+
+  def []=(name, value)
+    name = atize(name)
+    @delegate.instance_varaible_set(name,value)
+  end
+
+  def <<(pair)
+    name, value = *pair
+    name = atize(name)
+    @delegate.instance_varaible_set(name, value)
+  end
+
+  def update(hash)
+    hash.each do |pair|
+      self << pair
+    end
+  end
+
+  def keys
+    @delegate.instance_variables.collect do |name|
+      name[1..-1].to_sym
+    end
+  end
+
+  def names
+    @delegate.instance_variables.collect do |name|
+      name[1..-1]
+    end
+  end
+
+  def values
+    @delegate.instance_variables.collect do |name|
+      @delegate.instance_variable_get(name)
+    end
+  end
+
+  private
+
+    def atize(name)
+      name !~ /^@/ ? "@#{name}" : name
+    end
+
+end
+
+
+if $0 == __FILE__
+
+  class Friend
+    attr_accessor :name, :age, :phone
+    def initialize(name, age, phone)
+      @name, @age, @phone = name, age, phone
+    end
+  end
+
+  f1 = Friend.new("John", 30, "555-1212")
+  p f1.variables
+  p f1.variables.to_hash
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/maybe.rb

@@ -0,0 +1,18 @@
+module Kernel
+
+  # Random generator that returns true or false.
+  # Can also take a block that has a 50/50 chance to being executed.
+  #
+  #   maybe  #=> true
+  #   maybe  #=> false
+  #
+  def maybe(chance = 0.5, &block)
+    if block then
+      yield if rand < chance
+    else
+      rand < chance
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/not_nil.rb

@@ -0,0 +1,17 @@
+module Kernel
+
+  # The opposite of #nil?.
+  #
+  #   "hello".not_nil?     # -> true
+  #   nil.not_nil?         # -> false
+  #
+  #  CREDIT: Gavin Sinclair
+
+  def not_nil?
+    not nil?
+  end
+
+  alias_method :non_nil?, :not_nil?
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/object_class.rb

@@ -0,0 +1,10 @@
+module Kernel
+
+  # Defines object_classas an alias of class.
+  # This is an alternative to __class__, akin to
+  # #object_id.
+
+  alias_method :object_class, :class
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/object_hexid.rb

@@ -0,0 +1,12 @@
+module Kernel
+
+  # Returns the object id as a string in hexideciaml,
+  # which is how Ruby reports them with inspect.
+  #
+  #   "ABC".object_hexid  #=> "0x402d359c"
+
+  def object_hexid
+    return "0x" << ('%.x' % (2*self.__id__))  #[1..-1]
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/object_send.rb

@@ -0,0 +1,32 @@
+module Kernel
+
+  # Send only to public methods.
+  #
+  #   class X
+  #     private
+  #     def foo; end
+  #   end
+  #
+  #   X.new.object_send(:foo)
+  #   => NoMethodError: private method `foo' called for #<X:0xb7ac6ba8>
+  #
+  # TODO: object_send needs to change for 1.9.
+  #
+  #  CREDIT: Trans
+  #--
+  # Which implementation is faster?
+  #++
+
+  def object_send(name,*args,&blk)
+    #instance_eval "self.#{name}(*args)"
+    if respond_to?(name)
+      send(name,*args,&blk)
+    else #if respond_to?(:method_missing)
+      method_missing(name,*args,&blk)
+    #else
+    #  raise NoMethodError
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/p.rb

@@ -0,0 +1,24 @@
+module Kernel
+
+  # Alternate to standard #p method that outputs
+  # Kernel#inspect to stdout, but also passes through
+  # the orginal argument(s).
+  #
+  #   x = 1
+  #   r = 4 + q(1)
+  #   p r
+  #
+  # produces
+  #
+  #   1
+  #   5
+  #
+  # DEPRECATE AS OF 1.9, _if_ #p will then do this too.
+
+  def p(*x)
+    x.each{ |e| puts e.inspect } #p(*x)
+    x.size > 1 ? x : x.last #x.last
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/populate.rb

@@ -0,0 +1,73 @@
+module Kernel
+
+  # Assign via accessor methods using a hash, associative
+  # array or block.
+  #
+  #   object.populate( :a => 1, :b => 2 )
+  #   object.populate( :a, 1, :b, 2 )
+  #   object.populate( [:a, 1], [:b, 2] )
+  #   object.populate( *[[:a, 1], [:b, 2]] )
+  #   object.populate{ |s| s.a = 1; s.b = 2 }
+  #
+  # These are all the same as doing:
+  #
+  #   object.a = 1
+  #   object.b = 2
+  #
+  # Using an associative array instead of hash guarentees 
+  # order of assignemnt.
+  #
+  # Using a hash or array will not raise an error if the
+  # accessor does not exits --it will simply be skipped.
+  #
+  # TODO: Better name, #set_with ?
+
+  def populate(data=nil) #:yield:
+    if data
+      data.each do |k,v|
+        send("#{k}=", v) if respond_to?("#{k}=")
+      end
+    end
+    yield(self) if block_given?
+    self
+  end
+
+  # Set setter methods using a another object.
+  #
+  #   class X
+  #     attr_accessor :a, :b
+  #     def initialize( a, b )
+  #        @a,@b = a,b
+  #     end
+  #   end
+  #
+  #   obj1 = X.new( 1, 2 )
+  #   obj2 = X.new
+  #
+  #   obj2.set_from(obj1)
+  #
+  #   obj2.a  #=> 1
+  #   obj2.b  #=> 2
+  #
+  # TODO: pepulate_from(obj) ?
+
+  def set_from(obj, *fields)
+    unless fields.empty?
+      fields.each do |k|
+        send( "#{k}=", obj.send("#{k}") )  #if self.respond_to?("#{k}=") && obj.respond_to?("#{k}")
+      end
+    else
+      setters = methods.collect { |m| m =~ /=$/ }
+      setters.each do |setter|
+        getter = setter.chomp('=')
+        if obj.respond_to?(getter)
+          send( setter, obj.send(getter) )
+          fields < getter
+        end
+      end
+    end
+    fields
+  end
+
+end
+