Class: HammerBuilder::DynamicClasses::Classes

Inherits:
Object
  • Object
show all
Defined in:
lib/hammer_builder/dynamic_classes.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(base) ⇒ Classes

Returns a new instance of Classes.



83
84
85
86
87
88
89
 
# File 'lib/hammer_builder/dynamic_classes.rb', line 83

def initialize(base)
  raise unless base.is_a? Class
  @base              = base
  @class_definitions = { }
  @class_extensions  = { }
  @classes           = { }
end

Instance Attribute Details

#base ⇒ Object (readonly)

Returns the value of attribute base.



81
82
83
 
# File 'lib/hammer_builder/dynamic_classes.rb', line 81

def base
  @base
end

#class_definitions ⇒ Object (readonly)

Returns the value of attribute class_definitions.



81
82
83
 
# File 'lib/hammer_builder/dynamic_classes.rb', line 81

def class_definitions
  @class_definitions
end

#classes ⇒ Object (readonly)

Returns the value of attribute classes.



81
82
83
 
# File 'lib/hammer_builder/dynamic_classes.rb', line 81

def classes
  @classes
end

Instance Method Details

#[](name) ⇒ Class

Returns defined class.

Returns:

  • (Class) —

    defined class



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/hammer_builder/dynamic_classes.rb', line 124

def [](name)
  return @classes[name] if @classes[name]
  return nil unless klass_definition = class_definition(name)

  superclass = case klass_definition.superclass_or_name
                 when Symbol then
                   self[klass_definition.superclass_or_name]
                 when Class then
                   klass = Class.new(klass_definition.superclass_or_name)
                   klass.send :include, Describable
                   klass._description = "Describable#{klass_definition.superclass_or_name}"
                   klass
                 when nil then
                   DescribableClass
               end

  klass              = Class.new(superclass, &klass_definition.definition)
  klass._description = "#{base}.dc[:#{klass_definition.name}]"

  class_extensions(name).each do |klass_extension|
    klass              = Class.new(klass, &klass_extension.definition)
    klass._description = "#{base}.dc[:#{klass_extension.name}]"
  end

  @classes[name] = klass
end

#class_names ⇒ Object 



151
152
153
 
# File 'lib/hammer_builder/dynamic_classes.rb', line 151

def class_names
  ancestors.map(&:class_definitions).map(&:keys).flatten
end

#def_class(name, superclass_or_name = nil) { ... } ⇒ Object

define a class when Symbol then dynamic class is found when Class then this class is used when nil then Object is used

Parameters:

  • name (Symbol)
  • superclass_or_name (Symbol, Class, nil) (defaults to: nil)

Yields:

  • definition block is evaluated inside the class defining it

Raises:

  • (ArgumentError) 


98
99
100
101
102
103
104
105
106
 
# File 'lib/hammer_builder/dynamic_classes.rb', line 98

def def_class(name, superclass_or_name = nil, &definition)
  raise ArgumentError, "name is not a Symbol" unless name.is_a?(Symbol)
  unless superclass_or_name.is_a?(Symbol) || superclass_or_name.is_a?(Class) || superclass_or_name.nil?
    raise ArgumentError, "superclass_or_name is not a Symbol, Class or nil"
  end
  raise ArgumentError, "definition is nil" unless definition
  raise ArgumentError, "Class #{name} already defined" if class_definition(name)
  @class_definitions[name] = ClassDefinition.new(name, base, superclass_or_name, definition)
end

#extend_class(name) { ... } ⇒ Object

extends already defined class by adding a child,

Parameters:

  • name (Symbol)

Yields:

  • definition block is evaluated inside the class extending it

Raises:

  • (ArgumentError) 


111
112
113
114
115
116
 
# File 'lib/hammer_builder/dynamic_classes.rb', line 111

def extend_class(name, &definition)
  raise ArgumentError, "name is not a Symbol" unless name.is_a?(Symbol)
  raise ArgumentError, "definition is nil" unless definition
  raise ArgumentError, "Class #{name} not defined" unless class_definition(name)
  @class_extensions[name] = ClassExtension.new(name, base, definition)
end

#load! ⇒ Object

triggers loading of all defined classes



119
120
121
 
# File 'lib/hammer_builder/dynamic_classes.rb', line 119

def load!
  class_names.each { |name| self[name] }
end