Module: MetaMongo

Defined in:
lib/meta_mongo.rb,
lib/meta_mongo/utils.rb,
lib/meta_mongo/version.rb

Defined Under Namespace

Modules: Utils Classes: BadHash

Constant Summary collapse

VERSION = 
"0.2.0"

Class Method Summary collapse

Class Method Details

.check_missing_keys(obj, *keys) ⇒ Object 



28
29
30
31
32
 
# File 'lib/meta_mongo.rb', line 28

def check_missing_keys(obj, *keys)
  keys.each do |key|
    missing_key(key) if !obj.key?(key)
  end
end

.create_method(klass, method, block) ⇒ Object 



18
19
20
 
# File 'lib/meta_mongo.rb', line 18

def create_method(klass, method, block)
  klass.singleton_class.send(:define_method, :foo, &block)
end

.create_model(name) ⇒ Object 



10
11
12
 
# File 'lib/meta_mongo.rb', line 10

def create_model(name)
  Utils.create_class(name)
end

.include_module(klass, mod) ⇒ Object 



22
23
24
25
26
 
# File 'lib/meta_mongo.rb', line 22

def include_module(klass, mod)
  klass.class_eval do
    include mod
  end
end

.init(hash) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/meta_mongo.rb', line 62

def init(hash)
  models = hash["models"]

  missing_key("models") unless models
  wrong_type("models") unless models.is_a?(Array)

  models.each do |model|
    check_missing_keys(model, "name", "attributes")

    if !model["attributes"].is_a?(Array)
      wrong_type("attributes")
    end

    attrs = parse_attributes(model["attributes"])

    klass = MetaMongo.create_model(model["name"])
    MetaMongo.include_module(klass, Mongoid::Document)

    attrs.each do |att|
      MetaMongo.run_method(klass, :field, att[:field], type: att[:type])

      att[:vals].each do |val|
        MetaMongo.run_method(klass, :validates, att[:field], val)
      end
    end
  end
end

.missing_key(key) ⇒ Object

Raises:



34
35
36
 
# File 'lib/meta_mongo.rb', line 34

def missing_key(key)
  raise BadHash.new("Missing '#{key}' key")
end

.parse_attributes(attrs) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/meta_mongo.rb', line 42

def parse_attributes(attrs)
  out = []

  attrs.each do |my_attr|
    check_missing_keys my_attr, "field", "name", "type", "validations"

    out << {
      name:  my_attr["name"],
      field: my_attr["field"],
      type:  Utils.to_class(my_attr["type"]),
      vals:  my_attr["validations"]
    }

    wrong_type("validations") if !out.last[:vals].is_a?(Array)

  end

  out
end

.run_method(klass, method, *args) ⇒ Object 



14
15
16
 
# File 'lib/meta_mongo.rb', line 14

def run_method(klass, method, *args)
  klass.send(method, *args)
end

.wrong_type(key) ⇒ Object

Raises:



38
39
40
 
# File 'lib/meta_mongo.rb', line 38

def wrong_type(key)
  raise BadHash.new("Invalid '#{key}' type")
end