foobara 0.5.7 → 0.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d1c5cb75a03670d17291e1d85de76a826b6fedfe4b0f099f235ca646253c165
-  data.tar.gz: 7f852654ca70620a4dd544792d4518cfb7a5cd64214802517bdd9a3e1f435b19
+  metadata.gz: c97d7f81b121b86084fb6305b3327cdb82500828a1e4f87fc308c11390c46045
+  data.tar.gz: 7a48863a2c118156769df85217057309a680207af1af989d2465676c6cf012bc
 SHA512:
-  metadata.gz: 83077d31d4ac8f03a044568550f97a79a1772f6ec27f3b839501625a400d9b40550df500ba70e8e3241cf9ea001a2a52821b4c2c2c1a76241d5eb8265d36cf43
-  data.tar.gz: 9e41a5c335dab08647082b411e55ef4962ddf09a280cba9c8ee58b77533072349a0b271607a1f28ccd56eff82219182dd66e7e41177200abd979d855d9d53430
+  metadata.gz: 25ea5d0c8f87d7f77c0d6f8feecf93aac2940161eceebd3b8935013b7e06b617e12d8e003826f439f5685027b96121e795765a9b4376e2f08038f682f7860601
+  data.tar.gz: 8b7796124e4e7d553f895c46913a693aa3f42666712a8100404bf68bcdaf80f25ec201177894c72efc6d7b53aac1565be8fe4c795f3a762ab4127d0da9b344fa

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# [0.5.9] - 2026-03-06
+
+- Do not require an allowed rule for builtin-in commands when using requires_allowed_rule: true
+
+# [0.5.8] - 2026-03-04
+
+- Provide a way for allowed rules to be declared independently of connecting commands
+
 # [0.5.7] - 2026-02-25
 
 - Add a Manifest::Model.associations convenience method

data/projects/command_connectors/spec/allowed_rules_spec.rb

@@ -0,0 +1,77 @@
+RSpec.describe Foobara::CommandConnector do
+  after { Foobara.reset_alls }
+
+  let(:authenticator) { -> { :some_user } }
+
+  let(:response) { command_connector.run(full_command_name:, action:, inputs:) }
+  let(:parsed_response) { JSON.parse(response.body) }
+
+  let(:action) { "run" }
+  let(:full_command_name) { "ComputeExponent" }
+  let(:inputs) do
+    { base:, exponent: }
+  end
+
+  let(:command_class) do
+    stub_class(:ComputeExponent, Foobara::Command) do
+      inputs do
+        exponent :integer, :required
+        base :integer, :required
+      end
+
+      result :integer
+
+      attr_accessor :exponential
+
+      def execute
+        compute
+
+        exponential
+      end
+
+      def compute
+        self.exponential = 1
+
+        exponent.times do
+          self.exponential *= base
+        end
+      end
+    end
+  end
+
+  context "when independently setting the allowed rules" do
+    let(:command_connector) do
+      described_class.new(authenticator:,
+                          allow: { command_class => -> { base.even? } })
+    end
+
+    before do
+      command_connector.connect(command_class)
+    end
+
+    context "when allowed rule is met" do
+      let(:base) { 2 }
+      let(:exponent) { 3 }
+
+      it "runs the command" do
+        expect(response.status).to be(0)
+        expect(response.error).to be_nil
+        expect(response.body).to eq(8)
+      end
+    end
+
+    context "when allowed rule is not met" do
+      let(:base) { 3 }
+      let(:exponent) { 3 }
+
+      it "is not authorized" do
+        expect(response.status).to be(1)
+
+        errors = response.body
+
+        expect(errors.size).to eq(1)
+        expect(errors.first).to be_a(Foobara::CommandConnector::NotAllowedError)
+      end
+    end
+  end
+end

data/projects/command_connectors/src/authenticator_selector.rb

@@ -9,7 +9,7 @@ module Foobara
       def initialize(authenticators:, symbol: nil, explanation: nil, &block)
         self.authenticators = authenticators
 
-        symbol ||= authenticators.map(&:symbol).map(&:to_s).join("_or_").to_sym
+        symbol ||= authenticators.map(&:symbol).join("_or_").to_sym
         explanation ||= authenticators.map(&:explanation).join(", or ")
 
         super(symbol:, explanation:)

data/projects/command_connectors/src/command_connector.rb

@@ -199,7 +199,10 @@ module Foobara
                    default_pre_commit_transformers: nil,
                    auth_map: nil,
                    current_user: nil,
+                   # TODO: let's default this to true
                    requires_allowed_rule: false,
+                   allowed_rules: nil,
+                   allow: nil,
                    &block)
       authenticator = self.class.to_authenticator(authenticator)
 
@@ -216,6 +219,8 @@ module Foobara
 
       self.authenticator = authenticator
       self.command_registry = CommandRegistry.new(authenticator:)
+      allowed_rules&.each_pair { |symbol, rule| register_allowed_rule(symbol, rule) }
+      self.allow allow if allow
 
       self.capture_unknown_error = capture_unknown_error
       self.name = name
@@ -242,6 +247,10 @@ module Foobara
       end
     end
 
+    def allow(rules)
+      command_registry.allow rules
+    end
+
     def register_allowed_rule(*ruleish_args)
       command_registry.allowed_rule(*ruleish_args)
     end
@@ -404,8 +413,6 @@ module Foobara
           raise NoCommandFoundError.new(message: "Could not find command registered for #{full_command_name}")
           # :nocov:
         end
-
-        transformed_command_class
       else
         action = case action
                  when "describe_type", "manifest", "describe_command"
@@ -424,8 +431,15 @@ module Foobara
         command_class = find_builtin_command_class(command_name)
         full_command_name = command_class.full_command_name
 
-        transformed_command_from_name(full_command_name) || transform_command_class(command_class)
+        transformed_command_class = transformed_command_from_name(full_command_name) ||
+                                    transform_command_class(command_class)
+
+        if transformed_command_class < TransformedCommand
+          transformed_command_class.builtin = true
+        end
       end
+
+      transformed_command_class
     end
 
     def request_to_command_inputs(request)
@@ -631,8 +645,14 @@ module Foobara
 
     def run_command(request)
       command = request.command
+      command_class = request.command_class
 
-      if requires_allowed_rule
+      if requires_allowed_rule &&
+         command.is_a?(TransformedCommand) &&
+         # The != false looks odd and must be that we want to distinguish between the default (nil)
+         # and explicitly not requiring auth
+         command.class.requires_authentication != false &&
+         !command_class.builtin?
         unless command.allowed_rule
           raise NoAllowedRuleGivenError,
                 "Must connect #{command.full_command_name} with an `allowed_if:` " \

data/projects/command_connectors/src/command_registry.rb

@@ -9,9 +9,10 @@ module Foobara
     # Should we support different authenticators for different commands?
     # Might be a smell of two domains co-habitating in one? Or maybe one is just
     # passing another through and we should support that?
-    def initialize(authenticator: nil)
+    def initialize(authenticator: nil, allow: nil)
       self.scoped_path = []
       self.authenticator = authenticator
+      self.allow allow if allow
 
       customized = [:command]
 
@@ -193,15 +194,29 @@ module Foobara
       foobara_all_command.size
     end
 
+    def allow(rules = (no_args = true))
+      @allow ||= {}
+
+      if no_args
+        @allow
+      else
+        @allow = @allow.merge(rules)
+      end
+    end
+
     private
 
-    def create_exposed_command(command_class, **)
+    def create_exposed_command(command_class, **opts)
       full_domain_name = command_class.domain.scoped_full_name
       exposed_domain = foobara_lookup_domain(full_domain_name,
                                              mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) ||
                        build_and_register_exposed_domain(full_domain_name)
 
-      exposed_command = create_exposed_command_without_domain(command_class, **)
+      if !opts.key?(:allowed_rule) && allow&.key?(command_class)
+        opts = opts.merge(allowed_rule: allow[command_class])
+      end
+
+      exposed_command = create_exposed_command_without_domain(command_class, **opts)
 
       exposed_domain.foobara_register(exposed_command)
 
@@ -292,7 +307,7 @@ module Foobara
       errors_transformers: nil,
       pre_commit_transformers: nil,
       serializers: nil,
-      allowed_rule: default_allowed_rule,
+      allowed_rule: nil,
       authenticator: nil,
       **opts
     )

data/projects/command_connectors/src/transformed_command.rb

@@ -21,7 +21,8 @@ module Foobara
                     :requires_authentication,
                     :authenticator,
                     :subclassed_in_namespace,
-                    :suffix
+                    :suffix,
+                    :builtin
 
       def subclass(
         command_class,
@@ -546,6 +547,10 @@ module Foobara
         end
       end
 
+      def builtin?
+        builtin
+      end
+
       private
 
       def processors_to_manifest_symbols(processors)

data/projects/command_connectors/src/transformers/auth_errors_transformer.rb

@@ -12,7 +12,7 @@ module Foobara
               map = map.merge(possible_error.key.to_s => possible_error)
             end
 
-            if transformed_command.allowed_rule
+            if transformed_command.allowed_rule && transformed_command.allowed_rule.symbol != :always
               possible_error = PossibleError.new(CommandConnector::NotAllowedError)
               map = map.merge(possible_error.key.to_s => possible_error)
             end

data/projects/entities/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/symbolize_private.rb

@@ -18,7 +18,7 @@ module Foobara
           def desugarize(rawish_type_declaration)
             private = rawish_type_declaration[:private]
 
-            if private.any? { |key| key.is_a?(::String) }
+            if private.any?(::String)
               rawish_type_declaration[:private] = private.map(&:to_sym)
             end
 

data/projects/typesystem/projects/common/src/error_collection.rb

@@ -83,9 +83,13 @@ module Foobara
     end
 
     def errors_hash
-      each_with_object({}) do |error, hash|
-        hash[error.key] = error.to_h
+      h = {}
+
+      each do |error|
+        h[error.key] = error.to_h
       end
+
+      h
     end
 
     def to_sentence

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.5.7".freeze
+    VERSION = "0.5.9".freeze
     MINIMUM_RUBY_VERSION = ">= 3.4.0".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.5.9
 platform: ruby
 authors:
 - Miles Georgi
@@ -106,6 +106,7 @@ files:
 - projects/command/src/state_machine.rb
 - projects/command_connectors/Guardfile
 - projects/command_connectors/lib/foobara/command_connectors.rb
+- projects/command_connectors/spec/allowed_rules_spec.rb
 - projects/command_connectors/spec/ambiguous_lookups_spec.rb
 - projects/command_connectors/spec/auth_mappers_spec.rb
 - projects/command_connectors/spec/command_connector_spec.rb