controller_policies 1.0.1 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bce0f759505e11b5f05fd9d220d1f8553a1b1a281f50a40b51533a160a225fd
-  data.tar.gz: e5f9d53c8bfe61e53e546c760fe0eba07d298717f5306f99575da4c8f60c4fb5
+  metadata.gz: 85d80d00d5bb31de269ac2190cd44a77e9d2aa1623aa7d6e00cf86de12565baa
+  data.tar.gz: ec23ef9100a962f17386693889903182f84cbb247c9dc275da54cec789acc445
 SHA512:
-  metadata.gz: 2b25df0839fdc02faf866a769f1102175ecda41fbf6e018ea735c981c712354270768af5770dc266cc9fc998cddc0ae6316c90b54570fb5faa4abf06c8c43d8b
-  data.tar.gz: da0373ebea81108926b63a898b0b9955aff0a9383a2fd4e49d7da0ea67c6784429550edb9d1312c34534a50aa4bc531bc1002f5f606b796431e773fa494f7827
+  metadata.gz: 9ec83f851cc09988e4664c404b2e99b2a8c48e954f3804652fb0477f66545d75b12887261e4b72c265da16dd3c8ce277e5fdcf6d170eea535b7dfe07c53aa2e8
+  data.tar.gz: 6afa4ececa6d5c04164eafc5c66a578290d6ff3edfcffff76260f6bb645450000b2177d33b49a9d3105eb8f6463a0cda3902a7caee3baa4acfa665b0395e9f39

data/README.md

@@ -20,6 +20,16 @@ rails g policy_definition my/namespace
 
 This will generate a file: `app/policies/my/namespace/definitions.rb`
 
+For controllers without a namespace (root-level controllers), you can generate a root-level definitions file:
+
+```sh
+rails g policy_definition root
+# or simply
+rails g policy_definition
+```
+
+This will generate a file: `app/policies/definitions.rb`
+
 The developer should edit this file and add the policies for the app. **It is important to note that the location of the definitions file should reflect the namespace of the associated controllers.**
 
 ### `actions` key
@@ -43,16 +53,35 @@ end
 
 The above definition will have enforced policies on `Base::FeatureApp::UsersController` (all actions), `Base::DataApp::ProductsController` (`index` action) and `Base::SubscriptionController`.
 
+For root-level controllers (controllers without a namespace), you can define policies directly in the `Policies` module:
+
+```ruby
+module Policies
+  DEFINITIONS = [
+    {
+      code: 'user_management',
+      name: 'User Management',
+      description: 'Allows user management operations',
+      actions: ['users', 'profiles#show', 'dashboard']
+    }
+  ]
+end
+```
+
+The above definition will have enforced policies on `UsersController` (all actions), `ProfilesController` (`show` action) and `DashboardController`.
+
 **Do note that the `actions` array implement *Regular Expression Matching*. That means that if you have multiple controllers with the same name on their parent namespace, the parent will be matched first.** To avoid this problem, simply add the namespace to match the intended child instead.
 
 ```ruby
-module Base
-  DEFINITIONS = {
-    code: 'policy_code',
-    name: 'Policy Name',
-    description: 'I am a policy.',
-    actions: ['feature_app/users', 'another_base/data_app/products#index', 'base/subscriptions']
-  }
+module Policies
+  module Base
+    DEFINITIONS = {
+      code: 'policy_code',
+      name: 'Policy Name',
+      description: 'I am a policy.',
+      actions: ['feature_app/users', 'another_base/data_app/products#index', 'base/subscriptions']
+    }
+  end
 end
 ```
 

data/lib/ability.rb

@@ -34,36 +34,28 @@ class Ability
 
     # Filter abilities based on namespace.
     def where(*queries)
-      results = []
-      queries.each do |query|
-        case query.class.to_s
-        when 'String'
-          results += all.select { |ability| ability.namespace.to_s == "Policies::#{trim(query).camelize}" }
-        when 'Module', 'Class'
-          results += all.select { |ability| ability.namespace == query }
+      queries.flat_map do |query|
+        case query
+        when String
+          filter_by_string_query(query)
+        when Module, Class
+          all.select { |ability| ability.namespace == query }
+        else
+          []
         end
       end
-      results
     end
 
-    # Find an ability within a namespace.
-    # def find(query_string)
-    #   where(query_string).first
-    # end
-
     # Match abilities based on a matching string or regex. The matcher is based on the namespace.
     def match(expression)
-      case expression.class.to_s
-      when 'String' then all.select { |ability| ability.namespace.to_s.match?(/#{trim(expression).camelize}/) }
-      when 'Regexp' then regex_matcher(expression)
+      case expression
+      when String
+        all.select { |ability| ability.namespace.to_s.match?(/#{trim(expression).camelize}/) }
+      when Regexp
+        regex_matcher(expression)
       end
     end
 
-    # Find an ability based on a matching string or regex. The matcher is based on the namespace.
-    # def mill(expression)
-    #   match(expression).first
-    # end
-
     # Path to the policy folder.
     def policy_path
       @policy_path ||= Rails.root.join('app/policies')
@@ -71,6 +63,15 @@ class Ability
 
     private
 
+    def filter_by_string_query(query)
+      if query.empty? || query == '/'
+        all.select { |ability| ability.namespace == Policies }
+      else
+        target_namespace = "Policies::#{trim(query).camelize}"
+        all.select { |ability| ability.namespace.to_s == target_namespace }
+      end
+    end
+
     def definitions
       @definitions ||= begin
         data = []
@@ -82,14 +83,20 @@ class Ability
     end
 
     def definition_files_post_processing(file_path)
-      module_constant = "Policies::#{convert_namespace(file_path)}".constantize
-      policy_definitions = module_constant::DEFINITIONS
-      policy_definitions.map do |policy_definition|
-        policy_definition[:namespace] = module_constant
-        policy_definition
+      namespace_path = convert_namespace(file_path)
+      module_constant = resolve_module_constant(namespace_path)
+
+      module_constant::DEFINITIONS.map do |policy_definition|
+        policy_definition.merge(namespace: module_constant)
       end
     end
 
+    def resolve_module_constant(namespace_path)
+      return Policies if namespace_path.empty?
+
+      "Policies::#{namespace_path}".constantize
+    end
+
     def regex_matcher(expression)
       all.select do |ability|
         ability.namespace.to_s.match?(expression) || ability.namespace.to_s.underscore.match?(expression)

data/lib/controller_policies/enforcement.rb

@@ -34,11 +34,23 @@ module ControllerPolicies
       # Method that attempts to go through policy definitions and check if it matches the current controller.
       # If it finds a match, it will be an applicable definition to check abilities for.
       def applicable_abilities
-        @applicable_abilities ||= Ability.where(controller_namespace).select do |ability|
-          matching_actions = ability.actions.select { |action| /#{action}/.match?("#{controller_path}##{action_name}") }
-          matching_actions.present?
+        @applicable_abilities ||= begin
+          namespace_abilities = fetch_namespace_abilities
+          namespace_abilities.select { |ability| ability_matches_current_action?(ability) }
         end
       end
+
+      # Get abilities for the current controller namespace, or root if no namespace
+      def fetch_namespace_abilities
+        namespace = controller_namespace.empty? ? '' : controller_namespace
+        Ability.where(namespace)
+      end
+
+      # Check if an ability matches the current controller action
+      def ability_matches_current_action?(ability)
+        current_controller_action = "#{controller_path}##{action_name}"
+        ability.actions.any? { |action| /#{action}/.match?(current_controller_action) }
+      end
     end
   end
 end

data/lib/controller_policies/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ControllerPolicies
-  VERSION = '1.0.1'
+  VERSION = '1.1.1'
 end

data/lib/generators/policy_definition_generator.rb

@@ -3,18 +3,22 @@
 # Generates a definition file for a namespace.
 class PolicyDefinitionGenerator < Rails::Generators::Base
   source_root File.expand_path('templates', __dir__)
-  desc 'Generates a policy definition file based on given namespace.'
-  argument :name, type: :string, required: true, desc: 'The namespace for the definition file.'
+  desc 'Generates a policy definition file based on given namespace. Leave empty for root-level definitions.'
+  argument :name, type: :string, required: false, default: '',
+                  desc: 'The namespace for the definition file. Leave empty for root-level definitions.'
 
   def create_policy_definition_file
-    return if processed_name.blank?
-
-    template 'definitions.rb', "app/policies/#{processed_name}/definitions.rb"
+    if processed_name.blank?
+      # Generate root-level definitions.rb
+      template 'root_definitions.rb', 'app/policies/definitions.rb'
+    else
+      template 'modular_definitions.rb', "app/policies/#{processed_name}/definitions.rb"
+    end
   end
 
   private
 
   def processed_name
-    @processed_name ||= name.strip.delete_prefix('/').delete_suffix('/')
+    @processed_name ||= name.strip.delete_prefix('/').delete_suffix('/') || ''
   end
 end

data/lib/generators/templates/{definitions.rb.tt → modular_definitions.rb.tt}

@@ -17,7 +17,7 @@ module Policies
       {
         code: 'Another-Policy-Code',
         name: 'Another Policy',
-        description: 'Long description.',
+        description: 'Long description.'
       }
     ].freeze
   end

data/lib/generators/templates/root_definitions.rb.tt

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Policies
+  DEFINITIONS = [
+    {
+      # Used as identifier for the policy.
+      code: 'Policy-Code',
+      # Readable name for the policy.
+      name: 'Readable Policy Name',
+      # Readable description for the policy.
+      description: 'Short description of what this policy allows',
+      # Controller actions the policy applies to. It works as matchers based on routes.
+      # It can be empty for manual policy checking.
+      actions: ['users', 'products#index', 'dashboard']
+    },
+    {
+      code: 'Another-Policy-Code',
+      name: 'Another Policy',
+      description: 'Long description.'
+    }
+  ].freeze
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: controller_policies
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.1
 platform: ruby
 authors:
 - Tien
 bindir: bin
 cert_chain: []
-date: 2025-03-03 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -47,7 +47,8 @@ files:
 - lib/controller_policies/railtie.rb
 - lib/controller_policies/version.rb
 - lib/generators/policy_definition_generator.rb
-- lib/generators/templates/definitions.rb.tt
+- lib/generators/templates/modular_definitions.rb.tt
+- lib/generators/templates/root_definitions.rb.tt
 homepage: https://github.com/tieeeeen1994/rails-controller-policies
 licenses:
 - MIT
@@ -68,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.5
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Allows the developer to define policies for controllers.
 test_files: []