menilite 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27f419ef565f994b020d022eea673453e02a6c8a
-  data.tar.gz: b9da18be00c27e19fa8e4c214db72adfe145eb02
+  metadata.gz: fa0456ba69383e0e59a40b7b7fad44296b9f5576
+  data.tar.gz: f74ce6a6826bc2b73108a64c98aabba159078507
 SHA512:
-  metadata.gz: 8f5baa982958df003abfa0d738af9238d17e5127a01861f10588b2af58a71f561ba5ccc9a2e983972a963942eabfc4b06bf37e6c2a214b625cc5d334d23c800e
-  data.tar.gz: 08f91b60b5eb398a0878af9703be8b1bd3b1f71a1b481ea313d05deca78db52d4030159b09521f87508794493849223a4d901fd9f361dd906a1e7b22c5f28ef3
+  metadata.gz: d37414bfd1a1b040ffe0b5f11f3a77b2e75e90762a788f45ccae8a764c204ac63edf893754ef85517b443e0b6f285a09e217da0533621a5795c0c46605e5abf7
+  data.tar.gz: c9f86a5dbef6f88bb4ff07d080756f443576f16beefc19de56c95681f23e6a566f30f2382fa9bba8ea97aeb4a7972b7097ea2a61e741467a0697dbd88d7b1999

data/Rakefile

@@ -1,10 +1,10 @@
 require 'opal'
-require 'opal-browser'
 require 'opal/rspec/rake_task'
 require "bundler/gem_tasks"
 
 Opal::RSpec::RakeTask.new(:default) do |server, task|
   task.pattern = 'spec/opal/**/*_spec.rb'
+  task.file = [ENV['FILE']] if ENV['FILE']
   server.append_path File.expand_path('../lib', __FILE__)
   server.source_map = true
   server.debug = true

data/lib/menilite.rb

@@ -4,9 +4,10 @@ require "menilite/helper"
 
 if RUBY_ENGINE == "opal"
   require 'native'
-  require 'browser'
   require 'menilite/model'
   require 'menilite/controller'
+  require 'menilite/client/http'
+  require 'menilite/client/deserializer'
   require 'menilite/client/store'
 else
   require 'opal'
@@ -14,6 +15,7 @@ else
   require 'menilite/controller'
   require 'menilite/server/error_with_status_code'
   require 'menilite/server/privilege'
+  require 'menilite/server/serializer'
   require 'menilite/server/router'
   require 'menilite/server/activerecord_store'
 

data/lib/menilite/client/deserializer.rb

@@ -0,0 +1,28 @@
+module Menilite
+  module Deserializer
+    def self.deserialize(model_class, json, includes = nil)
+      case json
+      when Array
+        json.map {|j| deserialize(model_class, j, includes) }
+      when Hash
+        if includes
+          case includes
+          when String
+            assoc_data = json.delete(includes)
+            assoc_id = json.delete(:id)
+            obj = model_class.new(json)
+            assoc = obj.send(includes).model_class.new(assoc_data)
+            obj.send(includes + '=', assoc)
+            obj
+          when Array
+            raise "not implemented"
+          when Hash
+            raise "not implemented"
+          end
+        else
+          model_class.new(json)
+        end
+      end
+    end
+  end
+end

data/lib/menilite/client/http.rb

@@ -0,0 +1,69 @@
+module Menilite
+  module Http
+    class << self
+      def get_json(url, &block)
+        (callback, promise) = prepare(url, &block)
+
+        `fetch(url).then(callback)`
+
+        promise
+      end
+
+      def post_json(url, json, &block)
+        (callback, promise) = prepare(url, &block)
+
+        `fetch(url, {method: 'post', body: JSON.stringify(json)}).then(callback)`
+
+        promise
+
+      end
+
+      private
+
+      def prepare(url, &block)
+        promise = nil
+        callback = nil
+
+        if block
+          handler = ResponseHandler.new
+          handler.instance_eval(&block)
+
+          callback = Proc.new do |response|
+            if `response.ok`
+              %x(
+                response.json().then(function(json) {
+                  #{handler.success(JSON.from_object(`json`))}
+                })
+              )
+            else
+              handler.failure(Native(response))
+            end
+          end
+        else
+          promise = Promise.new
+          callback = Proc.new {|reponse| promise.resolve(JSON.from_object(response.json)) }
+        end
+
+        [callback, promise]
+      end
+    end
+
+    class ResponseHandler
+      def initialize
+        @listeners = {}
+      end
+
+      def on(evt, &block)
+        @listeners[evt] = block
+      end
+
+      def success(res)
+        @listeners[:success].call(res)
+      end
+
+      def failure
+        @listeners[:failure].call(res)
+      end
+    end
+  end
+end

data/lib/menilite/client/store.rb

@@ -1,5 +1,3 @@
-require 'browser/http'
-
 module Menilite
   class Store
     def initialize
@@ -19,11 +17,7 @@ module Menilite
     end
 
     def find(model_class, id)
-      return self[model_class][id] if self[model_class][id]
-
-      res = Browser::HTTP.get!("api/#{model_class.to_s}/#{id}")
-      model = model_class.new(res.json)
-      @tables[model_class][id] = model
+      self[model_class][id]
     end
 
     def save(model)
@@ -31,9 +25,9 @@ module Menilite
       models = is_array ? model : [ model ]
       model_class = models.first.class
       table = @tables[model_class]
-      Browser::HTTP.post("api/#{model_class.to_s}", models.to_json) do
-        on :success do |res|
-          results = res.json.map do |value|
+      Menilite::Http.post_json("api/#{model_class.to_s}", models.to_json) do
+        on :success do |json|
+          results = json.map do |value|
             if table.has_key?(value[:id])
               table[value[:id]].update(value)
               table[value[:id]]
@@ -52,13 +46,14 @@ module Menilite
       end
     end
 
-    def fetch(model_class, filter: nil, order: nil, &block)
+    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
-      Browser::HTTP.get("api/#{model_class}#{params}") do
-        on :success do |res|
-          tables[model_class] = res.json.map {|value| [value[:id], model_class.new(value)] }.to_h
+      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
 
@@ -73,11 +68,14 @@ module Menilite
       @tables[model_class] = {}
     end
 
-    def max(model_class, field_name)
-      res = Browser::HTTP.get!("api/#{model_class}?order=#{field_name}")
-      if res.json.last
-        model = model_class.new(res.json.last)
-        model.fields[field_name]
+    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
   end

data/lib/menilite/controller.rb

@@ -1,5 +1,4 @@
 if RUBY_ENGINE == 'opal'
-  require 'browser/http'
   require 'opal-parser'
 end
 
@@ -38,7 +37,7 @@ module Menilite
             action_url = self.respond_to?(:namespace) ? "api/#{self.namespace}/#{name}" : "api/#{name}"
             post_data = {}
             post_data[:args] = args
-            Browser::HTTP.post(action_url, post_data.to_json) do
+            Menilite::Http.post_json(action_url, post_data.to_json) do
               on :success do |res|
                 callback.call(:success, res) if callback
               end

data/lib/menilite/model.rb

@@ -1,7 +1,7 @@
 require 'securerandom'
+require_relative 'model/association'
 
 if RUBY_ENGINE == 'opal'
-  require 'browser/http'
   require 'opal-parser'
 end
 
@@ -39,12 +39,12 @@ module Menilite
       @guid = fields.delete(:id) || SecureRandom.uuid
 
       self.class.field_info.select{|_, i| i.type == :reference}.each do |name, info|
-        fields[:"#{name}_id"] = fields[info.name] if fields.has_key?(info.name)
+        fields[name] = Association.new(info.params[:class])
+        fields[name].load(fields["#{name}_id".to_sym]) if fields["#{name}_id".to_sym]
       end
 
       fields.each{|k, v| type_validate(k, v) }
       fields = fields.map{|k,v| [k, convert_value(self.class.field_info[k].type, v)] }.to_h
-
       if server?
         fields.merge!(self.class.privilege_fields)
       end
@@ -116,7 +116,7 @@ module Menilite
 
       def save(collection, &block)
         self.init
-        colection.each {|obj| obj.validate_all }
+        collection.each {|obj| obj.validate_all }
         self.store.save(collection, &block)
       end
 
@@ -130,30 +130,50 @@ module Menilite
         store.delete(self)
       end
 
-      def fetch(filter: {}, order: nil)
-        self.init
-        filter = filter.map{|k, v| type_convert(k.to_sym, v) }.to_h
 
-        if_server do
-          filter.merge!(privilege_filter)
+      Menilite.if_server do
+        def fetch(filter: {}, order: nil, includes: nil)
+          self.init
+          store.fetch(self, filter: convert_fileter(filter), order: order, includes: includes)
         end
 
-        store.fetch(self, filter: filter, order: order) do |list|
-          yield list if block_given?
-          list
+        def max(field_name)
+          self.init
+          store.max(self, field_name)
         end
       end
 
-      def type_convert(key, value)
-        field_info = self.field_info[key] || self.field_info[key.to_s.sub(/_id\z/,'').to_sym]
-        raise "no such field #{key} in #{self}" unless field_info
-        converted = case field_info.type
-                    when :boolean
-                      value.is_a?(String) ? (value == 'true' ? true : false) : value
-                    else
-                      value
-                    end
-        [key, converted]
+      def find(id)
+        case id
+        when String
+          self[id]
+        when Hash
+          self.fetch(filter:id).first
+        end
+      end
+
+      def [](id)
+        self.init
+        store.find(self, id)
+      end
+
+      def fetch!(filter: {}, order: nil, includes: nil, &block)
+        raise 'method is block required' unless block_given?
+
+        self.init
+
+        store.fetch!(self, filter: convert_fileter(filter), order: order, includes: includes) do |list|
+          yield list
+        end
+      end
+
+      def max!(field_name, &block)
+        raise 'method is block required' unless block_given?
+
+        self.init
+        store.max!(self, field_name) do |max|
+          yield max
+        end
       end
 
       def store
@@ -168,8 +188,6 @@ module Menilite
         subclasses[child] = false
       end
 
-      FieldInfo = Struct.new(:name, :type, :params)
-
       def field(name, type = :string, params = {})
         params.merge!(client: true, server: true)
 
@@ -179,44 +197,41 @@ module Menilite
           return unless params[:server]
         end
 
+        field_info[name] = FieldInfo.new(name, type, params)
         if type == :reference
-          field_info[:"#{name}_id"] = FieldInfo.new(name, type, params)
-        else
-          field_info[name] = FieldInfo.new(name, type, params)
+          field_info["#{name}_id".to_sym] = FieldInfo.new("#{name}_id", :id, {})
         end
 
         self.instance_eval do
           if type == :reference
-            field_name = "#{name}_id"
-
-            define_method(name) do
-              id = @fields[field_name.to_sym]
-              next nil unless id
-              model_class = Object.const_get(name.to_s.camel_case)
-              model_class[id]
+            define_method("#{name}_id") do
+              @fields[name.to_sym].id
             end
 
-            define_method(name.to_s + "=") do |value|
-              @fields[field_name.to_sym] = value.id
+            define_method("#{name}_id=") do |value|
+              @fields[name.to_sym].load(value)
             end
-          else
-            field_name = name.to_s
           end
 
-          define_method(field_name) do
-            value = @fields[field_name.to_sym]
+          define_method(name) do
+            value = @fields[name.to_sym]
             if type.is_a?(Hash) && type.keys.first == :enum
               value = type[:enum][value]
             end
             value
           end
 
-          define_method(field_name + "=") do |value|
+          define_method("#{name}=") do |value|
+            puts "#{name}=#{value}: #{type}"
             unless type_validator(type).call(value, name)
-              raise TypeError.new("type error: field_name: #{name}, value: #{value}")
+              raise TypeError.new("type error: field name: #{name}, value: #{value}")
+            end
+            if type == :reference
+              @fields[name.to_sym].assign convert_value(type, value)
+            else
+              @fields[name.to_sym] = convert_value(type, value)
             end
-            @fields[field_name.to_sym] = convert_value(type, value)
-            handle_event(:change, field_name.to_sym, value)
+            handle_event(:change, name.to_sym, value)
           end
         end
       end
@@ -248,7 +263,7 @@ module Menilite
               post_data[:model] = model.to_h
             end
 
-            Browser::HTTP.post(action_url, post_data.to_json) do
+            Menilite::Http.post_json(action_url, post_data.to_json) do
               on :success do |res|
                 callback.call(:success, res) if callback
               end
@@ -283,28 +298,6 @@ module Menilite
         (validators[field_name] ||= []) << Validator.new(self, field_name, &block) if block
       end
 
-      def find(id)
-        self.init
-
-        case id
-        when String
-          self[id]
-        when Hash
-          self.fetch(filter:id).first
-        end
-
-      end
-
-      def [](id)
-        self.init
-        store.find(self, id)
-      end
-
-      def max(field_name)
-        self.init
-        store.max(self, field_name)
-      end
-
       def permit(privileges)
         Menilite.if_server do
           case privileges
@@ -335,6 +328,30 @@ module Menilite
           end
         end
       end
+
+      private
+
+      def convert_fileter(filter)
+        converted = filter.map{|k, v| convert_type(k.to_sym, v) }.to_h
+
+        if_server do
+          converted.merge!(privilege_filter)
+        end
+
+        converted
+      end
+
+      def convert_type(key, value)
+        field_info = self.field_info[key] || self.field_info[key.to_s.sub(/_id\z/,'').to_sym]
+        raise "no such field #{key} in #{self}" unless field_info
+        converted = case field_info.type
+                    when :boolean
+                      value.is_a?(String) ? (value == 'true' ? true : false) : value
+                    else
+                      value
+                    end
+        [key, converted]
+      end
     end
 
     def type_validator(type)
@@ -356,7 +373,9 @@ module Menilite
             raise TypeError.new("type error")
           end
         when :reference
-          -> (value, name) { value.nil? || validate_reference(value, name) }
+          -> (value, name) { client? || value.nil? || validate_reference(value, name) || value.is_a?(Association) }
+        when :id
+          -> (value, name) { value.nil? || value.is_a?(String) }
         else
           raise TypeError.new("type error. type: #{type.inspect}")
       end
@@ -389,6 +408,14 @@ module Menilite
       messages.empty? or raise ValidationError.new(messages)
     end
 
+    def [](key)
+      if self.class.field_info.has_key?(key.to_sym) || self.class.field_info.has_key?("#{key}_id".to_sym)
+        self.send(key)
+      else
+        raise ArgumentError.new("field '#{name}' is not defind")
+      end
+    end
+
     def to_h
       @fields.merge(id: @guid)
     end
@@ -429,6 +456,12 @@ module Menilite
       end
     end
 
+    class FieldInfo < Struct.new(:name, :type, :params)
+      def default
+        params[:default] if params.has_key?(:default)
+      end
+    end
+
     class Validator
       include Menilite::Helper
 

data/lib/menilite/model/association.rb

@@ -0,0 +1,45 @@
+module Menilite
+  class Model
+    class UnacquiredDataAccess < StandardError; end
+
+    class Association
+      attr_reader :model_class
+
+      def initialize(model_class)
+        @model_class = model_class
+        @model = nil
+      end
+
+      def assign(model)
+        @model = model
+      end
+
+      def load(id)
+        assign @model_class.find(id)
+      end
+
+      def id
+        @model && @model.id
+      end
+
+      def to_h
+        raise UnacquiredDataAccess.new unless @model
+        @model.to_h
+      end
+
+      private
+
+      def method_missing(method_sym, *args, &block)
+        field_name = method_sym.to_s
+        field_name = field_name[0, field_name.size - 1] if field_name.chars.last == '='
+        field = @model_class.field_info[field_name]
+        if field
+          raise UnacquiredDataAccess.new unless @model
+          @model.send(method_sym, *args)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/menilite/server/activerecord_store.rb

@@ -54,13 +54,14 @@ module Menilite
       yield model if block_given?
     end
 
-    def fetch(model_class, filter: nil, order: nil)
+    def fetch(model_class, filter: nil, order: nil, includes: nil)
       assoc = @armodels[model_class].all
 
       assoc = assoc.where(filter_condition(model_class, filter)) if filter
+      assoc = assoc.includes(includes) if includes
       assoc = assoc.order([order].flatten.map(&:to_sym)) if order
 
-      yield assoc.map {|ar| to_model(ar, model_class) } || [] if block_given?
+      assoc.map {|ar| to_model(ar, model_class) } || []
     end
 
     def delete(model_class)
@@ -97,6 +98,7 @@ module Menilite
       model.to_h.tap do |hash|
         references.each do |r|
           hash["#{r.name}_guid".to_sym] = hash.delete("#{r.name}_id".to_sym)
+          hash.delete(r.name.to_sym)
         end
 
         hash[:guid] = hash.delete(:id)
@@ -104,7 +106,7 @@ module Menilite
     end
 
     def fields(ar_obj, model_class)
-      references = model_class.field_info.values.select{|i| i.type == :reference}
+      references = model_class.field_info.values.select{|i| i.type == :reference }
       ar_obj.attributes.tap do |hash|
         references.each do |r|
           hash["#{r.name}_id"] = hash.delete("#{r.name}_guid")

data/lib/menilite/server/router.rb

@@ -64,6 +64,8 @@ module Menilite
           status 403
           { result: 'validation_error', message: e.message, messages: e.messages }.to_json
         rescue => e
+          puts e.message
+          puts e.backtrace
           content_type :json
           status 500
           { result: 'error', message: e.message }.to_json
@@ -81,8 +83,9 @@ module Menilite
                 PrivilegeService.init
                 router.before_action_handlers(klass, 'index').each {|h| self.instance_eval(&h[:proc]) }
                 order = params.delete('order')&.split(?,)
-                data = klass.fetch(filter: params, order: order)
-                json data.map(&:to_h)
+                includes = params.delete('includes')
+                data = klass.fetch(filter: params, order: order, includes: includes)
+                json Serializer.serialize(data, includes)
               end
             end
 
@@ -90,13 +93,15 @@ module Menilite
               with_error_handler do
                 PrivilegeService.init
                 router.before_action_handlers(klass, 'get').each {|h| self.instance_eval(&h[:proc]) }
-                json klass[params[:id]].to_h
+                includes = params.delete('includes')
+                json Serializer.serialize(klass[params[:id]], includes)
               end
             end
 
             post "/#{resource_name}" do
               PrivilegeService.init
               router.before_action_handlers(klass, 'post').each {|h| self.instance_eval(&h[:proc]) }
+              includes = params.delete('includes')
               data = JSON.parse(request.body.read)
               results = data.map do |model|
                 instance = klass.new model.map{|key, value| [key.to_sym, value] }.to_h
@@ -104,7 +109,7 @@ module Menilite
                 instance
               end
 
-              json results.map(&:to_h)
+              json Serializer.serialize(results, includes)
             end
 
             klass.action_info.each do |name, action|

data/lib/menilite/server/serializer.rb

@@ -0,0 +1,27 @@
+module Menilite
+  module Serializer
+    def self.serialize(obj, includes)
+      case obj
+      when Menilite::Model
+        hash = obj.to_h
+        if includes
+          case includes
+          when String, Symbol
+            hash[includes.to_s] = obj[includes].to_h
+          when Array
+            includes.each do |i|
+              hash[i.to_s] = obj[i].to_h
+            end
+          when Hash
+            includes.each do |k, v|
+              hash[k.to_s] = Menilite::Serializer.serialize(obj[k], v)
+            end
+          end
+        end
+        hash
+      when Array
+        obj.map {|o| Menilite::Serializer.serialize(o, includes) }
+      end
+    end
+  end
+end

data/lib/menilite/server/store.rb

@@ -45,7 +45,7 @@ module Menilite
       yield model if block_given?
     end
 
-    def fetch(model_class, filter: nil, order: nil)
+    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
@@ -53,7 +53,11 @@ module Menilite
         @tables[model_class] = records.map {|m| [m["id"], model_class.new(m)] }.to_h
       end
 
-      yield @tables[model_class].values || [] if block_given?
+      @tables[model_class].values || []
+    end
+
+    def fetch!(model_class, filter: nil, order: nil, includes: nil)
+      yield fetch(model_class, filter, order, includes)
     end
 
     def delete(model_class)

data/lib/menilite/version.rb

@@ -1,3 +1,3 @@
 module Menilite
-  VERSION = "0.4.2"
+  VERSION = "0.5.0"
 end

data/menilite.gemspec

@@ -21,9 +21,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency 'opal-rspec', '0.5.0'
+  spec.add_development_dependency 'opal-rspec'
 
   spec.add_runtime_dependency "opal"
-  spec.add_runtime_dependency 'opal-browser'
   spec.add_runtime_dependency "sinatra-activerecord"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: menilite
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - youchan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-30 00:00:00.000000000 Z
+date: 2017-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -54,26 +54,12 @@ dependencies:
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: opal-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.5.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.5.0
-- !ruby/object:Gem::Dependency
-  name: opal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -81,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: opal-browser
+  name: opal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -125,14 +111,18 @@ files:
 - bin/console
 - bin/setup
 - lib/menilite.rb
+- lib/menilite/client/deserializer.rb
+- lib/menilite/client/http.rb
 - lib/menilite/client/store.rb
 - lib/menilite/controller.rb
 - lib/menilite/helper.rb
 - lib/menilite/model.rb
+- lib/menilite/model/association.rb
 - lib/menilite/server/activerecord_store.rb
 - lib/menilite/server/error_with_status_code.rb
 - lib/menilite/server/privilege.rb
 - lib/menilite/server/router.rb
+- lib/menilite/server/serializer.rb
 - lib/menilite/server/store.rb
 - lib/menilite/version.rb
 - menilite.gemspec
@@ -155,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Isomorphic models between client side opal and server side ruby.