foobara 0.0.1

data/projects/common/src/error_collection.rb

@@ -0,0 +1,97 @@
+module Foobara
+  # TODO: inherit array instead of delegating
+  class ErrorCollection
+    class ErrorAlreadySetError < StandardError; end
+
+    class << self
+      def to_h(errors)
+        new.tap do |collection|
+          collection.add_errors(errors)
+        end.to_h
+      end
+    end
+
+    attr_reader :error_array
+
+    def initialize
+      @error_array = []
+    end
+
+    def success?
+      empty?
+    end
+
+    def has_errors?
+      !empty?
+    end
+
+    foobara_delegate :empty?, :partition, :size, to: :error_array
+
+    def errors
+      error_array
+    end
+
+    def each_error(&)
+      error_array.each(&)
+    end
+
+    def has_error?(error)
+      unless error.is_a?(Error)
+        # :nocov:
+        raise ArgumentError, "Can only check if an Error instance is in the collection"
+        # :nocov:
+      end
+
+      error_array.include?(error)
+    end
+
+    def add_error(error_or_collection_or_error_hash)
+      error = case error_or_collection_or_error_hash
+              when Error
+                error_or_collection_or_error_hash
+              when ErrorCollection
+                return add_errors(error_or_collection_or_error_hash.errors)
+              when Hash
+                if error_or_collection_or_error_hash.key?(:symbol) &&
+                   error_or_collection_or_error_hash.key?(:message)
+                  Error.new(**error_or_collection_or_error_hash)
+                else
+                  # :nocov:
+                  raise ArgumentError,
+                        "if passing a hash of error args it must include symbol and message at least"
+                  # :nocov:
+                end
+              else
+                # :nocov:
+                raise ArgumentError, "Not sure how to convert #{args.inspect} into an error. " \
+                                     "Can handle a hash of error " \
+                                     "args or 3 arguments for symbol, message, and context, or, of course, an Error"
+                # :nocov:
+              end
+
+      if has_error?(error)
+        raise ErrorAlreadySetError, "cannot set #{error} more than once"
+      end
+
+      error_array << error
+    end
+
+    def add_errors(errors)
+      Util.array(errors).each { |error| add_error(error) }
+    end
+
+    def to_h
+      error_array.to_h do |error|
+        [error.key, error.to_h]
+      end
+    end
+
+    def to_sentence
+      Util.to_sentence(error_array.map(&:message))
+    end
+
+    def keys
+      error_array.map(&:key)
+    end
+  end
+end

data/projects/common/src/error_key.rb

@@ -0,0 +1,168 @@
+module Foobara
+  # TODO: path's have use outside of errors. Make this more general.
+  class ErrorKey
+    # TODO: use this wherever it makes sense
+    EMPTY_PATH = [].freeze
+
+    class << self
+      def to_s_type(key)
+        unless key.is_a?(ErrorKey)
+          key = parse(key)
+        end
+
+        key.to_s_type
+      end
+
+      def prepend_path(key, *)
+        if key.is_a?(ErrorKey)
+          key.prepend_path(*).to_s
+        else
+          key = parse(key)
+          key.prepend_path!(*).to_s
+        end
+      end
+
+      def prepend_runtime_path(key, prepend_part)
+        if key.is_a?(ErrorKey)
+          key.prepend_runtime_path(prepend_part).to_s
+        else
+          key = parse(key)
+          key.prepend_runtime_path!(prepend_part).to_s
+        end
+      end
+
+      # key contains.......
+      # a;b;c;d.e.f.g.h
+      # Then a, b, c is the runtime path and d is the category and e,f,g is the data path and h is the symbol
+      def parse(key_string)
+        *runtime_path, key_string = key_string.to_s.split(">")
+        category, *path, symbol = key_string.split(".")
+
+        new(category:, path:, symbol:, runtime_path:)
+      end
+
+      def to_h(key_string)
+        parse(key_string).to_h
+      end
+    end
+
+    attr_reader :category, :symbol, :path, :runtime_path
+
+    # TODO: accept error_class instead of symbol/category??
+    def initialize(symbol: nil, category: nil, path: EMPTY_PATH, runtime_path: EMPTY_PATH)
+      self.category = symbolize(category)
+      self.symbol = symbolize(symbol)
+      self.path = symbolize(path)
+      self.runtime_path = symbolize(runtime_path)
+    end
+
+    def symbol=(symbol)
+      @symbol = symbolize(symbol)
+    end
+
+    def category=(category)
+      @category = symbolize(category)
+    end
+
+    def path=(path)
+      @path = symbolize_all(path)
+    end
+
+    def runtime_path=(runtime_path)
+      @runtime_path = symbolize_all(runtime_path)
+    end
+
+    def prepend_path!(*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_path(*)
+      dup.tap do |key|
+        key.prepend_path!(*)
+      end
+    end
+
+    def prepend_runtime_path!(prepend_parts)
+      self.runtime_path = [*prepend_parts, *runtime_path]
+      self
+    end
+
+    def prepend_runtime_path(prepend_parts)
+      dup.tap do |key|
+        key.runtime_path = [*prepend_parts, *runtime_path]
+      end
+    end
+
+    INDEX_VALUE = /\A\d+\z/
+
+    def to_s(convert_to_type: false)
+      path = self.path
+
+      if convert_to_type
+        path = path.map do |path_part|
+          path_part =~ INDEX_VALUE ? :"#" : path_part
+        end
+      end
+
+      [
+        *runtime_path,
+        [category, *path, symbol].join(".")
+      ].join(">")
+    end
+
+    def to_sym(**)
+      to_s(**).to_sym
+    end
+
+    def to_s_type
+      to_s(convert_to_type: true)
+    end
+
+    def to_h
+      {
+        path:,
+        runtime_path:,
+        category:,
+        symbol:
+      }
+    end
+
+    private
+
+    def symbolize_all(key_parts)
+      symbolize(Util.array(key_parts))
+    end
+
+    def symbolize(key_parts)
+      return nil if key_parts.nil?
+
+      case key_parts
+      when Array
+        key_parts.map do |key_part|
+          symbolize(key_part)
+        end
+      when Symbol, Integer
+        key_parts
+      when String
+        if key_parts.empty?
+          nil
+        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 "
+        # :nocov:
+      end
+    end
+  end
+end

data/projects/common/src/outcome.rb

@@ -0,0 +1,101 @@
+module Foobara
+  class Outcome
+    class UnsuccessfulOutcomeError < StandardError
+      attr_accessor :errors
+
+      def initialize(errors)
+        self.errors = errors
+
+        message = errors.map(&:message).join(", ")
+
+        super(message)
+      end
+    end
+
+    class << self
+      def success(result)
+        new.tap do |outcome|
+          outcome.result = result
+        end
+      end
+
+      def errors(*errors)
+        errors = errors.flatten
+
+        if errors.empty?
+          # :nocov:
+          raise "No errors given"
+          # :nocov:
+        end
+
+        new.tap do |outcome|
+          outcome.add_errors(errors)
+        end
+      end
+
+      def error(error)
+        errors(Util.array(error))
+      end
+
+      def raise!(errors)
+        self.errors(errors).raise! unless errors.empty?
+      end
+    end
+
+    attr_accessor :result
+    attr_reader :error_collection
+
+    def initialize(result: nil, errors: nil, error_collection: ErrorCollection.new)
+      @error_collection = error_collection
+
+      self.result = result
+
+      if errors
+        add_errors(errors)
+      end
+    end
+
+    foobara_delegate :has_errors?,
+                     :errors,
+                     :each_error,
+                     :has_error?,
+                     :add_error,
+                     :add_errors,
+                     to: :error_collection
+
+    def success?
+      !has_errors?
+    end
+
+    def fatal?
+      errors.any?(&:fatal?)
+    end
+
+    def raise!
+      return if success?
+
+      if errors.size == 1
+        raise errors.first
+      else
+        raise UnsuccessfulOutcomeError, errors
+      end
+    end
+
+    def result!
+      raise!
+      result
+    end
+
+    def errors_hash
+      error_collection.to_h
+    end
+
+    def errors_sentence
+      error_collection.to_sentence
+    end
+
+    def error_keys
+      error_collection.keys
+    end
+  end
+end

data/projects/common/src/possible_error.rb

@@ -0,0 +1,80 @@
+module Foobara
+  class PossibleError
+    attr_accessor :key, :error_class, :data, :processor, :manually_added
+
+    # why can't we set path here?
+    def initialize(
+      error_class,
+      key: nil,
+      data: nil,
+      symbol: error_class.symbol,
+      category: error_class.category,
+      processor: nil
+    )
+      self.error_class = error_class
+      self.processor = processor
+      self.data = if data
+                    data
+                  elsif processor
+                    { processor.symbol => processor.declaration_data }
+                  end
+      self.key = if key
+                   if key.is_a?(ErrorKey)
+                     key
+                   else
+                     ErrorKey.parse(key)
+                   end
+                 else
+                   ErrorKey.new(symbol:, category:)
+                 end
+    end
+
+    def dup
+      PossibleError.new(
+        error_class,
+        key: key.dup,
+        data:
+      )
+    end
+
+    def prepend_path!(...)
+      key.prepend_path!(...)
+    end
+
+    def prepend_runtime_path!(...)
+      key.prepend_runtime_path!(...)
+    end
+
+    # TODO: technically does not belong in this project but maybe it should
+    def foobara_manifest(to_include:)
+      to_include << error_class
+
+      if processor
+        processor_class = processor.class
+        to_include << processor_class
+
+        if processor.scoped_path_set?
+          # Unclear why nothing in the test suite passes through here.
+          # TODO: either test this or delete it.
+          # :nocov:
+          to_include << processor
+          processor_reference = processor.foobara_manifest_reference
+          # :nocov:
+        end
+      end
+
+      processor_manifest_data = data unless processor_reference
+
+      Util.remove_blank(
+        key.to_h.merge(
+          key: key.to_s,
+          error: error_class.foobara_manifest_reference,
+          processor: processor_reference,
+          processor_class: processor_class&.foobara_manifest_reference,
+          processor_manifest_data:,
+          manually_added:
+        )
+      )
+    end
+  end
+end

data/projects/common/src/runtime_error.rb

@@ -0,0 +1,24 @@
+Foobara.require_project_file("common", "error")
+
+module Foobara
+  # NOTE: annoyingly this will clash with ::RuntimeError if not fully qualified when using
+  class RuntimeError < Error
+    abstract
+
+    class << self
+      def category
+        :runtime
+      end
+
+      def fatal?
+        true
+      end
+    end
+
+    # TODO: why path instead of runtime path?
+    def initialize(message: nil, symbol: nil, context: nil, path: nil)
+      args = { message:, symbol:, context:, path: }.compact
+      super(**args.merge(category: self.class.category))
+    end
+  end
+end

data/projects/concerns/lib/foobara/concerns.rb

@@ -0,0 +1 @@
+module Foobara::Concerns; end

data/projects/concerns/src/concern.rb

@@ -0,0 +1,93 @@
+module Foobara
+  module Concern
+    # TODO: there seems to be a bug when extending classes. They do not get inheritance for free with
+    # this module as would be expected.
+    module IsConcern
+      def included(klass)
+        # If behavior is defined in Concern A and then included into Concern B, we need to make sure
+        # that when B is included it's also as if A were included.
+        # ClassMethods on A should exist on any object's class that included B.
+        # Any code-snippets to be ran when A is included should also be ran if B is included.
+        if Concern.foobara_concern?(klass)
+          if const_defined?(:ClassMethods, false)
+            Concern.foobara_class_methods_module_for(klass).include(const_get(:ClassMethods, false))
+          end
+        else
+          if const_defined?(:ClassMethods, false)
+            klass.extend(const_get(:ClassMethods, false))
+          end
+
+          ancestors.select { |mod| Concern.foobara_concern?(mod) }.reverse.each do |concern|
+            concern.instance_variable_get("@inherited_overridable_class_attr_accessors")&.each do |name|
+              var_name = "@#{name}"
+              klass.instance_variable_set(var_name, klass.instance_variable_get(var_name))
+            end
+
+            if concern.has_foobara_on_include_block?
+              klass.class_eval(&concern.foobara_on_include_block)
+            end
+          end
+        end
+
+        super
+      end
+
+      def has_foobara_on_include_block?
+        !!@foobara_on_include
+      end
+
+      def foobara_on_include_block
+        @foobara_on_include
+      end
+
+      def on_include(&block)
+        @foobara_on_include = block
+      end
+
+      def inherited_overridable_class_attr_accessor(*names)
+        @inherited_overridable_class_attr_accessors ||= []
+        @inherited_overridable_class_attr_accessors += names
+
+        Concern.foobara_class_methods_module_for(self).module_eval do
+          names.each do |name|
+            var_name = "@#{name}"
+
+            define_method name do
+              if instance_variable_defined?(var_name)
+                instance_variable_get(var_name)
+              else
+                superclass.send(name)
+              end
+            end
+
+            attr_writer name
+          end
+        end
+      end
+    end
+
+    class << self
+      def included(concern)
+        concern.extend(IsConcern)
+      end
+
+      def foobara_concern?(mod)
+        mod.singleton_class < IsConcern
+      end
+
+      def foobara_class_methods_module_for(klass)
+        unless klass.name
+          # :nocov:
+          raise "This does not work with anonymous classes"
+          # :nocov:
+        end
+
+        if klass.const_defined?(:ClassMethods, false)
+          klass.const_get(:ClassMethods, false)
+        else
+          Util.make_module "#{klass.name}::ClassMethods"
+        end
+      end
+    end
+  end
+end

data/projects/delegate/lib/foobara/delegate.rb

@@ -0,0 +1 @@
+module Foobara::Delegate; end

data/projects/delegate/src/extensions/module.rb

@@ -0,0 +1,12 @@
+class Module
+  def foobara_delegate(*method_names, to:, allow_nil: false)
+    method_names.each do |method_name|
+      define_method method_name do |*args, **opts, &block|
+        target = to.is_a?(::Symbol) || to.is_a?(::String) ? send(to) : to
+        return nil if target.nil? && allow_nil
+
+        target.send(method_name, *args, **opts, &block)
+      end
+    end
+  end
+end

data/projects/domain/lib/foobara/domain.rb

@@ -0,0 +1,25 @@
+module Foobara
+  module Domain
+    class << self
+      def install!
+        if @installed
+          # :nocov:
+          raise "Already registered Domain"
+          # :nocov:
+        end
+
+        # TODO: delete this?
+        @installed = true
+
+        Namespace.global.foobara_add_category(:organization) { is_a?(Module) && foobara_organization? }
+        Namespace.global.foobara_add_category(:domain) { is_a?(Module) && foobara_domain? }
+      end
+
+      def reset_all
+        if Foobara::DomainMapper.instance_variable_defined?(:@foobara_domain_mappers_to_process)
+          Foobara::DomainMapper.remove_instance_variable(:@foobara_domain_mappers_to_process)
+        end
+      end
+    end
+  end
+end

data/projects/domain/src/domain.rb

@@ -0,0 +1,65 @@
+module Foobara
+  module Domain
+    class DomainAlreadyExistsError < StandardError; end
+
+    class << self
+      def to_domain(object)
+        case object
+        when nil
+          global
+        when ::String, ::Symbol
+          domain = Namespace.global.foobara_lookup_domain(object)
+
+          unless domain
+            # :nocov:
+            raise NoSuchDomain, "Couldn't determine domain for #{object}"
+            # :nocov:
+          end
+
+          domain
+        when Foobara::Scoped
+          if object.is_a?(Module) && object.foobara_domain?
+            object
+          else
+            parent = object.scoped_namespace
+
+            if parent
+              to_domain(parent)
+            else
+              GlobalDomain
+            end
+          end
+        else
+          # :nocov:
+          raise NoSuchDomain, "Couldn't determine domain for #{object}"
+          # :nocov:
+        end
+      end
+
+      def create(full_domain_name)
+        if Domain.to_domain(full_domain_name)
+          raise DomainAlreadyExistsError, "Domain #{full_domain_name} already exists"
+        end
+      rescue Domain::NoSuchDomain
+        begin
+          Util.make_module(full_domain_name) { foobara_domain! }
+        rescue Util::ParentModuleDoesNotExistError => e
+          # TODO: this doesn't feel like the right logic... how do we know this isn't a prefix instead of an
+          # organization?
+          Util.make_module(e.parent_name) { foobara_organization! }
+          Util.make_module(full_domain_name) { foobara_domain! }
+        end
+      end
+
+      def foobara_type_from_declaration(scoped, type_declaration)
+        domain = to_domain(scoped)
+
+        domain.foobara_type_from_declaration(type_declaration)
+      end
+
+      def current
+        to_domain(Namespace.current)
+      end
+    end
+  end
+end