module BaseChip::Dsl::ClassMethods

Attributes

child_types[RW]
possible_settings[RW]
settings[RW]

class instance variables

Public Instance Methods

define_child(name,type) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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() click to toggle source
# File lib/base_chip/dsl.rb, line 181
def possible_child_types; @possible_child_types end
to_doc_hash() click to toggle source
# 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