foobara 0.0.1

data/projects/command_connectors/src/command_registry.rb

@@ -0,0 +1,257 @@
+module Foobara
+  class CommandRegistry
+    include TruncatedInspect
+
+    foobara_instances_are_namespaces!
+
+    attr_accessor :authenticator, :default_allowed_rule
+
+    def initialize(authenticator: nil)
+      self.scoped_path = []
+      self.authenticator = authenticator
+
+      customized = %i[command domain organization]
+
+      Namespace.global.foobara_categories.keys.reverse.each do |symbol|
+        next if customized.include?(symbol)
+
+        proc = Namespace.global.foobara_categories[symbol]
+
+        foobara_add_category(symbol, &proc)
+      end
+
+      foobara_add_category_for_instance_of(:command, ExposedCommand)
+      foobara_add_category_for_instance_of(:domain, ExposedDomain)
+      foobara_add_category_for_instance_of(:organization, ExposedOrganization)
+    end
+
+    def register(command_class, **)
+      create_exposed_command(command_class, **)
+    end
+
+    def create_exposed_command(command_class, **)
+      full_domain_name = command_class.domain.scoped_full_name
+      exposed_domain = foobara_lookup_domain(full_domain_name) || build_and_register_exposed_domain(full_domain_name)
+
+      exposed_command = create_exposed_command_without_domain(command_class, **)
+
+      exposed_domain.foobara_register(exposed_command)
+
+      exposed_command
+    end
+
+    # TODO: eliminate this method
+    def create_exposed_command_without_domain(command_class, **)
+      ExposedCommand.new(command_class, **apply_defaults(**))
+    end
+
+    def apply_defaults(
+      inputs_transformers: nil,
+      result_transformers: nil,
+      errors_transformers: nil,
+      pre_commit_transformers: nil,
+      serializers: nil,
+      allowed_rule: default_allowed_rule,
+      authenticator: self.authenticator,
+      **opts
+    )
+      opts.merge(
+        inputs_transformers: [*inputs_transformers, *default_inputs_transformers],
+        result_transformers: [*result_transformers, *default_result_transformers],
+        errors_transformers: [*errors_transformers, *default_errors_transformers],
+        pre_commit_transformers: [*pre_commit_transformers, *default_pre_commit_transformers],
+        serializers: [*serializers, *default_serializers],
+        allowed_rule: allowed_rule && to_allowed_rule(allowed_rule),
+        authenticator:
+      )
+    end
+
+    def build_and_register_exposed_domain(domain_full_name)
+      # TODO: would be nice to not have to do this...
+      domain_module = if domain_full_name.to_s == ""
+                        GlobalDomain
+                      else
+                        Namespace.global.foobara_lookup_domain!(domain_full_name)
+                      end
+
+      full_organization_name = domain_module.foobara_full_organization_name
+      exposed_organization = foobara_lookup_organization(full_organization_name) ||
+                             build_and_register_exposed_organization(full_organization_name)
+
+      exposed_domain = ExposedDomain.new(domain_module)
+
+      exposed_organization.foobara_register(exposed_domain)
+      exposed_domain.foobara_parent_namespace = exposed_organization
+
+      exposed_domain
+    end
+
+    def build_and_register_exposed_organization(full_organization_name)
+      org = if full_organization_name.to_s == ""
+              GlobalOrganization
+            else
+              Namespace.global.foobara_lookup_organization!(full_organization_name)
+            end
+
+      exposed_organization = ExposedOrganization.new(org)
+      foobara_register(exposed_organization)
+      exposed_organization.foobara_parent_namespace = self
+
+      exposed_organization
+    end
+
+    def exposed_global_domain
+      exposed_global_organization.foobara_lookup_domain("") ||
+        build_and_register_exposed_domain("")
+    end
+
+    def exposed_global_organization
+      foobara_lookup_organization("") ||
+        build_and_register_exposed_organization("")
+    end
+
+    def [](name)
+      if name.is_a?(Class)
+        name.full_command_name
+      end
+
+      foobara_lookup(name)
+    end
+
+    def allowed_rule_registry
+      @allowed_rule_registry ||= {}
+    end
+
+    def allowed_rule(ruleish)
+      allowed_rule = to_allowed_rule(ruleish)
+
+      unless allowed_rule.symbol
+        # :nocov:
+        raise "Cannot register a rule without a symbol"
+        # :nocov:
+      end
+
+      allowed_rule_registry[allowed_rule.symbol] = allowed_rule
+    end
+
+    def allowed_rules(hash)
+      hash.map do |symbol, ruleish|
+        allowed_rule = to_allowed_rule(ruleish)
+        allowed_rule.symbol = symbol
+
+        allowed_rule(allowed_rule)
+      end
+    end
+
+    def default_inputs_transformers
+      @default_inputs_transformers ||= []
+    end
+
+    def add_default_inputs_transformer(transformer)
+      default_inputs_transformers << transformer
+    end
+
+    def default_result_transformers
+      @default_result_transformers ||= []
+    end
+
+    def add_default_result_transformer(transformer)
+      default_result_transformers << transformer
+    end
+
+    def default_errors_transformers
+      @default_errors_transformers ||= []
+    end
+
+    def add_default_errors_transformer(transformer)
+      default_errors_transformers << transformer
+    end
+
+    def default_pre_commit_transformers
+      @default_pre_commit_transformers ||= []
+    end
+
+    def add_default_pre_commit_transformer(transformer)
+      default_pre_commit_transformers << transformer
+    end
+
+    def default_serializers
+      @default_serializers ||= []
+    end
+
+    def add_default_serializer(serializer)
+      default_serializers << serializer
+    end
+
+    def to_allowed_rule(object)
+      case object
+      when AllowedRule, nil
+        object
+      when ::String
+        to_allowed_rule(object.to_sym)
+      when ::Symbol
+        allowed_rule = allowed_rule_registry[object]
+
+        unless allowed_rule
+          # :nocov:
+          raise "No allowed rule found for #{object}"
+          # :nocov:
+        end
+
+        allowed_rule
+      when ::Hash
+        rule_attributes = AllowedRule.allowed_rule_attributes_type.process_value!(object)
+
+        allowed_rule = to_allowed_rule(rule_attributes[:logic])
+
+        if rule_attributes.key?(:symbol)
+          allowed_rule.symbol = rule_attributes[:symbol]
+        end
+
+        if rule_attributes.key?(:explanation)
+          allowed_rule.explanation = rule_attributes[:explanation]
+        end
+
+        allowed_rule.explanation ||= allowed_rule.symbol
+
+        allowed_rule
+      when ::Array
+        rules = object.map { |ruleish| to_allowed_rule(ruleish) }
+
+        procs = rules.map(&:block)
+
+        block = proc do
+          procs.any?(&:call)
+        end
+
+        allowed_rule = AllowedRule.new(&block)
+
+        if rules.all?(&:explanation)
+          allowed_rule.explanation = Util.to_or_sentence(rules.map(&:explanation))
+        end
+
+        allowed_rule
+      else
+        if object.respond_to?(:call)
+          AllowedRule.new(&object)
+        else
+          # :nocov:
+          raise "Not sure how to convert #{object} into an AllowedRule object"
+          # :nocov:
+        end
+      end
+    end
+
+    def transformed_command_from_name(name)
+      foobara_lookup_command(name, mode: Namespace::LookupMode::RELAXED)&.transformed_command_class
+    end
+
+    def all_transformed_command_classes
+      foobara_all_command.map(&:transformed_command_class)
+    end
+
+    def each_transformed_command_class(&)
+      foobara_all_command.map(&:transformed_command_class).each(&)
+    end
+  end
+end

data/projects/command_connectors/src/commands/describe.rb

@@ -0,0 +1,36 @@
+module Foobara
+  module CommandConnectors
+    module Commands
+      class Describe < Foobara::Command
+        inputs manifestable: :duck,
+               request: :duck
+        result :associative_array
+
+        def execute
+          build_manifest
+          stamp_request_metadata
+
+          manifest
+        end
+
+        attr_accessor :manifest
+
+        def build_manifest
+          self.manifest = if manifestable.is_a?(CommandConnector)
+                            manifestable.foobara_manifest
+                          else
+                            manifestable.foobara_manifest(to_include: Set.new)
+                          end
+        end
+
+        def stamp_request_metadata
+          manifest[:metadata] = {
+            # TODO: why is this here instead of in Http ??
+            url: request.url,
+            when: Time.now
+          }
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors/src/commands/list_commands.rb

@@ -0,0 +1,51 @@
+module Foobara
+  module CommandConnectors
+    module Commands
+      class ListCommands < Command
+        inputs request: :duck, # TODO: have some way to specify by Ruby class...
+               verbose: :boolean
+
+        result [
+          [
+            :string,
+            {
+              type: :string,
+              allow_nil: true
+            }
+          ]
+        ]
+
+        def execute
+          build_list
+          build_result
+        end
+
+        attr_accessor :list
+
+        def build_list
+          self.list = command_connector.command_registry.all_transformed_command_classes
+        end
+
+        def verbose?
+          verbose
+        end
+
+        def build_result
+          if verbose?
+            list.map do |command_class|
+              [command_class.full_command_name, command_class.description]
+            end
+          else
+            list.map do |command_class|
+              [command_class.full_command_name, nil]
+            end
+          end
+        end
+
+        def command_connector
+          request.command_connector
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors/src/commands/ping.rb

@@ -0,0 +1,21 @@
+module Foobara
+  module CommandConnectors
+    module Commands
+      class Ping < Foobara::Command
+        result :datetime
+
+        def execute
+          set_pong
+
+          pong
+        end
+
+        attr_accessor :pong
+
+        def set_pong
+          self.pong = Time.now
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors/src/commands/query_git_commit_info.rb

@@ -0,0 +1,81 @@
+module Foobara
+  module CommandConnectors
+    module Commands
+      # NOTE: this assumes that the following has been executed to generate the `git_commit_info.json` file:
+      #
+      # git show -s --format='{"commit": "%H", "author": "%an <%ae>", "date": "%ad", "message": "%s"}' \
+      #   HEAD > $1/git_commit_info.json
+      class QueryGitCommitInfo < Foobara::Command
+        GIT_COMMIT_INFO_FILE = "git_commit_info.json".freeze
+
+        # TODO: creating these types of error classes should be much much easier!
+        class GitCommitInfoFileNotFoundError < Foobara::RuntimeError
+          class << self
+            def message
+              format = '{"commit": "%H", "author": "%an <%ae>", "date": "%ad", "message": "%s"}'
+
+              <<~HERE
+                Could not find file: #{GIT_COMMIT_INFO_FILE}.#{" "}
+                Are you sure you are executing the following in the right place in your infrastructure?
+
+                  git show -s --format='#{format}' HEAD > git_commit_info.json
+
+              HERE
+            end
+
+            def context_type_declaration
+              {}
+            end
+
+            def context
+              {}
+            end
+          end
+        end
+
+        possible_error GitCommitInfoFileNotFoundError
+
+        result commit: :string,
+               author: :string,
+               date: :string,
+               message: :string
+
+        def execute
+          validate_git_commit_info_exists
+          load_git_commit_info
+
+          git_commit_info
+        end
+
+        attr_accessor :commit,
+                      :author,
+                      :date,
+                      :message
+
+        def validate_git_commit_info_exists
+          unless File.exist?(GIT_COMMIT_INFO_FILE)
+            add_runtime_error GitCommitInfoFileNotFoundError
+          end
+        end
+
+        def load_git_commit_info
+          git_commit_info = JSON.parse(File.read(GIT_COMMIT_INFO_FILE))
+
+          self.commit = git_commit_info["commit"]
+          self.author = git_commit_info["author"]
+          self.date = git_commit_info["date"]
+          self.message = git_commit_info["message"]
+        end
+
+        def git_commit_info
+          {
+            commit:,
+            author:,
+            date:,
+            message:
+          }
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors/src/request.rb

@@ -0,0 +1,99 @@
+module Foobara
+  module CommandConnectors
+    class Request
+      include TruncatedInspect
+
+      # TODO: this feels like a smell of some sort...
+      attr_accessor :command_class, :command, :error, :command_connector, :serializers
+
+      def full_command_name
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def inputs
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def serializer
+        return @serializer if defined?(@serializer)
+
+        if serializers.nil? || serializers.empty?
+          @serializer = nil
+          return
+        end
+
+        actual_serializers = objects_to_serializers(serializers)
+
+        @serializer = if actual_serializers.size == 1
+                        actual_serializers.first
+                      else
+                        Value::Processor::Pipeline.new(processors: actual_serializers)
+                      end
+      end
+
+      def response_body
+        @response_body ||= begin
+          # TODO: should we have separate ways to register success and failure serializers?
+          body = success? ? result : error_collection
+
+          if serializer
+            serializer.process_value!(body)
+          else
+            body
+          end
+        end
+      end
+
+      def success?
+        outcome.success?
+      end
+
+      def outcome
+        command.outcome
+      end
+
+      def result
+        outcome.result
+      end
+
+      def error_collection
+        outcome.error_collection
+      end
+
+      private
+
+      def objects_to_serializers(objects)
+        objects.map do |object|
+          case object
+          when Class
+            object.new(self)
+          when Value::Processor
+            object
+          when ::Symbol, ::String
+            klass = Serializer.serializer_from_symbol(object)
+
+            unless klass
+              # :nocov:
+              raise "Could not find serializer for #{object}"
+              # :nocov:
+            end
+
+            klass.new(self)
+          else
+            if object.respond_to?(:call)
+              Value::Transformer.create(transform: object)
+            else
+              # :nocov:
+              raise "Not sure how to convert #{object} into a serializer"
+              # :nocov:
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors/src/response.rb

@@ -0,0 +1,17 @@
+module Foobara
+  module CommandConnectors
+    class Response
+      attr_accessor :status,
+                    :body,
+                    :request
+
+      def initialize(status:, body:, request:)
+        self.status = status
+        self.body = body
+        self.request = request
+      end
+
+      foobara_delegate :command, :error, to: :request
+    end
+  end
+end

data/projects/command_connectors/src/serializer.rb

@@ -0,0 +1,25 @@
+module Foobara
+  module CommandConnectors
+    class Serializer < Value::Transformer
+      class << self
+        def serializer_from_symbol(symbol)
+          Util.descendants(Serializer).find do |klass|
+            name = Util.non_full_name(klass)
+            name = name.gsub(/Serializer$/, "")
+            name = Util.underscore(name)
+
+            symbol.to_s == name
+          end
+        end
+      end
+
+      def request
+        declaration_data
+      end
+
+      def transform(object)
+        serialize(object)
+      end
+    end
+  end
+end

data/projects/command_connectors/src/serializers/aggregate_serializer.rb

@@ -0,0 +1,32 @@
+module Foobara
+  module CommandConnectors
+    module Serializers
+      class AggregateSerializer < SuccessSerializer
+        def serialize(object)
+          case object
+          when Entity
+            # TODO: handle polymorphism? Would require iterating over the result type not the object!
+            # Is there maybe prior art for this in the associations stuff?
+            unless object.loaded?
+              # :nocov:
+              raise "#{object} is not loaded so cannot serialize it"
+              # :nocov:
+            end
+
+            transform(object.attributes)
+          when Model
+            transform(object.attributes)
+          when Array
+            object.map { |element| transform(element) }
+          when Hash
+            object.to_h do |key, value|
+              [transform(key), transform(value)]
+            end
+          else
+            object
+          end
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors/src/serializers/atomic_serializer.rb

@@ -0,0 +1,25 @@
+module Foobara
+  module CommandConnectors
+    module Serializers
+      class AtomicSerializer < SuccessSerializer
+        def serialize(object)
+          if object.is_a?(Model)
+            if object.is_a?(Entity) && !object.loaded?
+              # :nocov:
+              raise "#{object} is not loaded so cannot serialize it"
+              # :nocov:
+            end
+
+            object = object.attributes
+          end
+
+          entities_to_primary_keys_serializer.serialize(object)
+        end
+
+        def entities_to_primary_keys_serializer
+          @entities_to_primary_keys_serializer ||= EntitiesToPrimaryKeysSerializer.new(declaration_data)
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors/src/serializers/entities_to_primary_keys_serializer.rb

@@ -0,0 +1,28 @@
+require_relative "success_serializer"
+
+module Foobara
+  module CommandConnectors
+    module Serializers
+      class EntitiesToPrimaryKeysSerializer < SuccessSerializer
+        def serialize(object)
+          case object
+          when Entity
+            # TODO: handle polymorphism? Would require iterating over the result type not the object!
+            # Is there maybe prior art for this in the associations stuff?
+            object.primary_key
+          when Model
+            object.attributes
+          when Array
+            object.map { |element| serialize(element) }
+          when Hash
+            object.to_h do |key, value|
+              [serialize(key), serialize(value)]
+            end
+          else
+            object
+          end
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors/src/serializers/errors_serializer.rb

@@ -0,0 +1,18 @@
+module Foobara
+  require_project_file("command_connectors", "serializer")
+
+  module CommandConnectors
+    module Serializers
+      class ErrorsSerializer < Serializer
+        # TODO: always_applicable? instead?
+        def always_applicable?
+          !request.outcome.success?
+        end
+
+        def serialize(errors)
+          errors.map(&:to_h)
+        end
+      end
+    end
+  end
+end