Module: BaseChip::Dsl::ClassMethods

Defined in:
lib/base_chip/dsl.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#child_types ⇒ Object

Returns the value of attribute child_types.



49
50
51
 
# File 'lib/base_chip/dsl.rb', line 49

def child_types
  @child_types
end

#possible_settings ⇒ Object

Returns the value of attribute possible_settings.



50
51
52
 
# File 'lib/base_chip/dsl.rb', line 50

def possible_settings
  @possible_settings
end

#settings ⇒ Object

class instance variables



48
49
50
 
# File 'lib/base_chip/dsl.rb', line 48

def settings
  @settings
end

Instance Method Details

#define_child(name, type) ⇒ Object 



60
61
62
63
64
65
66
67
68
 
# File 'lib/base_chip/dsl.rb', line 60

def define_child(name,type)
  @possible_settings   .merge! type.possible_settings
  @possible_child_types.merge! type.possible_child_types
  @possible_child_types[name] = type
           @child_types[name] = type
  type.possible_settings   .each { |name, legal_types| define_settings_methods name, legal_types }
  type.possible_child_types.each { |name, type       |    define_child_methods name, type        }
  define_child_methods(name,type)
end

#define_child_methods(child_name, type) ⇒ Object 



135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/base_chip/dsl.rb', line 135

def define_child_methods(child_name,type)
  child_name_plural = child_name.to_s.pluralize.to_sym
  attr_accessor child_name_plural
  define_method child_name do |name=nil,&blk| # why is this an accessor also?
    if name
      hash           =  instance_variable_or_equal(child_name_plural,HashWithIndifferentAccess.new)
      tmp            =  (hash[name] ||= type.new)
      tmp.name       =  name
      tmp.parent     =  self
      tmp.blks       << blk if blk
      tmp
    else
      instance_variable_get("@#{name}")
    end
  end
  define_method "abstract_#{child_name}" do |name=nil,&blk|
    tmp = send(child_name, name, &blk)
    tmp.abstract = true
  end
  define_method "import_#{child_name}" do |name,object|
    fault        "attempting to import object #{object.name} of type #{object.class} into #{child_name_plural} of type #{type}" if object.class != type
    hash       = instance_variable_or_equal(child_name_plural,HashWithIndifferentAccess.new)
    fault        "#{child_name} '#{name} already exists.  Import is not possible" if hash[name]
    tmp        = (hash[name] = object.clone)
    tmp.name   = name
    tmp.foster = tmp.parent
    tmp.parent = self
  end

  define_method "remove_#{child_name}" do |name|
    hash       = instance_variable_or_equal(child_name_plural,HashWithIndifferentAccess.new)
    hash.delete name
  end

  # FIXME this only works on defined objects
  define_method "all_#{child_name_plural}" do |&blk|
    hash       = instance_variable_or_equal(child_name_plural,HashWithIndifferentAccess.new)
    hash.each_value do |value|
      value.blks << blk
    end
  end
end

#define_children(h) ⇒ Object 



53
 
# File 'lib/base_chip/dsl.rb', line 53

def define_children(h); h.each { |name, type       | define_child   name, type        } end

#define_setting(name, legal_types) ⇒ Object 



55
56
57
58
59
 
# File 'lib/base_chip/dsl.rb', line 55

def define_setting(name,legal_types)
  @possible_settings[name] = legal_types
           @settings[name] = legal_types
  define_settings_methods(name,legal_types)
end

#define_settings(h) ⇒ Object 



52
 
# File 'lib/base_chip/dsl.rb', line 52

def define_settings(h); h.each { |name, legal_types| define_setting name, legal_types } end

#define_settings_methods(name, type) ⇒ Object 



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/base_chip/dsl.rb', line 70

def define_settings_methods(name,type)
  define_method name do |value=:base_chip_get_operation|
    unless value == :base_chip_get_operation
      check_type(name,value,type)
      if value.is_a? Hash
        instance_variable_set "@#{name}", value.with_indifferent_access
      else
        instance_variable_set "@#{name}", value
      end
    end
    if (value = instance_variable_get "@#{name}") and value.is_a? Hash
      value.with_indifferent_access
    else
      value
    end
  end

  define_method "prepend_#{name}" do |value|
    check_type(name,value,type)
    if value && (current_value = instance_variable_get("@#{name}"))
      if    value.is_a? Hash
          instance_variable_set "@#{name}", current_value.merge(  value).with_indifferent_access
      elsif value.is_a?(String) || value.is_a?(Symbol)
        if current_value.is_a? Array 
          instance_variable_set "@#{name}", current_value.unshift(value)
        else
          instance_variable_set "@#{name}",                    "#{value} " + current_value
        end
      else
          instance_variable_set "@#{name}",                       value    + current_value
      end
    else
          instance_variable_set "@#{name}",                       value
    end
    if (value = instance_variable_get "@#{name}") and value.is_a? Hash
      value.with_indifferent_access
    else
      value
    end
  end

  define_method "append_#{name}" do |value|
    check_type(name,value,type)
    if value && (current_value = instance_variable_get("@#{name}"))
      if    value.is_a? Hash
          instance_variable_set("@#{name}", current_value.merge(  value).with_indifferent_access)
      elsif value.is_a?(String) || value.is_a?(Symbol)
        if current_value.is_a? Array 
          instance_variable_set "@#{name}", current_value <<      value
        else
          instance_variable_set "@#{name}", current_value +   " #{value}"
        end
      else
          instance_variable_set "@#{name}", current_value +       value
      end
    else
          instance_variable_set "@#{name}",                       value
    end
    if (value = instance_variable_get "@#{name}") and value.is_a? Hash
      value.with_indifferent_access
    else
      value
    end
  end
end

#possible_child_types ⇒ Object 



181
 
# File 'lib/base_chip/dsl.rb', line 181

def possible_child_types; @possible_child_types end

#to_doc_hash ⇒ Object 



183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
 
# File 'lib/base_chip/dsl.rb', line 183

def to_doc_hash
  doc_settings             = {}
  doc_child_types          = {}
  doc_possible_settings    = {}
  doc_possible_child_types = {}

  settings          .each { |name,types|                                     doc_settings[name] = types.map{|t|t.to_s}    }
  possible_settings .each { |name,types| unless doc_settings[name]; doc_possible_settings[name] = types.map{|t|t.to_s} end}

  child_types          .each { |k,v|          doc_child_types[k.to_s] = v.to_s }
  possible_child_types .each { |k,v| doc_possible_child_types[k.to_s] = v.to_s unless doc_child_types[k.to_s] }

  doc_method_list = instance_methods - Object.methods
  doc_methods = {}
  doc_method_list.each do |m|
    im = instance_method(m)
    doc_methods[m] = {
      :inputs  =>  im.parameters,
      :expects => (im.parameters.empty? ? "This method takes no inputs." : nil)
    }
  end

  possible_settings.keys.each do |n|
    [ n                   , 
     "append_#{ n}".to_sym,
     "prepend_#{n}".to_sym
    ].each do |m|
      doc_methods[m][:setting] = n.to_s
    end
  end
  possible_child_types.keys.each do |n|
    [ n                            ,
               "remove_#{n}".to_sym,
             "abstract_#{n}".to_sym,
               "import_#{n}".to_sym,
        "all_#{n}".pluralize.to_sym,
            n.to_s.pluralize.to_sym,
      "#{n.to_s.pluralize}=".to_sym
    ].each do |m|
      doc_methods[m][:object] = n.to_s
    end
  end

  h = { self.to_s => { :type                 => self.to_s                      ,
                       :child_types          => doc_child_types                ,
                       :settings             => doc_settings                   ,
                       :possible_child_types => doc_possible_child_types       ,
                       :possible_settings    => doc_possible_settings          ,
                       :methods              => doc_methods                    }
      }
  child_types.each_value do |v|
    next if v == self
    h.merge! v.to_doc_hash
  end
  h
end