menilite 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8bd4f42ddb852546849eaf34e1ad3247d19b7365
-  data.tar.gz: 572240d87bfb87dc8c75747a427e3e6e4ed08afe
+  metadata.gz: e96823093a09cbe81fe57e93acb586d480258fb6
+  data.tar.gz: 1c1698195f5afb071265a644f0b5f725d04fc1a3
 SHA512:
-  metadata.gz: 6c3cfffbe205a5c878560d0fa28aee2d357ce4351b277c8f134dcdf6c6257d0a3aae86f0eb500eb37e1ee54cfece83c3d66a4c211179bde49f596afaff4fd30b
-  data.tar.gz: 157c094db9e46ecf109730510cdcbfa8c82d7592d99d0f37a47708c20fa78d3b096349a331f44e0566c64de2bb731db383fa67e98a8304b01b2b175810f8c68a
+  metadata.gz: 16f926123ff653a696b6b1fea7477de86fa51fe2776708202886518c214cce4284f6e47a043df4d285804793c12dc2a262793ccb3f8f71be1157a6c98af464b0
+  data.tar.gz: a5190655a95e355561b5f15f55fe96bd7d654134aad86bf46678a115cccd52e537ee9fd205ec34565a0111f5077e76d28f76fe95baf561cb0c9a3ff9173dd014

data/lib/menilite.rb

@@ -1,5 +1,7 @@
 require "menilite/version"
 
+require "menilite/helper"
+
 if RUBY_ENGINE == "opal"
   require 'menilite/model'
   require 'menilite/controller'
@@ -8,9 +10,13 @@ else
   require 'opal'
   require 'menilite/model'
   require 'menilite/controller'
+  require 'menilite/privilege'
   require 'menilite/router'
   require 'menilite/server/activerecord_store'
 
   Opal.append_path File.expand_path('../', __FILE__).untaint
   Opal.append_path File.expand_path('../../vendor', __FILE__).untaint
 end
+
+module Menilite
+end

data/lib/menilite/helper.rb

@@ -0,0 +1,23 @@
+module Menilite
+  module Helper
+    def server?
+      !client?
+    end
+
+    def client?
+      RUBY_ENGINE == 'opal'
+    end
+
+    def if_server(&block)
+      block.call if server?
+    end
+
+    def if_client(&block)
+      block.call if client?
+    end
+  end
+
+  class << self
+    include Helper
+  end
+end

data/lib/menilite/model.rb

@@ -1,5 +1,6 @@
 require 'securerandom'
-if RUBY_ENGINE == 'opal'
+
+Menilite.if_client do
   require 'browser/http'
   require 'opal-parser'
 end
@@ -13,15 +14,18 @@ end
 
 module Menilite
   class Model
+    include Menilite::Helper
+
     attr_reader :fields
 
     def initialize(fields = {})
       self.class.init
 
-      if RUBY_ENGINE == 'opal'
+      if client?
         fields = fields.clone
       else
         fields = fields.map{|k,v| [k.to_sym, v] }.to_h
+        fields.merge!(self.class.privilege_fields)
       end
 
       defaults = self.class.field_info.map{|k, d| [d.name, d.params[:default]] if d.params.has_key?(:default) }.compact.to_h
@@ -42,11 +46,11 @@ module Menilite
     def update(data)
       case data
       when self.class
-        @fields.merge(data.fields)
+        @fields.merge!(data.fields)
       when Hash
-        @fields.merge(data)
+        @fields.merge!(data.map{|k, v| resolve_references(k, v) }.to_h)
       when String
-        @fields.merge(JSON.parse(json))
+        @fields.merge!(JSON.parse(json))
       end
     end
 
@@ -67,6 +71,8 @@ module Menilite
     end
 
     class << self
+      include Menilite::Helper
+
       def init
         if Model.subclasses.has_key?(self) && !Model.subclasses[self]
           store.register(self)
@@ -97,9 +103,14 @@ module Menilite
         store.delete(self)
       end
 
-      def fetch(filter: nil, order: nil)
+      def fetch(filter: {}, order: nil)
         self.init
-        filter = filter.map{|k, v| type_convert(k, v)  }.to_h if filter
+        filter = filter.map{|k, v| type_convert(k, v)  }.to_h
+
+        if_server do
+          filter.merge!(privilege_filter)
+        end
+
         store.fetch(self, filter: filter, order: order) do |list|
           yield list if block_given?
           list
@@ -135,7 +146,7 @@ module Menilite
       def field(name, type = :string, params = {})
         params.merge!(client: true, server: true)
 
-        if RUBY_ENGINE == 'opal'
+        if client?
           return unless params[:client]
         else
           return unless params[:server]
@@ -178,7 +189,15 @@ module Menilite
 
       def action(name, options = {}, &block)
         action_info[name.to_s] = ActionInfo.new(name, block.parameters, options)
-        if RUBY_ENGINE == 'opal'
+        if server?
+          self.instance_eval do
+            if options[:class]
+              define_singleton_method(name, block)
+            else
+              define_method(name, block)
+            end
+          end
+        else
           method = Proc.new do |model, *args, &callback| # todo: should adopt keyword parameters
             action_url = options[:on_create] || options[:class] ? "api/#{self}/#{name}" : "api/#{self}/#{model.id}/#{name}"
             post_data = {}
@@ -201,14 +220,6 @@ module Menilite
               define_method(name) {|*args, &callback| method.call(self, *args, &callback) }
             end
           end
-        else
-          self.instance_eval do
-            if options[:class]
-              define_singleton_method(name, block)
-            else
-              define_method(name, block)
-            end
-          end
         end
       end
 
@@ -233,6 +244,37 @@ module Menilite
         self.init
         store.max(self, field_name)
       end
+
+      def permit(privileges)
+        Menilite.if_server do
+          case privileges
+          when Array
+            self.privileges.push(*privileges)
+          when Symbol, String
+            self.privileges << privileges
+          end
+        end
+      end
+
+      Menilite.if_server do
+        def privileges
+          @privileges ||= []
+        end
+
+        def privilege_filter
+          return {} unless PrivilegeService.current
+          PrivilegeService.current.get_privileges(self.privileges).each_with_object({}) do |priv, filter|
+            filter.merge!(priv.filter)
+          end
+        end
+
+        def privilege_fields
+          return {} unless PrivilegeService.current
+          PrivilegeService.current.get_privileges(self.privileges).each_with_object({}) do |priv, fields|
+            fields.merge!(priv.fields)
+          end
+        end
+      end
     end
 
     def type_validator(type)
@@ -278,5 +320,13 @@ module Menilite
       @listeners[event][field_name] ||= []
       @listeners[event][field_name] << block
     end
+
+    def resolve_references(key, value)
+      if self.class.field_info.has_key?(key.to_s) && self.class.field_info[key.to_s].type == :reference
+        ["#{key}_id".to_sym, value.id]
+      else
+        [key, value]
+      end
+    end
   end
 end

data/lib/menilite/privilege.rb

@@ -0,0 +1,36 @@
+module Menilite
+  class Privilege
+    def key
+      raise NotImplementedError.new "Menilite::Privilege#key must be overriden"
+    end
+
+    def filter
+      {}
+    end
+
+    def fields
+      {}
+    end
+  end
+
+  class PrivilegeService
+    attr_reader :privileges
+
+    def initialize
+      @privileges = []
+    end
+
+    def self.init
+      instance = PrivilegeService.new
+      Thread.current.thread_variable_set(:previlege_service, instance)
+    end
+
+    def self.current
+      Thread.current.thread_variable_get(:previlege_service)
+    end
+
+    def get_privileges(names)
+      names.map{|key| @privileges.find{|p| p.key == key } }.compact
+    end
+  end
+end

data/lib/menilite/router.rb

@@ -3,11 +3,11 @@ require 'sinatra/json'
 require 'json'
 
 class Class
-  def subclass_of?(klass)
-    raise ArgumentError.new unless klass.is_a?(Class)
+  def subclass_of?(klass, include_self = true)
+    raise ArgumentError.new unless klass.is_a?(Module)
 
     if self == klass
-      true
+      include_self
     else
       if self.superclass
         self.superclass.subclass_of?(klass)
@@ -20,15 +20,30 @@ end
 
 module Menilite
   class Router
-    def initialize(*classes)
-      @classes = classes
+    def initialize
+      @classes = []
+
+      ObjectSpace.each_object(Class) do |klass|
+        @classes << klass if klass.subclass_of?(Menilite::Model, false)
+        @classes << klass if klass.subclass_of?(Menilite::Controller, false)
+        @classes << klass if klass.subclass_of?(Menilite::Privilege, false)
+      end
     end
 
     def before_action_handlers(klass, action)
       @handlers ||= @classes.select{|c| c.subclass_of?(Menilite::Controller) }.map{|c| c.before_action_handlers }.flatten
-      @handlers.reject do |c|
-        [c[:options][:expect]].flatten.any? do |expect|
-          (classname, _, name) = expect.to_s.partition(?#)
+
+      handlers = @handlers.select do |c|
+        next true unless c[:options].has_key?(:include)
+        [c[:options][:include]].flatten.any? do |includes|
+          (classname, _, name) = includes.to_s.partition(?#)
+          (classname == klass.name) && (name.empty? || name == action.to_s)
+        end
+      end
+
+      handlers.reject do |c|
+        [c[:options][:exclude]].flatten.any? do |exclude|
+          (classname, _, name) = exclude.to_s.partition(?#)
           (classname == klass.name) && (name.empty? || name == action.to_s)
         end
       end
@@ -46,6 +61,7 @@ module Menilite
             klass.init
             resource_name = klass.name
             get "/#{resource_name}" do
+              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)
@@ -53,11 +69,13 @@ module Menilite
             end
 
             get "/#{resource_name}/:id" do
+              PrivilegeService.init
               router.before_action_handlers(klass, 'get').each {|h| self.instance_eval(&h[:proc]) }
               json klass[params[:id]].to_h
             end
 
             post "/#{resource_name}" do
+              PrivilegeService.init
               router.before_action_handlers(klass, 'post').each {|h| self.instance_eval(&h[:proc]) }
               data = JSON.parse(request.body.read)
               results = data.map do |model|
@@ -73,6 +91,7 @@ module Menilite
               path = action.options[:on_create] || action.options[:class] ? "/#{resource_name}/#{action.name}" : "/#{resource_name}/#{action.name}/:id"
 
               post path do
+                PrivilegeService.init
                 router.before_action_handlers(klass, action.name).each {|h| self.instance_eval(&h[:proc]) }
                 data = JSON.parse(request.body.read)
                 result = if action.options[:on_create]
@@ -89,6 +108,7 @@ module Menilite
             klass.action_info.each do |name, action|
               path = klass.respond_to?(:namespace) ? "/#{klass.namespace}/#{action.name}" : "/#{action.name}"
               post path  do
+                PrivilegeService.init
                 router.before_action_handlers(klass, action.name).each {|h| self.instance_eval(&h[:proc]) }
                 data = JSON.parse(request.body.read)
                 controller = klass.new(session, settings)

data/lib/menilite/version.rb

@@ -1,3 +1,3 @@
 module Menilite
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: menilite
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - youchan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-28 00:00:00.000000000 Z
+date: 2016-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -85,7 +85,9 @@ files:
 - lib/menilite.rb
 - lib/menilite/client/store.rb
 - lib/menilite/controller.rb
+- lib/menilite/helper.rb
 - lib/menilite/model.rb
+- lib/menilite/privilege.rb
 - lib/menilite/router.rb
 - lib/menilite/server/activerecord_store.rb
 - lib/menilite/server/store.rb