Module: DefDsl::So

Defined in:
lib/def_dsl.rb

Overview

def shallow_constants who

  (who.constants - who.superclass.constants).map { |name| * = name.to_s.underscore, who.const_get(name) }
end

def define_dsl! who, constants=shallow_constants(who) # ...
  # constants = constants.nil?? shallow_constants(who) : constants_info(constants)
  return if who.included_modules.include? So
  who.send :include, So
  constants.each do |mini, const|

    #next if who.included_modules.include? So
    #who.send :include, So
    next if const.included_modules.include? So
    const.send :include, So
    #who.send :include, So

    define_dsl! const if const.is_a? Class

    meth =  const.instance_eval { @dsl } || mini

    who.class_eval do
      define_method(meth) do |*a,&b|
        so [mini,meth],*a,&b
      end
    end

    # const.send :include, So if const.is_a? Module # or even class
    # who.send :include, So if who.is_a? Module # or even class
    if who.class == Module
      who.send :module_function, meth
      who.send :module_function, :so
      who.send :module_function, :so1
      who.send :module_function, :so2
    end      
  end
end

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(target) ⇒ Object 



215
216
217
218
219
220
221
 
# File 'lib/def_dsl.rb', line 215

def self.included target
  if target.class == Module # class.superclass for meta_module...
    target.send :module_function, :so
    target.send :module_function, :so1
    target.send :module_function, :so2
  end
end

Instance Method Details

#feed_block(&block) ⇒ Object 



181
182
183
 
# File 'lib/def_dsl.rb', line 181

def feed_block &block
  instance_eval &block
end

#so(klass_name = nil, *a, &b) ⇒ Object 



185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/def_dsl.rb', line 185

def so klass_name=nil,*a,&b
  return @so if klass_name.nil?

  klass_name, label = if klass_name.is_a? Array
                        klass_name.map &:to_sym
                      else
                        [klass_name.to_sym, klass_name.to_sym]
                      end

  if self.class == Module
    klass = self.const_get(klass_name.to_s.camelize)
  else
    klass = self.class.const_get(klass_name.to_s.camelize)
  end

  obj = klass.new(*a) #,&b)
  # obj.instance_eval &b if b
  obj.feed_block &b if b
  (@so ||= {}).tap { |h| h[label] = h[label] ? [h[label], obj].flatten(1) : obj }
end

#so1(name) ⇒ Object 



205
206
207
208
 
# File 'lib/def_dsl.rb', line 205

def so1(name)
  value = @so[name]
  value.is_a?(Array) ? value.last : value
end

#so2(name) ⇒ Object 



209
210
211
212
213
 
# File 'lib/def_dsl.rb', line 209

def so2(name)
  return [] unless @so.key? name
  value = @so[name]
  value.is_a?(Array) ? value : [value]
end