canard 0.5.0.pre → 0.6.0.pre

data/lib/canard/adapters/active_record.rb

@@ -1,51 +1,54 @@
+# frozen_string_literal: true
+
 module Canard
   module Adapters
-    module ActiveRecord
-
+    module ActiveRecord # :nodoc:
       private
 
-      def add_role_scopes(*args)
-        options = args.extract_options!
-        # TODO change to check has_roles_attribute?
-        if active_record_table?
-          valid_roles.each do |role|
-            define_scopes_for_role role, options[:prefix]
-          end
-
-          # TODO change hard coded :role_mask to roles_attribute_name
-          define_singleton_method(:with_any_role) do |*roles|
-            where("#{role_mask_column} & :role_mask > 0", { :role_mask => mask_for(*roles) })
-          end
-
-          define_singleton_method(:with_all_roles) do |*roles|
-            where("#{role_mask_column} & :role_mask = :role_mask", { :role_mask => mask_for(*roles) })
-          end
-
-          define_singleton_method(:with_only_roles) do |*roles|
-            where("#{role_mask_column} = :role_mask", { :role_mask => mask_for(*roles) })
-          end
+      def add_role_scopes(**options)
+        define_scopes(options) if active_record_table_exists?
+      end
+
+      def define_scopes(options)
+        valid_roles.each do |role|
+          define_scopes_for_role role, options[:prefix]
+        end
+
+        # TODO: change hard coded :role_mask to roles_attribute_name
+        define_singleton_method(:with_any_role) do |*roles|
+          where("#{role_mask_column} & :role_mask > 0", role_mask: mask_for(*roles))
+        end
+
+        define_singleton_method(:with_all_roles) do |*roles|
+          where("#{role_mask_column} & :role_mask = :role_mask", role_mask: mask_for(*roles))
+        end
+
+        define_singleton_method(:with_only_roles) do |*roles|
+          where("#{role_mask_column} = :role_mask", role_mask: mask_for(*roles))
         end
       end
 
-      def active_record_table?
+      def active_record_table_exists?
         respond_to?(:table_exists?) && table_exists?
+      rescue ActiveRecord::NoDatabaseError, StandardError
+        false
       end
 
-      # TODO extract has_roles_attribute? and change to has_roles_attribute? || super
+      # TODO: extract has_roles_attribute? and change to has_roles_attribute? || super
       def has_roles_mask_accessors?
-        active_record_table? && column_names.include?(roles_attribute_name.to_s) || super
+        active_record_table_exists? && column_names.include?(roles_attribute_name.to_s) || super
       end
 
-      def define_scopes_for_role(role, prefix=nil)
+      def define_scopes_for_role(role, prefix = nil)
         include_scope = [prefix, String(role).pluralize].compact.join('_')
         exclude_scope = "non_#{include_scope}"
 
         define_singleton_method(include_scope) do
-          where("#{role_mask_column} & :role_mask > 0", { :role_mask => mask_for(role) })
+          where("#{role_mask_column} & :role_mask > 0", role_mask: mask_for(role))
         end
 
         define_singleton_method(exclude_scope) do
-          where("#{role_mask_column} & :role_mask = 0 or #{role_mask_column} is null", { :role_mask => mask_for(role) })
+          where("#{role_mask_column} & :role_mask = 0 or #{role_mask_column} is null", role_mask: mask_for(role))
         end
       end
 
@@ -54,4 +57,4 @@ module Canard
       end
     end
   end
-end
+end

data/lib/canard/adapters/mongoid.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 module Canard
   module Adapters
-    module Mongoid
-
+    module Mongoid # :nodoc:
       private
 
       def add_role_scopes(*args)
@@ -10,34 +11,40 @@ module Canard
           define_scopes_for_role role, options[:prefix]
         end
 
-        def with_any_role(*roles)
+        define_singleton_method(:with_any_role) do |*roles|
           where("(this.#{roles_attribute_name} & #{mask_for(*roles)}) > 0")
         end
 
-        def with_all_roles(*roles)
+        define_singleton_method(:with_all_roles) do |*roles|
           where("(this.#{roles_attribute_name} & #{mask_for(*roles)}) === #{mask_for(*roles)}")
         end
 
-        def with_only_roles(*roles)
+        define_singleton_method(:with_only_roles) do |*roles|
           where("this.#{roles_attribute_name} === #{mask_for(*roles)}")
         end
       end
 
       def has_roles_mask_accessors?
-       fields.include?(roles_attribute_name.to_s) || super
+        fields.include?(roles_attribute_name.to_s) || super
       end
 
-      def define_scopes_for_role(role, prefix=nil)
+      def define_scopes_for_role(role, prefix = nil)
         include_scope = [prefix, String(role).pluralize].compact.join('_')
         exclude_scope = "non_#{include_scope}"
 
         scope include_scope, -> { where("(this.#{roles_attribute_name} & #{mask_for(role)}) > 0") }
-        scope exclude_scope, -> { any_of({roles_attribute_name  => { "$exists" => false }}, {roles_attribute_name => nil}, {"$where" => "(this.#{roles_attribute_name} & #{mask_for(role)}) === 0"}) }
+        scope exclude_scope, lambda {
+          any_of(
+            { roles_attribute_name => { '$exists' => false } },
+            { roles_attribute_name => nil },
+            '$where' => "(this.#{roles_attribute_name} & #{mask_for(role)}) === 0"
+          )
+        }
       end
     end
   end
 end
 
-Mongoid::Document::ClassMethods.send :include, Canard::Adapters::Mongoid
-Mongoid::Document::ClassMethods.send :include, Canard::UserModel
-Canard.find_abilities
+Mongoid::Document::ClassMethods.send(:include, Canard::Adapters::Mongoid)
+Mongoid::Document::ClassMethods.send(:include, Canard::UserModel)
+Canard.find_abilities

data/lib/canard/find_abilities.rb

@@ -1,15 +1,16 @@
-module Canard
+# frozen_string_literal: true
 
+module Canard # :nodoc:
   def self.ability_definitions
     Abilities.definitions
   end
 
   def self.ability_key(class_name)
-    klass_name = String(class_name)
-    klass_name.gsub!('::', '')
-    klass_name.gsub!(/(.)([A-Z])/,'\1_\2')
-    klass_name.downcase!
-    klass_name.to_sym
+    String(class_name)
+      .gsub('::', '')
+      .gsub(/(.)([A-Z])/, '\1_\2')
+      .downcase
+      .to_sym
   end
 
   def self.load_paths
@@ -22,7 +23,5 @@ module Canard
         load file
       end
     end
-
   end
-
-end
+end

data/lib/canard/railtie.rb

@@ -1,21 +1,18 @@
-require 'canard'
-require 'rails'
+# frozen_string_literal: true
 
 module Canard
-  class Railtie < Rails::Railtie
-
-    initializer "canard.no_eager_loading", :before => 'before_eager_loading' do |app|
-      ActiveSupport::Dependencies.autoload_paths.reject!{ |path| Canard.load_paths.include?(path) }
+  class Railtie < Rails::Railtie # :nodoc:
+    initializer 'canard.no_eager_loading', before: 'before_eager_loading' do |app|
+      ActiveSupport::Dependencies.autoload_paths.reject! { |path| Canard.load_paths.include?(path) }
       # Don't eagerload our configs, we'll deal with them ourselves
       app.config.eager_load_paths = app.config.eager_load_paths.reject do |path|
         Canard.load_paths.include?(path)
       end
-      if app.config.respond_to?(:watchable_dirs)
-        app.config.watchable_dirs.merge! Hash[ Canard.load_paths.product([[:rb]]) ]
-      end
+
+      app.config.watchable_dirs.merge! Hash[Canard.load_paths.product([[:rb]])] if app.config.respond_to?(:watchable_dirs)
     end
 
-    initializer "canard.active_record" do |app|
+    initializer 'canard.active_record' do |_app|
       ActiveSupport.on_load :active_record do
         require 'canard/adapters/active_record'
         Canard::Abilities.default_path = File.expand_path('app/abilities', Rails.root)
@@ -24,19 +21,17 @@ module Canard
       end
     end
 
-    initializer "canard.mongoid" do |app|
+    initializer 'canard.mongoid' do |_app|
       require 'canard/adapters/mongoid' if defined?(Mongoid)
     end
 
-    initializer "canard.abilities_reloading", :after => "action_dispatch.configure" do |app|
+    initializer 'canard.abilities_reloading', after: 'action_dispatch.configure' do |_app|
       reloader = rails5? ? ActiveSupport::Reloader : ActionDispatch::Reloader
-      if reloader.respond_to?(:to_prepare)
-        reloader.to_prepare { Canard.find_abilities }
-      end
+      reloader.to_prepare { Canard.find_abilities } if reloader.respond_to?(:to_prepare)
     end
 
     rake_tasks do
-      load File.expand_path('../../tasks/canard.rake', __FILE__)
+      load File.expand_path('../tasks/canard.rake', __dir__)
     end
 
     private

data/lib/canard/user_model.rb

@@ -1,77 +1,78 @@
+# frozen_string_literal: true
+
 module Canard
+  # Canard applies roles to a model using the acts_as_user class method. The following User model
+  # will be given the :manager and :admin roles
+  #
+  #   class User < ActiveRecord::Base
+  #
+  #     acts_as_user :roles => [:manager, :admin]
+  #
+  #   end
+  #
+  # If using Canard with a non ActiveRecord class you can still assign roles but you will need to
+  # extend the class with Canard::UserModel and add a roles_mask attribute.
+  #
+  #   class User
+  #
+  #     extend Canard::UserModel
+  #
+  #     attr_accessor :roles_mask
+  #
+  #     acts_as_user :roles => [:manager, :admin]
+  #
+  #   end
+  #
+  # You can choose the attribute used for the roles_mask by specifying :roles_mask. If no
+  # roles_mask is specified it uses RoleModel's default of 'roles_mask'
+  #
+  #    acts_as_user :roles_mask => :my_roles_mask, :roles => [:manager, :admin]
+  #
+  # == Scopes
+  #
+  # Beyond applying the roles to the model, acts_as_user also creates some useful scopes for
+  # ActiveRecord models;
+  #
+  #   User.with_any_role(:manager, :admin)
+  #
+  # returns all the managers and admins
+  #
+  #  User.with_all_roles(:manager, :admin)
+  #
+  # returns only the users with both the manager and admin roles
+  #
+  #   User.admins
+  #
+  # returns all the admins as
+  #
+  #  User.managers
+  #
+  # returns all the users with the maager role likewise
+  #
+  #   User.non_admins
+  #
+  # returns all the users who don't have the admin role and
+  #
+  #   User.non_managers
+  #
+  # returns all the users who don't have the manager role.
   module UserModel
-
-    # Canard applies roles to a model using the acts_as_user class method. The following User model
-    # will be given the :manager and :admin roles
-    #
-    #   class User < ActiveRecord::Base
-    #
-    #     acts_as_user :roles => [:manager, :admin]
-    #
-    #   end
-    #
-    # If using Canard with a non ActiveRecord class you can still assign roles but you will need to
-    # extend the class with Canard::UserModel and add a roles_mask attribute.
-    #
-    #   class User
-    #
-    #     extend Canard::UserModel
-    #
-    #     attr_accessor :roles_mask
-    #
-    #     acts_as_user :roles => [:manager, :admin]
-    #
-    #   end
-    #
-    # You can choose the attribute used for the roles_mask by specifying :roles_mask. If no
-    # roles_mask is specified it uses RoleModel's default of 'roles_mask'
-    #
-    #    acts_as_user :roles_mask => :my_roles_mask, :roles => [:manager, :admin]
-    #
-    # == Scopes
-    #
-    # Beyond applying the roles to the model, acts_as_user also creates some useful scopes for
-    # ActiveRecord models;
-    #
-    #   User.with_any_role(:manager, :admin)
-    #
-    # returns all the managers and admins
-    #
-    #  User.with_all_roles(:manager, :admin)
-    #
-    # returns only the users with both the manager and admin roles
-    #
-    #   User.admins
-    #
-    # returns all the admins as
-    #
-    #  User.managers
-    #
-    # returns all the users with the maager role likewise
-    #
-    #   User.non_admins
-    #
-    # returns all the users who don't have the admin role and
-    #
-    #   User.non_managers
-    #
-    # returns all the users who don't have the manager role.
     def acts_as_user(*args)
       include RoleModel
       include InstanceMethods
-      
+
       options = args.last.is_a?(Hash) ? args.pop : {}
-      
+
       if defined?(ActiveRecord) && self < ActiveRecord::Base
         extend Adapters::ActiveRecord
-      elsif defined?(Mongoid) && self.included_modules.include?(Mongoid::Document)
+      elsif defined?(Mongoid) && included_modules.include?(Mongoid::Document)
         extend Adapters::Mongoid
-        field (options[:roles_mask] || :roles_mask), :type => Integer
+        field (options[:roles_mask] || :roles_mask), type: Integer
       end
 
-      roles_attribute options[:roles_mask] if options.has_key?(:roles_mask)
+      roles_attribute options[:roles_mask] if options.key?(:roles_mask)
 
-      roles options[:roles] if options.has_key?(:roles) && has_roles_mask_accessors?
+      roles options[:roles] if options.key?(:roles) && has_roles_mask_accessors?
 
       add_role_scopes(prefix: options[:prefix]) if respond_to?(:add_role_scopes, true)
     end
@@ -81,18 +82,16 @@ module Canard
     # This is overridden by the ActiveRecord adapter as the attribute accessors
     # don't show up in instance_methods.
     def has_roles_mask_accessors?
-      instance_method_names = instance_methods.map { |method_name| method_name.to_s }
-      [roles_attribute_name.to_s, "#{roles_attribute_name}="].all? do |accessor| 
+      instance_method_names = instance_methods.map(&:to_s)
+      [roles_attribute_name.to_s, "#{roles_attribute_name}="].all? do |accessor|
         instance_method_names.include?(accessor)
       end
     end
 
-    module InstanceMethods
-
+    module InstanceMethods # :nodoc:
       def ability
         @ability ||= Ability.new(self)
       end
-
     end
   end
 end

data/lib/canard/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Canard
-  VERSION = "0.5.0.pre"
+  VERSION = '0.6.0.pre'
 end

data/lib/generators/ability_definition.rb

@@ -1,43 +1,45 @@
+# frozen_string_literal: true
+
 require 'active_support/inflector'
 
-class AbilityDefinition
-  
+class AbilityDefinition # :nodoc:
   attr_accessor :cans, :cannots
-  
+
   def self.parse(definitions)
     @@ability_definitions ||= {}
-    limitation, ability_list, model_list = *definitions.split(':')
-    ability_names, model_names = extract(ability_list), extract(model_list)
+    limitation, ability_list, model_list = definitions.split(':')
+    ability_names = extract(ability_list)
+    model_names = extract(model_list)
     model_names.each do |model_name|
       definition = @@ability_definitions[model_name] || AbilityDefinition.new
       definition.merge(limitation.pluralize, ability_names)
       @@ability_definitions[model_name] = definition
     end
   end
-  
+
   def self.extract(string)
-    return *string.gsub(/[\[\]\s]/, '').split(',')
+    string.gsub(/[\[\]\s]/, '').split(',')
   end
-    
+
   def self.models
     @@ability_definitions
   end
-  
+
   def initialize
-    @cans, @cannots = [], []
+    @cans = []
+    @cannots = []
   end
-  
+
   def merge(limitation, ability_names)
     combined_ability_names = instance_variable_get("@#{limitation}") | ability_names
     instance_variable_set("@#{limitation}", combined_ability_names)
   end
-  
+
   def can
     @cans
   end
-  
+
   def cannot
     @cannots
   end
-      
 end