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) ⇒ Object 



67
68
69
 
# File 'lib/menilite/client/store.rb', line 67

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

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



48
49
50
51
52
53
54
55
56
57
 
# File 'lib/menilite/server/store.rb', line 48

def fetch(model_class, filter: nil, order: nil, includes: nil)
  File.open filename(model_class) do |file|
    records = JSON.parse(file.read)
    records.select! {|r| filter.all? {|k,v| r[k.to_s] == v } } if filter
    records.sort_by!{|r| [order].flatten.map{|o| r[o.to_s] } } if order
    @tables[model_class] = records.map {|m| [m["id"], model_class.new(m)] }.to_h
  end

  @tables[model_class].values || []
end

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

Yields:

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


49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/menilite/client/store.rb', line 49

def fetch!(model_class, filter: nil, includes: nil, order: nil, &block)
  tables = @tables
  params = filter && (?? + filter.map {|k,v| "#{k}=#{v}" }.join(?&))
  params = (params ? params + ?& : ??) + "order=#{[order].flatten.join(?,)}" if order
  params = (params ? params + ?& : ??) + "includes=#{includes}" if includes
  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

#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 



71
72
73
74
75
76
77
78
79
80
 
# File 'lib/menilite/client/store.rb', line 71

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) 


23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/menilite/client/store.rb', line 23

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 



75
76
77
 
# File 'lib/menilite/server/activerecord_store.rb', line 75

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