class Object

Constants

ArgVector

Argvector

Argvector provides a very simple means of parsing command line arguments.

Unlike other more complex libs this provides only the most basic and standard parsing functionality. In many cases that’s all one really needs.

Usage is straight foward. Simply instantiate the class and query it for the particular “views” of the command line you want.

cargs = Argvector.new("-a foo -b=2")

cargs.parameters    #=> [['foo'],{'a'=>true,'b'=>'2'}]
cargs.flags         #=> ['a']
cargs.preoptions    #=> {'a'=>true}
cargs.preflags      #=> ['a']
cargs.subcommand    #=> ['foo', [], {'b'=>'2'}]
Enumerator

for Ruby 1.8 -> 1.9 transition

RUBY_ENGINE

Public Instance Methods

against(*msg, &blk) click to toggle source

Objectified message or block application. Only a message or a block can be given, not both.

msg - method and arguments [Array] blk - procedure block [Proc]

Examples

a = [1,2,3,4,5]
c = a.against(:>, 2)
c.select  #=> [3,4,5]

a = [1,2,3,4,5]
c = a.against(:>)
c.select(2)  #=> [3,4,5]

Returns [Functor]

TODO: Better name for this method?

# File lib/standard/facets/against.rb, line 25
def against(*msg, &blk)
  raise ArgumentError, "too many arguments" if blk && !msg.empty?

        this = self

  blk = ::Proc.new{ |x,*a| x.__send__(*msg, *a) } unless blk

  #if blk
                Functor.new do |m, *a, &b|
                        if b
                          b2 = ::Proc.new{ |*x| blk.call(*b.call(*x), *a) }
      else
        b2 = blk
                        end
                        this.__send__(m, &b2)
                end
  #else
        #    Functor.new do |m, *a, &b|
        #            if b
        #              b2 = ::Proc.new{ |*x| b.call(*x).__send__(*msg, *a) }
        #            else
        #              b2 = ::Proc.new{ |x| x.__send__(*msg, *a) }
        #            end
        #            this.__send__(m, &b2)
        #    end
  #end
end
clone?() click to toggle source
# File lib/core/facets/object/dup.rb, line 23
def clone? ; true ; end
dup!() click to toggle source

Override this in a child class if it cannot be dup’ed.

obj1 = Object.new
obj2 = obj1.dup!
obj2.equal?(obj1)    #=> false

CREDIT: Dan Kubb (extlib)

# File lib/core/facets/object/dup.rb, line 9
def dup!
  dup
end
dup?() click to toggle source

Can you safely call dup on this object?

Returns false for nil, false, true, symbols, and numbers; true otherwise.

# File lib/core/facets/object/dup.rb, line 22
def dup?   ; true ; end
instance_exec(*args, &block) click to toggle source

Evaluate the block with the given arguments within the context of this object, so self is set to the method receiver.

From Mauricio’s eigenclass.org/hiki/bounded+space+instance_exec

This version has been borrowed from Rails for compatibility sake.

NOTE: This is not a common core extension (due to the use of thread.rb) and is not loaded automatically when using require 'facets'. However it is a core method in Ruby 1.9, so this only matters for users of Ruby 1.8.x or below.

@uncommon

require 'facets/kernel/instance_exec'
# File lib/core/facets/kernel/instance_exec.rb, line 27
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
itself() click to toggle source

An identity method that provides access to an object’s ‘self’.

Example

[1,2,3,4,5,1,2,2,3].group_by(&:itself)
#=> {1=>[1, 1], 2=>[2, 2, 2], 3=>[3, 3], 4=>[4], 5=>[5]}

CREDIT: Michael Kohl

# File lib/core/facets/object/itself.rb, line 12
def itself
  self
end
null?() click to toggle source
# File lib/standard/facets/nullclass.rb, line 33
def null?
  false
end
object_state(data=nil) click to toggle source

Get or set state of object. You can think of object_state as an in-code form of marshalling.

class StateExample
  attr_reader :a, :b
  def initialize(a,b)
    @a, @b = a, b
  end
end

obj = StateExample.new(1,2)
obj.a  #=> 1
obj.b  #=> 2

obj.object_state  #=> {:a=>1, :b=>2}

obj.object_state(:a=>3, :b=>4)
obj.a  #=> 3
obj.b  #=> 4

For most object’s this is essentially the same as instance.to_h. But for data structures like Array and Hash it returns a snapshot of their contents, not the state of their instance variables.

# File lib/core/facets/object/object_state.rb, line 28
def object_state(data=nil)
  if data
    instance_variables.each do |iv|
      name = iv.to_s.sub(/^[@]/, '').to_sym
      instance_variable_set(iv, data[name])
    end
  else
    data = {}
    instance_variables.each do |iv|
      name = iv.to_s.sub(/^[@]/, '').to_sym
      data[name] = instance_variable_get(iv)
    end
    data
  end
end
temporary_directory() click to toggle source
# File lib/core/facets/applique/file_helpers.rb, line 2
def temporary_directory
  @temporary_directory ||= 'tmp'
end
try_dup() click to toggle source

Alternative name for dup!

# File lib/core/facets/object/dup.rb, line 14
def try_dup
  dup!
end