foobara-http-command-connector 1.1.1 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3013f15a6e04c65bfddcc8163eda0216d46ec70e21cf502be342498fc93d7f6a
-  data.tar.gz: 5d79f4cbd50aabbca7059fccadeda2d2b3db0411644d0e72700782fa5da20413
+  metadata.gz: 1715bfa9cb8f787d96db3b2f527b314e9a21bc61cdb493e80db1c716c101a73d
+  data.tar.gz: 751386e288a082a533560620176b612ea8752c6fdf98ee985072e917fd45f253
 SHA512:
-  metadata.gz: 69af62d21fdae86bd10d1c58a6676e48ec263cf9dedc1c4c83c315db8243c3dffe85769586aa654dc3f7283a969e618631162e0d4d4adc07373e7fda9d9b71f6
-  data.tar.gz: c89d254db34fed4350696e33c63457312fbb939fab9ffa57f79e7e7add24239f1630ee802fb8583837d7dfd725e3862d8c55139a3c03b6405b177e24745d2128
+  metadata.gz: a1e22c9dec299e223eeb6ff2e79fef4b01f1f83687b213cadf42196a5887a9cdce3941030e35945216c6a5f70931fb6418c3011fea507fe0bcfbbbac561d0486
+  data.tar.gz: 2714a1040ea6857c0cdf818524b5ce0b67496a43dc421b4bd41c8cb1c0294b9762fb6cd35adfa9f6900e23b784ae2efb85b2d0d48b0c4db53781c9e5778759ce

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [1.1.3] - 2026-01-21
+
+- Add `set:` request mutator sugar
+
+## [1.1.2] - 2025-12-18
+
+- Fix bug causing commands to cram together on help page
+- Refactor help rendering
+- Make strings frozen-string compatible
+
 ## [1.1.1] - 2025-08-25
 
 - Add support for including processors

data/lib/foobara/http_command_connector.rb

@@ -2,3 +2,15 @@ require "foobara/all"
 require "foobara/command_connectors"
 
 Foobara::Util.require_directory "#{__dir__}/../../src"
+
+module Foobara
+  module HttpCommandConnector
+    class << self
+      def install!
+        CommandConnector.add_desugarizer CommandConnectors::Http::Desugarizers::SetInputToProcResult
+      end
+    end
+  end
+
+  project "http_command_connector", project_path: "#{__dir__}/../../"
+end

data/src/http/commands/help/presenter.rb

@@ -70,28 +70,28 @@ module Foobara
               self.manifest = manifest
             end
 
-            def render_html_list(data, skip_wrapper: false)
-              html = ""
+            def render_html_list(data)
+              html = +""
+
+              is_rendered_as_a_collection = rendered_as_collection?(data)
+
+              html << "<ul>" if is_rendered_as_a_collection
 
               case data
               when ::Hash
-                html << "<ul>" unless skip_wrapper
                 data.each do |key, value|
-                  html << "<li>#{key}"
-                  html << "<ul>"
-                  html << render_html_list(value, skip_wrapper: true)
-                  html << "</ul>"
-                  html << "</li>"
+                  html << render_list_child(value, key)
                 end
-                html << "</ul>" unless skip_wrapper
               when ::Array
-                html << "<ul>" unless skip_wrapper
-                data.each do |item|
-                  html << render_html_list(item)
+                if is_rendered_as_a_collection
+                  data.each do |item|
+                    html << render_list_child(item)
+                  end
+                else
+                  data = data.map { |item| render_html_list(item) }
+                  html << "[#{data.join(", ")}]"
                 end
-                html << "</ul>" unless skip_wrapper
               when Manifest::Attributes
-                html << "<ul>" unless skip_wrapper
                 data.relevant_manifest.each_pair do |key, value|
                   if key.to_s == "type"
                     next
@@ -101,59 +101,77 @@ module Foobara
                     key = :attributes
                     value = data.attribute_declarations
                   end
-                  html << "<li>#{key}"
-                  html << "<ul>"
-                  html << render_html_list(value, skip_wrapper: true)
-                  html << "</ul>"
-                  html << "</li>"
+
+                  html << render_list_child(value, key)
                 end
-                html << "</ul>" unless skip_wrapper
               when Manifest::Array
-                html << "<ul>" unless skip_wrapper
                 data.relevant_manifest.each_pair do |key, value|
                   next if key == :element_type_declaration
 
                   if key.to_s == "type"
                     value = root_manifest.lookup_path(key, value)
                   end
-                  html << "<li>#{key}"
-                  html << "<ul>"
-                  html << render_html_list(value, skip_wrapper: true)
-                  html << "</ul>"
-                  html << "</li>"
+                  html << render_list_child(value, key)
                 end
-                html << render_html_list({ element_type: data.element_type }, skip_wrapper: true)
-                html << "</ul>" unless skip_wrapper
+
+                html << render_html_list({ element_type: data.element_type })
               when Manifest::TypeDeclaration
                 manifest = data.relevant_manifest
 
                 if manifest.is_a?(::Symbol)
                   html << foobara_reference_link(data.to_type)
                 else
-                  html << "<ul>" unless skip_wrapper
                   data.relevant_manifest.each_pair do |key, value|
                     if key.to_s == "type"
                       value = root_manifest.lookup_path(key, value)
                     end
-                    html << "<li>#{key}"
-                    html << "<ul>"
-                    html << render_html_list(value, skip_wrapper: true)
-                    html << "</ul>"
-                    html << "</li>"
+
+                    html << render_list_child(value, key)
                   end
-                  html << "</ul>" unless skip_wrapper
                 end
               when Manifest::Type, Manifest::Command, Manifest::Error
                 html << foobara_reference_link(data)
               when Manifest::PossibleError
                 html << render_html_list(data.error)
               else
-                html << "<li>#{data}</li>"
+                html << case data
+                        when Numeric, TrueClass, FalseClass, NilClass
+                          data.inspect
+                        when ::String
+                          data
+                        when ::Symbol, ::Time
+                          data.to_s
+                        else
+                          # :nocov:
+                          raise "Not sure how to render #{data.class}"
+                          # :nocov:
+                        end
               end
 
+              html << "</ul>" if is_rendered_as_a_collection
+
               html
             end
 
+            def rendered_as_collection?(data)
+              if data.is_a?(::Array)
+                data.size > 5 || data.any? { |element| rendered_as_collection?(element) }
+              elsif data.is_a?(Manifest::TypeDeclaration)
+                !data.relevant_manifest.is_a?(::Symbol)
+              else
+                [
+                  ::Hash,
+                  Manifest::Attributes,
+                  Manifest::Array
+                ].any? { |klass| data.is_a?(klass) }
+              end
+            end
+
+            def render_list_child(child, label = nil)
+              label = "#{label}:" if label
+              "<li>#{label}\n#{render_html_list(child)}\n</li>"
+            end
+
             def foobara_reference_link(manifest)
               path = "/help/#{manifest.reference}"
 

data/src/http/desugarizers/set_input_to_proc_result.rb

@@ -0,0 +1,51 @@
+module Foobara
+  module CommandConnectors
+    class Http < CommandConnector
+      module Desugarizers
+        class SetInputToProcResult < Desugarizer
+          def applicable?(args_and_opts)
+            _args, opts = args_and_opts
+
+            return false unless opts.key?(:request_mutators)
+
+            mutators = opts[:request_mutators]
+            mutators = Util.array(mutators)
+
+            mutators.any? do |mutator|
+              mutator.is_a?(::Hash) && mutator.key?(:set)
+            end
+          end
+
+          def desugarize(args_and_opts)
+            args, opts = args_and_opts
+
+            mutators = opts[:request_mutators]
+            resulting_mutators = []
+
+            Util.array(mutators).map do |mutator|
+              if mutator.is_a?(::Hash) && mutator.key?(:set)
+                if mutator.size > 1
+                  # TODO: add test for this
+                  # :nocov:
+                  resulting_mutators << mutator.except(:set)
+                  # :nocov:
+                end
+
+                mutator[:set].each_pair do |input_name, proc|
+                  resulting_mutators << Http::SetInputToProcResult.for(input_name, &proc)
+                end
+              else
+                # TODO: add a test for this
+                # :nocov:
+                resulting_mutators << mutator
+                # :nocov:
+              end
+            end
+
+            [args, opts.merge(request_mutators: resulting_mutators)]
+          end
+        end
+      end
+    end
+  end
+end

data/src/http/request_mutators/set_input_to_proc_result.rb

@@ -3,6 +3,7 @@ module Foobara
     class Http < CommandConnector
       # TODO: We don't really want to mutate the request. We just need access to the authenticated user.
       # consider changing inputs transformer to have access to the command/request somehow
+      # TODO: what does this have to do with HTTP? Shouldn't this be a generic mutator for all connectors?
       class SetInputToProcResult < RequestMutator
         class << self
           attr_accessor :attribute_name, :input_value_proc

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-http-command-connector
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.3
 platform: ruby
 authors:
 - Miles Georgi
@@ -70,6 +70,7 @@ files:
 - src/http/commands/help/templates/root.html.erb
 - src/http/commands/help/templates/type.html.erb
 - src/http/cookie.rb
+- src/http/desugarizers/set_input_to_proc_result.rb
 - src/http/request.rb
 - src/http/request_mutators/set_input_from_cookie.rb
 - src/http/request_mutators/set_input_from_header.rb