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
150
151
152
153
154
155
156
 
# 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

  set_up_klass = lambda do |klass, description, block|
    klass._description = description
    klass.instance_variable_set :@dynamic_class_base, base
    klass.singleton_class.send :attr_reader, :dynamic_class_base
    klass.class_eval &block
  end

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

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

  @classes[name] = klass
end

#class_names ⇒ Object 



158
159
160
 
# File 'lib/hammer_builder/dynamic_classes.rb', line 158

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