i_am_i_can 3.0.1 → 4.0.0

data/lib/i_am_i_can/dynamic_generate.rb

@@ -1,95 +0,0 @@
-module IAmICan
-  module DynamicGenerate
-    extend self
-
-    def scopes
-      # Generate scopes of each specified i_am_i_can association
-      #
-      # scope :with_stored_roles, -> { includes(:stored_roles) }
-      #
-      proc do |keys|
-        keys.each do |k|
-          scope :"with_#{_reflect_of(k)}", ->  { includes(_reflect_of(k)) }
-        end
-      end
-    end
-
-    def class_reflections
-      # Extend each associated querying to a class method that returns ActiveRecord::Relation
-      #
-      # Suppose: in UserRole model,
-      #   has_and_belongs_to_many :related_users
-      #
-      # It will do like this:
-      #   def self.related_users
-      #     i_am_i_can.subject_model.with_stored_roles.where(user_roles: { id: self.ids })
-      #   end
-      #
-      # Usage:
-      #   UserRole.all.related_users
-      #
-      proc do
-        %w[ subject role role_group permission ].each do |k|
-          next unless _reflect_of(k)
-          define_singleton_method _reflect_of(k) do
-            model = i_am_i_can.send("#{k}_model")
-            raise NoMethodError unless (reflect_name = model._reflect_of(i_am_i_can.act))
-            model.send("with_#{reflect_name}").where(
-                self.name.underscore.pluralize => { id: self.ids }
-            )
-          end
-        end
-      end
-    end
-
-    def assignment_helpers
-      # Generate 4 methods for each Content of Assignment
-      #
-      # Example for a subject model called User, which `has_and_belongs_to_many :stored_roles`.
-      # You call this proc by given contents [:role], then:
-      #
-      # 1. stored_roles_add
-      #   Add roles to a user instance
-      #
-      # 2. stored_roles_add
-      #   Remove roles to a user instance
-      #
-      # 3. stored_role_names
-      #   Get names of stored_roles of a user instance
-      #
-      # 4. self.stored_role_names
-      #   Get names of stored_roles of User ActiveRecord::Relation
-      #
-      proc do |contents|
-        contents.each do |content|
-          # TODO: refactoring
-          define_method "#{_reflect_of(content)}_add" do |locate_vals = nil, check_size: nil, **condition|
-            condition = { name: locate_vals } if locate_vals
-            assoc = send("_#{content.to_s.pluralize}")
-            records = i_am_i_can.send("#{content}_model").where(condition).where.not(id: assoc.ids)
-            # will return false if it does nothing
-            return false if records.blank? || (check_size && records.count != check_size)
-            assoc << records
-          end
-
-          define_method "#{_reflect_of(content)}_rmv" do |locate_vals = nil, check_size: nil, **condition|
-            condition = { name: locate_vals } if locate_vals
-            assoc = send("_#{content.to_s.pluralize}")
-            records = i_am_i_can.send("#{content}_model").where(id: assoc.ids, **condition)
-            # will return false if it does nothing
-            return false if records.blank? || (check_size && records.count != check_size)
-            assoc.destroy(records)
-          end
-
-          define_method "#{_reflect_of(content).to_s.singularize}_names" do
-            send("_#{content.to_s.pluralize}").map(&:name).map(&:to_sym)
-          end
-
-          define_singleton_method "#{_reflect_of(content).to_s.singularize}_names" do
-            all.flat_map { |user| user.send("#{_reflect_of(content).to_s.singularize}_name") }.uniq
-          end
-        end
-      end
-    end
-  end
-end

data/lib/i_am_i_can/permission/helpers.rb

@@ -1,75 +0,0 @@
-module IAmICan
-  module Permission
-    module Helpers
-      module Cls
-        def _pms_definition_result(preds, obj, failed_items)
-          prefix = 'Permission Definition Done'
-          fail_msg = prefix + ", but #{failed_items} have been defined" if failed_items.present?
-          raise Error, fail_msg if  i_am_i_can.strict_mode && fail_msg
-          puts fail_msg || prefix unless ENV['ITEST']
-          prefix.present?
-        end
-
-        def _to_store_permission(pred, obj, **options)
-          return false if i_am_i_can.permission_model.exists?(pred, obj)
-          i_am_i_can.permission_model.create!(pred: pred, **deconstruct_obj(obj), **options)
-        end
-
-        def pms_naming(pred, obj)
-          i_am_i_can.permission_model.naming(pred, obj)
-        end
-
-        def deconstruct_obj(obj)
-          i_am_i_can.permission_model.deconstruct_obj(obj)
-        end
-
-        def defined_local_permissions
-          @defined_local_permissions ||= { }
-        end
-
-        def defined_stored_pms_names
-          i_am_i_can.permission_model.all.map(&:name)
-        end
-
-        def defined_stored_permissions
-          i_am_i_can.permission_model.all.map { |pms| [ pms.name, pms.desc ] }.to_h
-        end
-
-        def defined_permissions
-          defined_local_permissions.deep_merge(defined_stored_permissions)
-        end
-
-        def pms_of_defined_local_role(role_name)
-          i_am_i_can.subject_model.defined_local_roles[role_name.to_sym]&.[](:permissions) || []
-        end
-      end
-
-      module Ins
-        def _pms_assignment_result(preds, obj, not_defined_items, covered_items = nil, strict_mode = false)
-          prefix = 'Permission Assignment Done'
-          msg1 = "#{not_defined_items} have not been defined or have been repeatedly assigned" if not_defined_items.present?
-          msg2 = "#{covered_items} have been covered" if covered_items.present?
-          fail_msg = prefix + ', but ' + [msg1, msg2].compact.join(', ') if msg1 || msg2
-          raise Error, fail_msg if (strict_mode || i_am_i_can.strict_mode) && fail_msg
-          puts fail_msg || prefix unless ENV['ITEST']
-          prefix.present?
-        end
-
-        def pms_matched?(pms_name, plist)
-          i_am_i_can.permission_model.matched?(pms_name, in: plist[:in])
-        end
-
-        def local_permissions
-          @local_permissions ||= [ ]
-        end
-
-        alias local_permission_names local_permissions
-
-        # TODO: show by hash
-        def permissions
-          local_permission_names + stored_permission_names
-        end
-      end
-    end
-  end
-end

data/lib/i_am_i_can/permission/p_array.rb

@@ -1,22 +0,0 @@
-module IAmICan
-  module Permission
-    class PArray < ::Array
-      attr_accessor :pms
-
-      def matched?(pms_name)
-        return false if self.blank?
-        self.pms = pms_name.to_sym
-        found? || covered?
-      end
-
-      def found?
-        pms.in? self
-      end
-
-      def covered?
-        pred, obj_type, obj_id = pms.to_s.split('_')
-        pred.to_sym.in?(self) || :"#{pred}_#{obj_type}".in?(self)
-      end
-    end
-  end
-end

data/lib/i_am_i_can/reflection.rb

@@ -1,25 +0,0 @@
-module IAmICan
-  module Reflection
-    extend ActiveSupport::Concern
-
-    class_methods do
-      # User._roles => 'stored_roles'
-      %w[ subjects roles role_groups permissions ].each do |k|
-        define_method "_#{k}" do
-          v = instance_variable_get("@_#{k}")
-          return v if v.present?
-          instance_variable_set("@_#{k}", _reflect_of(k.singularize))
-        end
-      end
-    end
-
-    included do
-      # user._roles => Association CollectionProxy, same as: `user.stored_roles`
-      %w[ subjects roles role_groups permissions ].each do |k|
-        define_method "_#{k}" do
-          send(self.class.send("_#{k}")) if self.class.send("_#{k}")
-        end
-      end
-    end
-  end
-end

data/lib/i_am_i_can/role/helpers.rb

@@ -1,76 +0,0 @@
-module IAmICan
-  module Role
-    module Helpers
-      module Cls
-        def _to_store_role name, **options
-          return false if i_am_i_can.role_model.exists?(name: name) || i_am_i_can.role_group_model&.exists?(name: name)
-          i_am_i_can.role_model.create!(name: name, **options)
-        end
-
-        def _role_definition_result(names, failed_items)
-          prefix = 'Role Definition Done'
-          fail_msg = prefix + ", but name #{failed_items} have been used by other role or group" if failed_items.present?
-          raise Error, fail_msg if i_am_i_can.strict_mode && fail_msg
-          puts fail_msg || prefix unless ENV['ITEST']
-          prefix.present?
-        end
-
-        def defined_local_roles
-          @local_roles ||= { }
-        end
-
-        def defined_stored_role_names
-          i_am_i_can.role_model.pluck(:name).map(&:to_sym)
-        end
-
-        def defined_stored_roles
-          i_am_i_can.role_model.all.map { |role| [ role.name.to_sym, role.desc ] }.to_h
-        end
-
-        def defined_roles
-          defined_local_roles.deep_merge(defined_stored_roles)
-        end
-
-        def defined_role_group_names
-          i_am_i_can.role_group_model.pluck(:name).map(&:to_sym)
-        end
-
-        def defined_role_groups
-          i_am_i_can.role_group_model.all.map { |group| [ group.name.to_sym, group.member_names.map(&:to_sym).sort ] }.to_h
-        end
-      end
-
-      module Ins
-        def _role_assignment_result(names, failed_items)
-          prefix = 'Role Assignment Done'
-          fail_msg = prefix + ", but #{failed_items} have not been defined or have been repeatedly assigned" if failed_items.present?
-          raise Error, fail_msg if i_am_i_can.strict_mode && fail_msg
-          puts fail_msg || prefix unless ENV['ITEST']
-          prefix.present?
-        end
-
-        def __role
-          proc do |role|
-            next role.to_sym if role.is_a?(String) || role.is_a?(Symbol)
-            next role.name if role.is_a?(i_am_i_can.role_model)
-            # raise error
-          end
-        end
-
-        def local_role_names
-          @local_role_names ||= [ ]
-        end
-
-        def local_roles
-          defined_local_roles.slice(*local_role_names)
-        end
-
-        def roles
-          local_role_names + stored_role_names
-        end
-
-        alias role_names roles
-      end
-    end
-  end
-end