Class: Menilite::Store

Inherits:
Object
  • Object
show all
Defined in:
lib/menilite/client/store.rb,
lib/menilite/server/store.rb,
lib/menilite/server/activerecord_store.rb

Constant Summary collapse

DEFAULT_DB_DIR = 
'./.store'

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Store

Returns a new instance of Store.



3
4
5
 
# File 'lib/menilite/client/store.rb', line 3

def initialize
  @tables = {}
end

Class Method Details

.instance ⇒ Object 



7
8
9
 
# File 'lib/menilite/client/store.rb', line 7

def self.instance
  @instance ||= Store.new
end

Instance Method Details

#armodel(model_class) ⇒ Object 



31
32
33
 
# File 'lib/menilite/server/activerecord_store.rb', line 31

def armodel(model_class)
  @armodels[model_class]
end

#delete(model_class, filter:) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/menilite/client/store.rb', line 77

def delete(model_class, filter:, &block)
  tables = @tables
  Menilite::Http.request_json("api/#{model_class}", :delete, filter) do
    on :success do |json|
      res = json.map {|value| tables[model_class].delete(value[:id]) }
      block.call res if block
    end

    on :failure do |res|
      puts ">> Error: #{res.error}"
      puts ">>>> delete: #{model.inspect}"
    end
  end
end

#delete_all(model_class) ⇒ Object 



92
93
94
 
# File 'lib/menilite/client/store.rb', line 92

def delete_all(mdoel_class)
  @tables[model_class] = {}
end

#fetch(model_class, filter: nil, order: nil, includes: nil) ⇒ Object 



23
24
25
 
# File 'lib/menilite/client/store.rb', line 23

def fetch(model_class, filter:)
  @tables[model_class].find{|x| match_filter?(x, filter) }
end

#fetch!(model_class, filter: nil, order: nil, includes: nil) {|fetch(model_class, filter, order, includes)| ... } ⇒ Object

Yields:

  • (fetch(model_class, filter, order, includes)) 


57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/menilite/client/store.rb', line 57

def fetch!(model_class, filter: nil, includes: nil, order: nil, &block)
  tables = @tables
  param_list = []
  param_list << filter.map {|k,v| "#{k}=#{v}" } if filter
  param_list << "order=#{[order].flatten.join(?,)}" if order
  param_list << "includes=#{includes}" if includes
  params = ?? + param_list.join(?&) if param_list.length > 0
  Menilite::Http.get_json("api/#{model_class}#{params}") do
    on :success do |json|
      tables[model_class] = json.map {|value| [value[:id], Menilite::Deserializer.deserialize(model_class, value, includes)] }.to_h
      yield tables[model_class].values if block_given?
    end

    on :failure do |res|
      puts ">> Error: #{res.error}"
      puts ">>>> save: #{model.inspect}"
    end
  end
end

#filename(model_class) ⇒ Object 



73
74
75
 
# File 'lib/menilite/server/store.rb', line 73

def filename(model_class)
  @db_dir + "/#{model_class}.db"
end

#find(model_class, id) ⇒ Object 



19
20
21
 
# File 'lib/menilite/client/store.rb', line 19

def find(model_class, id)
  self[model_class][id]
end

#match_filter?(model, filter) ⇒ Boolean

Returns:

  • (Boolean) 


27
28
29
 
# File 'lib/menilite/client/store.rb', line 27

def match_filter?(model, filter)
  filter.all? {|k, v| model[k] == v }
end

#max(model_class, field_name) ⇒ Object 



68
69
70
71
 
# File 'lib/menilite/server/store.rb', line 68

def max(model_class, field_name)
  fetch(model_class)
  @tables[model_class].reduce(nil) {|v, max| v.fields[field_name] < max ? max : v.fields[field_name] }
end

#max!(model_class, field_name, &block) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
 
# File 'lib/menilite/client/store.rb', line 96

def max!(model_class, field_name, &block)
  Menilite::Http.get_json("api/#{model_class}?order=#{field_name}") do
    on :success do |json|
      if json.last
        model = model_class.new(json.last)
        yield model.fields[field_name]
      end
    end
  end
end

#register(model_class) ⇒ Object 



11
12
13
 
# File 'lib/menilite/client/store.rb', line 11

def register(model_class)
  @tables[model_class] = {}
end

#save(model) {|model| ... } ⇒ Object

Yields:

  • (model) 


31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/menilite/client/store.rb', line 31

def save(model)
  is_array = model.is_a?(Array)
  models = is_array ? model : [ model ]
  model_class = models.first.class
  table = @tables[model_class]
  Menilite::Http.post_json("api/#{model_class.to_s}", models) do
    on :success do |json|
      results = json.map do |value|
        if table.has_key?(value[:id])
          table[value[:id]].update(value)
          table[value[:id]]
        else
          table[value[:id]] = model_class.new(value)
        end
      end

      yield(is_array ? results : results.first) if block_given?
    end

    on :failure do |res|
      puts ">> Error: #{res.error}"
      puts ">>>> save: #{model.inspect}"
    end
  end
end

#to_model(ar_obj, model_class) ⇒ Object 



83
84
85
 
# File 'lib/menilite/server/activerecord_store.rb', line 83

def to_model(ar_obj, model_class)
  model_class.new(fields(ar_obj, model_class))
end