Class: Object

### Home Classes Methods

### In Files

- lib/extlib/blank.rb
- lib/extlib/object.rb
- lib/extlib/try_dup.rb

### Parent

BasicObject

### Methods

- #blank?
- #full_const_get
- #full_const_set
- #in?
- #instance_variable_defined?
- #make_module
- #meta_class
- #quacks_like?
- #try_call
- #try_dup

### Files

- LICENSE
- README.rdoc

### Class/Module Index

Quicksearch

- Extlib
- Extlib::Assertions
- Extlib::ByteArray
- Extlib::Hook
- Extlib::Hook::ClassMethods
- Extlib::Inflection
- Extlib::LocalObjectSpace
- Extlib::Logger
- Extlib::Pooling
- Extlib::Pooling::InvalidResourceError
- Extlib::Pooling::Pool
- Extlib::SimpleSet
- Gem
- Gem::SourceIndex
- Gem::Specification
- LazyModule
- LazyModule::ClassMethods
- Array
- Class
- DateTime
- Dictionary
- FalseClass
- Hash
- LazyArray
- Mash
- Module
- NilClass
- Numeric
- Object
- ObjectSpace
- Pathname
- REXMLUtilityNode
- String
- Struct
- Symbol
- Time
- ToHashParser
- TrueClass
- VirtualFile

No matching classes.

# Object

### Public Instance Methods

blank?() click to toggle source

Returns true if the object is nil or empty (if applicable)

    [].blank?         #=>  true
    [1].blank?        #=>  false
    [nil].blank?      #=>  false

@return [TrueClass, FalseClass]

@api public

    # File lib/extlib/blank.rb, line 12
    def blank?
      nil? || (respond_to?(:empty?) && empty?)
    end

full_const_get(name) click to toggle source

@param name<String> The name of the constant to get, e.g. "Merb::Router".

@return [Object] The constant corresponding to the name.

    # File lib/extlib/object.rb, line 67
    def full_const_get(name)
      list = name.split("::")
      list.shift if list.first.blank?
      obj = self
      list.each do |x|
        # This is required because const_get tries to look for constants in the
        # ancestor chain, but we only want constants that are HERE
        obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x)
      end
      obj
    end

full_const_set(name, value) click to toggle source

@param name<String> The name of the constant to get, e.g. "Merb::Router". @param value<Object> The value to assign to the constant.

@return [Object] The constant corresponding to the name.

    # File lib/extlib/object.rb, line 83
    def full_const_set(name, value)
      list = name.split("::")
      toplevel = list.first.blank?
      list.shift if toplevel
      last = list.pop
      obj = list.empty? ? Object : Object.full_const_get(list.join("::"))
      obj.const_set(last, value) if obj && !obj.const_defined?(last)
    end

in?(arrayish,*more) click to toggle source

@param arrayish<include?> Container to check, to see if it includes the object.

@param *more<Array> | additional args, will be flattened into arrayish

@return [Boolean]

    True if the object is included in arrayish (+ more)

@example 1.in?() #=> true @example 1.in?(1,2,3) #=> true

    # File lib/extlib/object.rb, line 163
    def in?(arrayish,*more)
      arrayish = more.unshift(arrayish) unless more.empty?
      arrayish.include?(self)
    end

instance_variable_defined?(variable) click to toggle source

    # File lib/extlib/object.rb, line 174
    def instance_variable_defined?(variable)
      instance_variables.include?(variable.to_s)
    end

make_module(string) click to toggle source

Defines module from a string name (e.g. Foo::Bar::Baz) If module already exists, no exception raised.

@param name<String> The name of the full module name to make

@return [nil]

    # File lib/extlib/object.rb, line 98
    def make_module(string)
      current_module = self
      string.split('::').each do |part|
        current_module = if current_module.const_defined?(part)
          current_module.const_get(part)
        else
          current_module.const_set(part, Module.new)
        end
      end
      current_module
    end

meta_class() click to toggle source

Extracts the singleton class, so that metaprogramming can be done on it.

@return [Class] The meta class.

@example [Setup]

    class MyString < String; end

    MyString.instance_eval do
      define_method :foo do
        puts self
      end
    end

    MyString.meta_class.instance_eval do
      define_method :bar do
        puts self
      end
    end

    def String.add_meta_var(var)
      self.meta_class.instance_eval do
        define_method var do
          puts "HELLO"
        end
      end
    end

@example

    MyString.new("Hello").foo #=> "Hello"

@example

    MyString.new("Hello").bar
      #=> NoMethodError: undefined method `bar' for "Hello":MyString

@example

    MyString.foo
      #=> NoMethodError: undefined method `foo' for MyString:Class

@example

    MyString.bar
      #=> MyString

@example

    String.bar
      #=> NoMethodError: undefined method `bar' for String:Class

@example

    MyString.add_meta_var(:x)
    MyString.x #=> HELLO

@details [Description of Examples]

    As you can see, using #meta_class allows you to execute code (and here,
    define a method) on the metaclass itself. It also allows you to define
    class methods that can be run on subclasses, and then be able to execute
    code on the metaclass of the subclass (here MyString).

    In this case, we were able to define a class method (add_meta_var) on
    String that was executable by the MyString subclass. It was then able to
    define a method on the subclass by adding it to the MyString metaclass.

    For more information, you can check out _why's excellent article at:
    http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html

    # File lib/extlib/object.rb, line 62
    def meta_class() class << self; self end end

quacks_like?(duck) click to toggle source

@param duck<Symbol, Class, Array> The thing to compare the object to.

@note

    The behavior of the method depends on the type of duck as follows:
    Symbol:: Check whether the object respond_to?(duck).
    Class:: Check whether the object is_a?(duck).
    Array::
      Check whether the object quacks_like? at least one of the options in the
      array.

@return [Boolean]

    True if the object quacks like duck.

    # File lib/extlib/object.rb, line 122
    def quacks_like?(duck)
      case duck
      when Symbol
        self.respond_to?(duck)
      when Class
        self.is_a?(duck)
      when Array
        duck.any? {|d| self.quacks_like?(d) }
      else
        false
      end
    end

try_call(*args) click to toggle source

If receiver is callable, calls it and returns result. If not, just returns receiver itself

@return [Object]

    # File lib/extlib/object.rb, line 147
    def try_call(*args)
      if self.respond_to?(:call)
        self.call(*args)
      else
        self
      end
    end

try_dup() click to toggle source

Override this in a child if it cannot be dup'ed

@return [Object]

    # File lib/extlib/object.rb, line 138
    def try_dup
      self.dup
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.