Class: Class

Class | Class
In: | lib/core/facets/class/cattr.rb lib/core/facets/class/descendents.rb lib/core/facets/class/methodize.rb lib/core/facets/class/pathize.rb lib/core/facets/class/prepend.rb lib/core/facets/class/to_proc.rb lib/more/facets/module/class_extend.rb lib/more/facets/preinitialize.rb
Parent: | Object

### Methods

cattr cattr_accessor cattr_reader cattr_writer class_extend descendents methodize new pathize prepend to_proc

### External Aliases

new | -> | postinitialize_new

### Public Instance methods

cattr( *syms )

Creates a class-variable attribute that can be accessed both on an instance and class level.

NOTE This used to be a Module method. But turns out it does not work as expected when included. The class-level method is not carried along. So it is now just a Class method. Accordingly, mattr has been deprecated.

CREDIT: David Heinemeier Hansson

[Source]

    # File lib/core/facets/class/cattr.rb, line 12
      def cattr( *syms )
        writers, readers = syms.flatten.partition{ |a| a.to_s =~ /=$/ }
        writers = writers.collect{ |e| e.to_s.chomp('=').to_sym }
        readers.concat( writers ) # writers also get readers
        cattr_writer( *writers )
        cattr_reader( *readers )
        return readers + writers
      end

cattr_accessor(*syms)

Creates a class-variable attr_accessor that can be accessed both on an instance and class level.

      class MyClass
        cattr_accessor :a
      end

      MyClass.a = 10
      MyClass.a           #=> 10
      mc = MyClass.new
      mc.a                #=> 10

CREDIT: David Heinemeier Hansson

[Source]

    # File lib/core/facets/class/cattr.rb, line 102
      def cattr_accessor(*syms)
        cattr_reader(*syms) + cattr_writer(*syms)
      end

cattr_reader( *syms )

Creates a class-variable attr_reader that can be accessed both on an instance and class level.

      class MyClass
        @@a = 10
        cattr_reader :a
      end

      MyClass.a           #=> 10
      MyClass.new.a       #=> 10

CREDIT: David Heinemeier Hansson

[Source]

    # File lib/core/facets/class/cattr.rb, line 33
      def cattr_reader( *syms )
        syms.flatten.each do |sym|
          class_eval("unless defined? @@\#{sym}\n@@\#{sym} = nil\nend\n\ndef self.\#{sym}\n@@\#{sym}\nend\n\ndef \#{sym}\n@@\#{sym}\nend\n", __FILE__, __LINE__)
        end
        return syms
      end

cattr_writer(*syms)

Creates a class-variable attr_writer that can be accessed both on an instance and class level.

      class MyClass
        cattr_writer :a
        def a
          @@a
        end
      end

      MyClass.a = 10
      MyClass.a            #=> 10
      MyClass.new.a = 29
      MyClass.a            #=> 29

CREDIT: David Heinemeier Hansson

[Source]

    # File lib/core/facets/class/cattr.rb, line 69
      def cattr_writer(*syms)
        syms.flatten.each do |sym|
          class_eval("unless defined? @@\#{sym}\n@@\#{sym} = nil\nend\n\ndef self.\#{sym}=(obj)\n@@\#{sym} = obj\nend\n\ndef \#{sym}=(obj)\n@@\#{sym}=(obj)\nend\n", __FILE__, __LINE__)
        end
        return syms
      end

class_extend(&blk)

For Class, class_extend is the same as class_eval. The alternative is to "undef_method :class_extend", but this seems uneccessarily limited.

[Source]

    # File lib/more/facets/module/class_extend.rb, line 118
      def class_extend(&blk)
        class_eval(&blk)
      end

descendents()

List all descedents of this class.

      class X ; end
      class A < X; end
      class B < X; end
      X.descendents  #=> [A,B]

NOTE: This is a intesive operation. Do not expect it to be super fast.

[Source]

    # File lib/core/facets/class/descendents.rb, line 12
      def descendents
        subclass = []
        ObjectSpace.each_object( Class ) do |c|
          if c.ancestors.include?( self ) and self != c
            subclass << c
          end
        end
        return subclass
      end

methodize()

Translate a class name to a suitable method name.

      My::CoolClass.methodize => "my__cool_class"

[Source]

    # File lib/core/facets/class/methodize.rb, line 9
      def methodize
        name.methodize
      end

new(*args, &blk)

[Source]

    # File lib/more/facets/preinitialize.rb, line 90
      def new(*args, &blk)
        o = allocate

        #if respond_to?(:default_instance_variables)
        #  default_instance_variables.each{|k,v| o.instance_variable_set( "@#{k.to_s.gsub(/\W$/,'')}",v )}
        #end

        a = ancestors
        until a.empty?
          m = a.pop
          #if m.private_instance_methods.include?('preinitialize') or m.public_instance_methods.include?('preinitialize')
          if m.method_defined?('preinitialize') or m.private_method_defined?('preinitialize')
            im = instance_method('preinitialize')
            im.arity == 0 ? im.bind(o).call : im.bind(o).call(*args, &blk)
          end
        end

        o.__send__(:initialize, *args, &blk) if o.object_class.private_method_defined?(:initialize)

        o
      end

pathize()

Converts a class name to a unix path.

      My::CoolClass.pathize  #=> "my/cool_class"

[Source]

    # File lib/core/facets/class/pathize.rb, line 9
      def pathize
        name.pathize
      end

prepend( aspect )

Prepend an "aspect module" to a class.

      class Firetruck
        def put_out_fire(option)
          "Put out #{option}"
        end
      end

      module FastFiretruck
        def put_out_fire(option)
          super("very #{option}!")
        end
      end

      Firetruck.prepend(FastFiretruck)

      ft = Firetruck.new
      ft.put_out_fire('fast') #=> "Put out very fast!"

Implementation of this method has some limitations, in that it works by overriding new and allocate.

CREDIT: Trans

TODO: Perhaps rename this to preallocate, b/c of the way it works. It is not really a clean prepend, like that of Module#prepend.

[Source]

    # File lib/core/facets/class/prepend.rb, line 30
      def prepend( aspect )
        _new      = method(:new)
        _allocate = method(:allocate)
        (class << self; self; end).class_eval do
          define_method(:new) do |*args|
            o = _new.call(*args)
            o.extend aspect
            o
          end
          define_method(:allocate) do |*args|
            o = _allocate.call(*args)
            o.extend aspect
            o
          end
        end
      end

to_proc()

Convert instatiation of a class into a Proc.

      class Person
        def initialize(name)
          @name = name
        end

        def inspect
          @name.to_str
        end
      end

      %w(john bob jane hans).map(&Person) => [john, bob, jane, hans]

CREDIT: Daniel Schierbeck

[Source]

    # File lib/core/facets/class/to_proc.rb, line 18
      def to_proc
        proc{|*args| new(*args)}
      end

[Validate]