Class: HammerBuilder::DynamicClasses::Classes

Inherits:

Object

• Object
• HammerBuilder::DynamicClasses::Classes

show all

Defined in:

lib/hammer_builder/dynamic_classes.rb

Instance Attribute Summary (collapse)

• - (Object) base readonly

  Returns the value of attribute base.

• - (Object) class_definitions readonly

  Returns the value of attribute class_definitions.

• - (Object) class_extensions(name) readonly private

  Returns the value of attribute class_extensions.

• - (Object) classes readonly

  Returns the value of attribute classes.

Instance Method Summary (collapse)

• - (Class) [](name)

  Defined class.

• - (Object) ancestor private
• - (Object) ancestors private
• - (Object) class_definition(name) private
• - (Object) class_names
• - (Object) def_class(name, superclass_or_name = nil) { ... }

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

• - (Object) extend_class(name) { ... }

  extends already defined class by adding a child,.

• - (Classes) initialize(base) constructor

  A new instance of Classes.

• - (Object) load!

  triggers loading of all defined 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

81
82
83

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

def base
  @base
end

81
82
83

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

def class_definitions
  @class_definitions
end

81
82
83

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

def class_extensions(name)
  ([*ancestor.try(:class_extensions, name)] + [@class_extensions[name]]).compact
end

81
82
83

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

def classes
  @classes
end

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

169
170
171

# File 'lib/hammer_builder/dynamic_classes.rb', line 169

def ancestor
  @base.superclass.dynamic_classes if @base.superclass.kind_of?(DynamicClasses)
end

165
166
167

# File 'lib/hammer_builder/dynamic_classes.rb', line 165

def ancestors
  ([self] + [*ancestor.try(:ancestors)]).compact
end

157
158
159

# File 'lib/hammer_builder/dynamic_classes.rb', line 157

def class_definition(name)
  @class_definitions[name] || ancestor.try(:class_definition, name)
end

151
152
153

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

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

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

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

119
120
121

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

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