foobara 0.0.1

data/projects/command_connectors_http/src/http/request.rb

@@ -0,0 +1,98 @@
+require "uri"
+
+module Foobara
+  module CommandConnectors
+    class Http < CommandConnector
+      class Request < CommandConnectors::Request
+        attr_accessor :path,
+                      :method,
+                      :headers,
+                      :query_string,
+                      :body,
+                      :scheme,
+                      :host,
+                      :port,
+                      :cookies,
+                      :remote_ip,
+                      :response_headers
+
+        def initialize(
+          path:,
+          method: nil,
+          headers: {},
+          query_string: "",
+          body: "",
+          scheme: nil,
+          host: nil,
+          port: nil,
+          cookies: nil,
+          remote_ip: nil
+        )
+          self.path = path
+          self.method = method
+          self.headers = headers
+          self.query_string = query_string
+          self.body = body
+          self.scheme = scheme
+          self.host = host
+          self.port = port
+          self.cookies = cookies
+          self.remote_ip = remote_ip
+
+          super()
+        end
+
+        def url
+          URI::Generic.build(
+            scheme:,
+            host:,
+            port:,
+            path:,
+            query: query_string.nil? || query_string.empty? ? nil : query_string
+          ).to_s
+        end
+
+        def inputs
+          @inputs ||= parsed_body.merge(parsed_query_string)
+        end
+
+        def full_command_name
+          unless defined?(@full_command_name)
+            set_action_and_command_name
+          end
+
+          @full_command_name
+        end
+
+        def parsed_body
+          body.empty? ? {} : JSON.parse(body)
+        end
+
+        def parsed_query_string
+          if query_string.nil? || query_string.empty?
+            {}
+          else
+            # TODO: override this in rack connector to use better rack utils
+            CGI.parse(query_string).transform_values!(&:first)
+          end
+        end
+
+        def action
+          unless defined?(@action)
+            set_action_and_command_name
+          end
+
+          @action
+        end
+
+        def argument
+          path.split("/")[2]
+        end
+
+        def set_action_and_command_name
+          @action, @full_command_name = path[1..].split("/")
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors_http/src/http/response.rb

@@ -0,0 +1,14 @@
+module Foobara
+  module CommandConnectors
+    class Http < CommandConnector
+      class Response < CommandConnectors::Response
+        attr_accessor :headers
+
+        def initialize(headers:, **opts)
+          self.headers = headers
+          super(**opts)
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors_http/src/http.rb

@@ -0,0 +1,84 @@
+module Foobara
+  module CommandConnectors
+    class Http < CommandConnector
+      include TruncatedInspect
+
+      def request_to_command(context)
+        if context.method == "OPTIONS"
+          # TODO: this feels a bit hacky and like overkill...
+          return Foobara::CommandConnectors::Http::Commands::GetOptions.new
+        end
+
+        command = super
+
+        if context.action == "help"
+          # Let's unwrap the transformed command to avoid serialization
+          # TODO: maybe instead register Help without serializers?
+          command = command.command
+        end
+
+        command
+      end
+
+      # TODO: eliminate passing the command here...
+      def request_to_response(request)
+        command = request.command
+        outcome = command.outcome
+
+        # TODO: feels awkward to call this here... Maybe use result/errors transformers instead??
+        # Or call the serializer here??
+        body = command.respond_to?(:serialize_result) ? command.serialize_result : outcome.result
+
+        status = if outcome.success?
+                   200
+                 else
+                   errors = outcome.errors
+
+                   if errors.size == 1
+                     error = errors.first
+
+                     case error
+                     when CommandConnector::UnknownError
+                       500
+                     when CommandConnector::NotFoundError, Foobara::Entity::NotFoundError
+                       # TODO: we should not be coupled to Entities here...
+                       body ||= "Not found"
+                       404
+                     when CommandConnector::UnauthenticatedError
+                       401
+                     when CommandConnector::NotAllowedError
+                       403
+                     end
+                   end || 422
+                 end
+
+        headers = headers_for(request)
+
+        Response.new(status:, headers:, body:, request:)
+      end
+
+      def headers_for(request)
+        response_headers = request.response_headers
+
+        if response_headers
+          static_headers.merge(response_headers)
+        else
+          static_headers.dup
+        end
+      end
+
+      private
+
+      def static_headers
+        @static_headers ||= ENV.each_with_object({}) do |(key, value), headers|
+          match = key.match(/\AFOOBARA_HTTP_RESPONSE_HEADER_(.*)\z/)
+
+          if match
+            header_name = match[1].downcase.tr("_", "-")
+            headers[header_name] = value
+          end
+        end.freeze
+      end
+    end
+  end
+end

data/projects/common/lib/foobara/common.rb

@@ -0,0 +1,11 @@
+module Foobara
+  module Common
+    class << self
+      def install!
+        Namespace.global.foobara_add_category_for_subclass_of(:processor_class, Value::Processor)
+        Namespace.global.foobara_add_category_for_instance_of(:processor, Value::Processor)
+        Namespace.global.foobara_add_category_for_subclass_of(:error, Error)
+      end
+    end
+  end
+end

data/projects/common/src/data_path.rb

@@ -0,0 +1,272 @@
+module Foobara
+  # TODO: figure out how to share code between here and ErrorKey
+  # TODO: use this to implement computed attributes
+  class DataPath
+    class BadPathError < StandardError; end
+
+    # TODO: use this wherever it makes sense
+    EMPTY_PATH = [].freeze
+
+    class TooManyValuesAtPathError < StandardError
+      attr_accessor :path, :values
+
+      def initialize(path, values)
+        self.path = path
+        self.values = values
+
+        super(message)
+      end
+
+      def message
+        "Expected only one value to be at #{path} but there were #{values.size}: #{values}"
+      end
+    end
+
+    class << self
+      def to_s_type(key)
+        unless key.is_a?(DataPath)
+          key = new(key)
+        end
+
+        key.to_s_type
+      end
+
+      def values_at(data_path, object)
+        unless data_path.is_a?(DataPath)
+          data_path = new(data_path)
+        end
+
+        data_path.values_at(object)
+      end
+
+      def value_at(data_path, object)
+        unless data_path.is_a?(DataPath)
+          data_path = new(data_path)
+        end
+
+        data_path.value_at(object)
+      end
+
+      def set_value_at(object, value, data_path)
+        unless data_path.is_a?(DataPath)
+          data_path = new(data_path)
+        end
+
+        data_path.set_value_at(object, value)
+      end
+
+      def prepend_path(key, *)
+        if key.is_a?(DataPath)
+          key.prepend(*)
+        else
+          key = new(key)
+          key.prepend!(*).to_s
+        end
+      end
+
+      def append_path(key, *)
+        if key.is_a?(DataPath)
+          key.append(*)
+        else
+          key = new(key)
+          key.append!(*).to_s
+        end
+      end
+
+      def parse(key_string)
+        new(key_string)
+      end
+    end
+
+    attr_reader :path
+
+    # TODO: accept error_class instead of symbol/category??
+    def initialize(path = [])
+      path = path.to_s if path.is_a?(::Symbol)
+      path = path.split(".") if path.is_a?(::String)
+
+      self.path = path
+    end
+
+    def path=(path)
+      @path = normalize_all(path)
+    end
+
+    def prepend!(*prepend_parts)
+      if prepend_parts.size == 1
+        arg = prepend_parts.first
+
+        if arg.is_a?(Array)
+          prepend_parts = arg
+        end
+      end
+
+      self.path = [*prepend_parts, *path]
+      self
+    end
+
+    def prepend(*)
+      dup.tap do |key|
+        key.prepend!(*)
+      end
+    end
+
+    def append!(*append_parts)
+      if append_parts.size == 1
+        arg = append_parts.first
+
+        if arg.is_a?(Array)
+          append_parts = arg
+        end
+      end
+
+      self.path = [*path, *append_parts]
+      self
+    end
+
+    def append(*)
+      dup.tap do |key|
+        key.append!(*)
+      end
+    end
+
+    INDEX_VALUE = /\A\d+\z/
+
+    def to_type!
+      path.map! do |part|
+        part.is_a?(Integer) ? :"#" : part
+      end
+    end
+
+    def to_type
+      dup.tap(&:to_type!)
+    end
+
+    def to_s
+      path.join(".")
+    end
+
+    def to_sym(...)
+      to_s(...).to_sym
+    end
+
+    def to_s_type
+      to_type.to_s
+    end
+
+    def values_at(object, parts = path)
+      _values_at([object], parts)
+    end
+
+    def value_at(object, parts = path)
+      values = values_at(object, parts)
+
+      if values.size > 1
+        raise TooManyValuesAtPathError.new(path, values)
+      end
+
+      values.first
+    end
+
+    def set_value_at(object, value, parts = path)
+      owner = value_at(object, parts[0..-2])
+      index = parts.last
+
+      if owner.is_a?(::Hash)
+        if owner.key?(index.to_s)
+          owner[index.to_s] = value
+        else
+          owner[index] = value
+        end
+      elsif owner.is_a?(::Array)
+        owner[index] = value
+      else
+        method = "#{index}="
+        if owner.respond_to?(method)
+          owner.send(method, value)
+        else
+          # :nocov:
+          raise BadPathError, "Bad path: #{parts}"
+          # :nocov:
+        end
+      end
+
+      value
+    end
+
+    # Helper method that determines if the path points to an array and none of the atoms along the way are also arrays.
+    # And that there's at least one atom (we are going to consider a collection to be "named" not an anonymous array.)
+    def simple_collection?
+      path.size > 1 && path.last == :"#" && path[0..-2].none? { |part| part == :"#" }
+    end
+
+    def ==(other)
+      self.class == other.class && path == other.path
+    end
+
+    private
+
+    def normalize_all(key_parts)
+      normalize(Util.array(key_parts))
+    end
+
+    def normalize(key_parts)
+      return nil if key_parts.nil?
+
+      case key_parts
+      when Array
+        key_parts.map do |key_part|
+          normalize(key_part)
+        end
+      when Symbol
+        normalize(key_parts.to_s)
+      when Integer
+        key_parts
+      when String
+        if key_parts.empty?
+          nil
+        elsif key_parts =~ INDEX_VALUE
+          key_parts.to_i
+        else
+          key_parts.to_sym
+        end
+      else
+        # :nocov:
+        raise ArgumentError,
+              "expected nil, a symbol, or a string, an integer, or an array of such values but was a #{key_parts.class}"
+        # :nocov:
+      end
+    end
+
+    def _values_at(objects, parts = path)
+      return objects if parts.empty?
+
+      path_part, *parts = parts
+
+      objects = case path_part
+                when :"#"
+                  objects.flatten.uniq
+                when Symbol
+                  objects.map do |object|
+                    if object.is_a?(::Hash)
+                      if object.key?(path_part.to_s)
+                        object[path_part.to_s]
+                      else
+                        object[path_part]
+                      end
+                    else
+                      object.send(path_part)
+                    end
+                  end
+                when Integer
+                  objects.map { |value| value[path_part] }
+                else
+                  # :nocov:
+                  raise "Bad path part: #{path_part.inspect}"
+                  # :nocov:
+                end.compact
+
+      _values_at(objects, parts)
+    end
+  end
+end

data/projects/common/src/error.rb

@@ -0,0 +1,215 @@
+module Foobara
+  class Error < StandardError
+    foobara_autoregister_subclasses(default_namespace: Foobara::GlobalDomain)
+
+    include Manifestable
+
+    # TODO: rename :path to data_path
+    attr_accessor :error_key, :message, :context, :is_fatal
+
+    # Need to do this early so doing it here... not sure if this is OK as it couples namespaces and errors
+
+    class << self
+      def abstract
+        @abstract = true
+      end
+
+      def abstract?
+        @abstract
+      end
+
+      def symbol
+        Util.non_full_name_underscore(self).gsub(/_error$/, "").to_sym
+      end
+
+      # Is this actually used?
+      def path
+        ErrorKey::EMPTY_PATH
+      end
+
+      def runtime_path
+        ErrorKey::EMPTY_PATH
+      end
+
+      def category
+        nil
+      end
+
+      def message
+        nil
+      end
+
+      def context
+        nil
+      end
+
+      def fatal?
+        false
+      end
+
+      def to_h
+        {
+          category:,
+          symbol:,
+          # TODO: this is a bad dependency direction but maybe time to bite the bullet and finally merge these...
+          context_type_declaration: context_type&.declaration_data,
+          is_fatal: fatal?
+        }
+      end
+
+      def foobara_manifest(to_include:)
+        types = types_depended_on.map do |t|
+          to_include << t
+          t.foobara_manifest_reference
+        end
+
+        base = nil
+        # don't bother including these core errors
+        unless superclass == Foobara::Error
+          base = superclass
+          to_include << base
+        end
+
+        manifest = super
+
+        unless types.empty?
+          manifest[:types_depended_on] = types.sort
+        end
+
+        h = manifest.merge(Util.remove_blank(to_h)).merge(
+          error_class: name
+        )
+
+        if base
+          h[:base_error] = base.foobara_manifest_reference
+        end
+
+        if abstract?
+          h[:abstract] = true
+        end
+
+        h
+      end
+
+      def subclass(
+        # TODO: technically context_type_declaration doesn't belong here. But maybe it should.
+        context_type_declaration:,
+        name: nil,
+        symbol: nil,
+        message: nil,
+        base_error: self,
+        category: base_error.category,
+        is_fatal: false,
+        abstract: false
+      )
+        name ||= "#{base_error.name}::#{Util.classify(symbol)}Error"
+
+        klass = Util.make_class_p(name, base_error) do
+          singleton_class.define_method :category do
+            category
+          end
+
+          if symbol
+            singleton_class.define_method :symbol do
+              symbol
+            end
+          end
+
+          singleton_class.define_method :fatal? do
+            is_fatal
+          end
+
+          singleton_class.define_method :context_type_declaration do
+            context_type_declaration
+          end
+
+          if message
+            singleton_class.define_method :message do
+              message
+            end
+          end
+        end
+
+        klass.abstract if abstract
+
+        klass
+      end
+    end
+
+    foobara_delegate :runtime_path,
+                     :runtime_path=,
+                     :category,
+                     :category=,
+                     :path,
+                     :path=,
+                     :symbol,
+                     :symbol=,
+                     to: :error_key
+
+    # TODO: seems like we should not allow the symbol to vary within instances of a class
+    # TODO: any items serializable in self.class.to_h should not be overrideable like this...
+    def initialize(
+      path: self.class.path,
+      runtime_path: self.class.runtime_path,
+      category: self.class.category,
+      message: self.class.message,
+      symbol: self.class.symbol,
+      context: self.class.context,
+      is_fatal: self.class.fatal?
+    )
+      self.error_key = ErrorKey.new
+
+      self.symbol = symbol
+      self.message = message
+      self.context = context
+      self.category = category
+      self.path = path
+      self.runtime_path = runtime_path
+      self.is_fatal = is_fatal
+
+      if !self.message.is_a?(String) || self.message.empty?
+        # :nocov:
+        raise "Bad error message, expected a string"
+        # :nocov:
+      end
+
+      super(message)
+    end
+
+    def fatal?
+      is_fatal
+    end
+
+    def key
+      error_key.to_s
+    end
+
+    def ==(other)
+      equal?(other) || eql?(other)
+    end
+
+    def eql?(other)
+      return false unless other.is_a?(Error)
+
+      symbol == other.symbol
+    end
+
+    def prepend_path!(...)
+      error_key.prepend_path!(...)
+      self
+    end
+
+    def to_h
+      {
+        key:,
+        path:,
+        runtime_path:,
+        category:,
+        symbol:,
+        message:,
+        context:,
+        is_fatal: fatal?
+      }
+    end
+  end
+end