rabarber 4.1.1 → 4.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: feb905214f327d8aef99517ba1364252b6722430fe6ab1b4839055e1ae5b18fc
-  data.tar.gz: ed0cacc2d6ad0ec5fd436ba24e96c3c26489264c3f00c73822b24f4593b2fa01
+  metadata.gz: 73050af26c88e78f295c489ee5fc49c782b3950157db2ecd1dd48cdda5b10045
+  data.tar.gz: '08f7da98672774c2198c155be4fb6f795c23e7da72e565631ef0f08207cd2cb9'
 SHA512:
-  metadata.gz: 6f88384ea24337c233f9183fde8bda61ba2939c3947b9eff07c2b5a47ff44372ba0287258565c3a5e085c4dc80b5026206d7b126e23c58b541b6490778946123
-  data.tar.gz: 9d7d4243f90fdc36cf8c27c391154449b38407a42995791240b72571e2dff14fa3836e62ce43ca92d5d0c65a5835a1e14119a077eda59ebedbe4c6b2a5aa8bac
+  metadata.gz: d1482714aa484c800970ea77a081388a0df4b8945e8fc0931b76e8d6415ed9f88c01ad8834e873d9161a20c7a5f2208b10782fe95857024b1a6069919f83dd47
+  data.tar.gz: '06383d81e91f872419fb567b2ef18991abf6a32263297645725e52b70a9c383a769c72d3657fb9f61a6cc11fb30b2129d813ca63e1a352761f99795f287c86b7'

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## v4.1.2
+
+### Misc:
+
+- Replaced `git ls-files` with `Dir.glob` in gemspec for improved portability and compatibility
+
 ## v4.1.1
 
 ### Bugs:

data/README.md

@@ -248,17 +248,19 @@ This adds `.grant_access(action: nil, roles: nil, context: nil, if: nil, unless:
 The most basic usage of the method is as follows:
 
 ```rb
-class Crm::InvoicesController < ApplicationController
-  grant_access action: :index, roles: [:accountant, :admin]
-  def index
-    @invoices = Invoice.all
-    @invoices = @invoices.paid if current_user.has_role?(:accountant)
-    # ...
-  end
-
-  grant_access action: :destroy, roles: :admin
-  def destroy
-    # ...
+module Crm
+  class InvoicesController < ApplicationController
+    grant_access action: :index, roles: [:accountant, :admin]
+    def index
+      @invoices = Invoice.all
+      @invoices = @invoices.paid if current_user.has_role?(:accountant)
+      # ...
+    end
+
+    grant_access action: :destroy, roles: :admin
+    def destroy
+      # ...
+    end
   end
 end
 ```
@@ -267,23 +269,27 @@ This grants access to `index` action for users with `accountant` or `admin` role
 You can also define controller-wide rules (without `action` argument):
 
 ```rb
-class Crm::BaseController < ApplicationController
-  grant_access roles: [:admin, :manager]
+module Crm
+  class BaseController < ApplicationController
+    grant_access roles: [:admin, :manager]
 
-  grant_access action: :dashboard, roles: :marketer
-  def dashboard
-    # ...
+    grant_access action: :dashboard, roles: :marketer
+    def dashboard
+      # ...
+    end
   end
 end
 
-class Crm::InvoicesController < Crm::BaseController
-  grant_access roles: :accountant
-  def index
-    # ...
-  end
+module Crm
+  class InvoicesController < Crm::BaseController
+    grant_access roles: :accountant
+    def index
+      # ...
+    end
 
-  def delete
-    # ...
+    def delete
+      # ...
+    end
   end
 end
 ```
@@ -311,28 +317,34 @@ If you've set `must_have_roles` setting to `true`, then only the users with at l
 
 Also keep in mind that rules defined in child classes don't override parent rules but rather add to them:
 ```rb
-class Crm::BaseController < ApplicationController
-  grant_access roles: :admin
+module Crm
+  class BaseController < ApplicationController
+    grant_access roles: :admin
   # ...
+  end
 end
 
-class Crm::InvoicesController < Crm::BaseController
-  grant_access roles: :accountant
+module Crm
+  class InvoicesController < Crm::BaseController
+    grant_access roles: :accountant
   # ...
+  end
 end
 ```
 This means that `Crm::InvoicesController` is still accessible to `admin` but is also accessible to `accountant`.
 
 This applies as well to multiple rules defined for the same controller or action:
 ```rb
-class Crm::OrdersController < ApplicationController
-  grant_access roles: :manager, context: Order
-  grant_access roles: :admin
+module Crm
+  class OrdersController < ApplicationController
+    grant_access roles: :manager, context: Order
+    grant_access roles: :admin
 
-  grant_access action: :show, roles: :client, context: -> { Order.find(params[:id]) }
-  grant_access action: :show, roles: :accountant
-  def show
-    # ...
+    grant_access action: :show, roles: :client, context: -> { Order.find(params[:id]) }
+    grant_access action: :show, roles: :accountant
+    def show
+      # ...
+    end
   end
 end
 ```
@@ -343,38 +355,42 @@ This will add rules for `manager` and `admin` roles for all actions in `Crm::Ord
 For more complex cases, Rabarber provides dynamic rules:
 
 ```rb
-class Crm::OrdersController < ApplicationController
-  grant_access roles: :manager, if: :company_manager?, unless: :fired?
+module Crm
+  class OrdersController < ApplicationController
+    grant_access roles: :manager, if: :company_manager?, unless: :fired?
 
-  def index
-    # ...
-  end
+    def index
+      # ...
+    end
 
-  private
+    private
 
-  def company_manager?
-    Company.find(params[:company_id]).manager == current_user
-  end
+    def company_manager?
+      Company.find(params[:company_id]).manager == current_user
+    end
 
-  def fired?
-    current_user.fired?
+    def fired?
+      current_user.fired?
+    end
   end
 end
 
-class Crm::InvoicesController < ApplicationController
-  grant_access roles: :senior_accountant
-
-  grant_access action: :index, roles: [:secretary, :accountant], if: -> { InvoicesPolicy.new(current_user).can_access?(:index) }
-  def index
-    @invoices = Invoice.all
-    @invoices = @invoices.where("total < 10000") if current_user.has_role?(:accountant)
-    @invoices = @invoices.unpaid if current_user.has_role?(:secretary)
-    # ...
-  end
-
-  grant_access action: :show, roles: :accountant, unless: -> { Invoice.find(params[:id]).total > 10_000 }
-  def show
-    # ...
+module Crm
+  class InvoicesController < ApplicationController
+    grant_access roles: :senior_accountant
+
+    grant_access action: :index, roles: [:secretary, :accountant], if: -> { InvoicesPolicy.new(current_user).can_access?(:index) }
+    def index
+      @invoices = Invoice.all
+      @invoices = @invoices.where("total < 10000") if current_user.has_role?(:accountant)
+      @invoices = @invoices.unpaid if current_user.has_role?(:secretary)
+      # ...
+    end
+
+    grant_access action: :show, roles: :accountant, unless: -> { Invoice.find(params[:id]).total > 10_000 }
+    def show
+      # ...
+    end
   end
 end
 ```
@@ -408,27 +424,27 @@ Every Rabarber method can accept a context as an additional keyword argument. By
 E.g., consider a model named `Project`, where each project has its owner and regular members. Roles can be defined like this:
 
 ```rb
-  user.assign_roles(:owner, context: project)
-  another_user.assign_roles(:member, context: project)
+user.assign_roles(:owner, context: project)
+another_user.assign_roles(:member, context: project)
 ```
 
 Then the roles can be verified:
 
 ```rb
-  user.has_role?(:owner, context: project)
-  another_user.has_role?(:member, context: project)
+user.has_role?(:owner, context: project)
+another_user.has_role?(:member, context: project)
 ```
 
 A role can also be added using a class as a context, e.g., for project admins who can manage all projects:
 
 ```rb
-  user.assign_roles(:admin, context: Project)
+user.assign_roles(:admin, context: Project)
 ```
 
 And then it can also be verified:
 
 ```rb
-  user.has_role?(:admin, context: Project)
+user.has_role?(:admin, context: Project)
 ```
 
 In authorization rules, the context can be used in the same way, but it also can be a proc or a symbol (similar to dynamic rules):
@@ -460,13 +476,13 @@ It's important to note that role names are not unique globally but are unique wi
 If you want to see all the roles assigned to a user within a specific context, you can use:
 
 ```rb
-  user.roles(context: project)
+user.roles(context: project)
 ```
 
 Or if you want to get all the roles available in a specific context, you can use:
 
 ```rb
-  Rabarber::Role.names(context: Project)
+Rabarber::Role.names(context: Project)
 ```
 
 ## When Unauthorized

data/lib/rabarber/core/cache.rb

@@ -38,10 +38,7 @@ module Rabarber
   end
 
   module Cache
-    module_function
-
-    def clear
-      Rabarber::Core::Cache.clear
-    end
+    delegate :clear, to: :"Rabarber::Core::Cache"
+    module_function :clear
   end
 end

data/lib/rabarber/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rabarber
-  VERSION = "4.1.1"
+  VERSION = "4.1.2"
 end

data/rabarber.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
 
   spec.files = [
     "rabarber.gemspec", "README.md", "CHANGELOG.md", "LICENSE.txt"
-  ] + `git ls-files | grep -E '^(lib)'`.split("\n")
+  ] + Dir.glob("lib/**/*")
 
   spec.require_paths = ["lib"]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rabarber
 version: !ruby/object:Gem::Version
-  version: 4.1.1
+  version: 4.1.2
 platform: ruby
 authors:
 - enjaku4
 - trafium
 bindir: bin
 cert_chain: []
-date: 2025-01-22 00:00:00.000000000 Z
+date: 2025-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails