foobara 0.0.1

data/projects/model/src/model.rb

@@ -0,0 +1,320 @@
+module Foobara
+  # TODO: either make this an abstract base class of ValueModel and Entity or rename it to ValueModel
+  # and have Entity inherit from it...
+  # TODO: also, why is this at the root level instead of in a project??
+  class Model
+    class NoSuchAttributeError < StandardError; end
+    class AttributeIsImmutableError < StandardError; end
+
+    include Concerns::Types
+    include Concerns::Reflection
+
+    class << self
+      attr_accessor :is_abstract
+
+      def description(*args)
+        case args.size
+        when 0
+          @description
+        when 1
+          @description = args.first
+        else
+          # :nocov:
+          raise ArgumentError, "expected 0 or 1 argument, got #{args.size}"
+          # :nocov:
+        end
+      end
+
+      def organization_name
+        domain.foobara_organization_name
+      end
+
+      def domain_name
+        domain.foobara_domain_name
+      end
+
+      # TODO: would be nice to make this a universal concept via a concern
+      def abstract
+        @is_abstract = true
+      end
+
+      def abstract?
+        @is_abstract
+      end
+
+      def closest_namespace_module
+        # TODO: Feels like we should use the autoset_namespace helpers here
+        mod = Util.module_for(self)
+
+        while mod
+          if mod.is_a?(Namespace::IsNamespace)
+            namespace = mod
+            break
+          end
+
+          mod = Util.module_for(mod)
+        end
+
+        if mod.nil? || mod == GlobalOrganization || mod == Foobara
+          GlobalDomain
+        else
+          namespace
+        end
+      end
+
+      def domain
+        if model_type
+          model_type.foobara_domain
+        else
+          mod = Util.module_for(self)
+
+          while mod
+            if mod.foobara_domain?
+              namespace = mod
+              break
+            end
+
+            mod = Util.module_for(mod)
+          end
+
+          if namespace&.foobara_domain?
+            namespace
+          else
+            GlobalDomain
+          end
+        end
+      end
+
+      def attribute_names
+        attributes_type.element_types.keys
+      end
+
+      def valid_attribute_name?(attribute_name)
+        attribute_names.include?(attribute_name.to_sym)
+      end
+
+      def validate_attribute_name!(attribute_name)
+        unless valid_attribute_name?(attribute_name)
+          raise NoSuchAttributeError, "No such attribute #{attribute_name} expected one of #{attribute_names}"
+        end
+      end
+
+      def model_name
+        model_type&.scoped_name || Util.non_full_name(self)
+      rescue Foobara::Scoped::NoScopedPathSetError
+        # :nocov:
+        Util.non_full_name(self)
+        # :nocov:
+      end
+
+      def full_model_name
+        model_type&.scoped_full_name
+      end
+
+      def possible_errors(mutable: true)
+        if mutable == true
+          attributes_type.possible_errors
+        elsif mutable
+          element_types = attributes_type.element_types
+
+          p = []
+
+          Util.array(mutable).each do |attribute_name|
+            attribute_name = attribute_name.to_sym
+
+            # TODO: this doesn't feel quite right... we should be excluding errors so that we don't
+            # miss any that are on attributes_type unrelated to the elements.
+            element_types[attribute_name].possible_errors.each do |possible_error|
+              possible_error = possible_error.dup
+              possible_error.prepend_path!(attribute_name)
+              p << possible_error
+            end
+          end
+
+          p
+        else
+          []
+        end
+      end
+
+      def allowed_subclass_opts
+        %i[name model_module]
+      end
+
+      def subclass(**opts)
+        invalid_opts = opts.keys - allowed_subclass_opts
+
+        unless invalid_opts.empty?
+          # :nocov:
+          raise ArgumentError, "Invalid opts #{invalid_opts} expected only #{allowed_subclass_opts}"
+          # :nocov:
+        end
+
+        model_name = opts[:name]
+
+        if model_name.is_a?(::Symbol)
+          model_name = model_name.to_s
+        end
+
+        # TODO: How are we going to set the domain and organization?
+        model_class = Class.new(self) do
+          singleton_class.define_method :model_name do
+            model_name
+          end
+        end
+
+        if opts.key?(:model_module)
+          model_module = opts[:model_module]
+
+          if model_name.include?("::")
+            model_module_name = "#{model_module.name}::#{model_name.split("::")[..-2].join("::")}"
+            model_module = Util.make_module_p(model_module_name, tag: true)
+          end
+
+          const_name = model_name.split("::").last
+
+          model_module.const_set(const_name, model_class)
+        end
+
+        model_class
+      end
+    end
+
+    attr_accessor :mutable
+
+    def initialize(attributes = nil, options = {})
+      allowed_options = %i[validate mutable]
+      invalid_options = options.keys - allowed_options
+
+      unless invalid_options.empty?
+        # :nocov:
+        raise ArgumentError, "Invalid options #{invalid_options} expected only #{allowed_options}"
+        # :nocov:
+      end
+
+      validate = options[:validate]
+
+      if attributes.nil?
+        if validate
+          # :nocov:
+          raise ArgumentError, "Cannot use validate option without attributes"
+          # :nocov:
+        end
+      else
+        self.mutable = true
+        attributes.each_pair do |attribute_name, value|
+          write_attribute(attribute_name, value)
+        end
+      end
+
+      mutable = options.key?(:mutable) ? options[:mutable] : true
+
+      self.mutable = if mutable.is_a?(::Array)
+                       mutable.map(&:to_sym)
+                     else
+                       mutable
+                     end
+
+      validate! if validate
+    end
+
+    foobara_delegate :model_name, :valid_attribute_name?, :validate_attribute_name!, to: :class
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def write_attribute(attribute_name, value)
+      attribute_name = attribute_name.to_sym
+
+      if mutable == true || mutable.include?(attribute_name)
+        outcome = cast_attribute(attribute_name, value)
+        attributes[attribute_name] = outcome.success? ? outcome.result : value
+      else
+        # :nocov:
+        raise AttributeIsImmutableError, "Cannot write attribute #{attribute_name} because it is not mutable"
+        # :nocov:
+      end
+    end
+
+    def write_attribute!(attribute_name, value)
+      attribute_name = attribute_name.to_sym
+      attributes[attribute_name] = cast_attribute!(attribute_name, value)
+    end
+
+    def write_attributes(attributes)
+      attributes.each_pair do |attribute_name, value|
+        write_attribute(attribute_name, value)
+      end
+    end
+
+    def write_attributes!(attributes)
+      attributes.each_pair do |attribute_name, value|
+        write_attribute!(attribute_name, value)
+      end
+    end
+
+    def read_attribute(attribute_name)
+      attributes[attribute_name.to_sym]
+    end
+
+    def read_attribute!(attribute_name)
+      validate_attribute_name!(attribute_name)
+      read_attribute(attribute_name)
+    end
+
+    def cast_attribute(attribute_name, value)
+      attribute_type = attributes_type.element_types[attribute_name]
+
+      return Outcome.success(value) unless attribute_type
+
+      attribute_type.process_value(value).tap do |outcome|
+        unless outcome.success?
+          outcome.errors.each do |error|
+            error.prepend_path!(attribute_name)
+          end
+        end
+      end
+    end
+
+    def cast_attribute!(attribute_name, value)
+      validate_attribute_name!(attribute_name)
+
+      outcome = cast_attribute(attribute_name, value)
+      outcome.raise!
+      outcome.result
+    end
+
+    def valid?
+      attributes_type.process_value(attributes).success?
+    end
+
+    def validation_errors
+      attributes_type.process_value(attributes).errors
+    end
+
+    def validate!
+      attributes_type.process_value!(attributes)
+    end
+
+    def ==(other)
+      self.class == other.class && attributes == other.attributes
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      attributes.hash
+    end
+
+    def to_h
+      attributes
+    end
+
+    def to_json(*_args)
+      to_h.to_json
+    end
+  end
+end

data/projects/monorepo/lib/foobara/monorepo/project.rb

@@ -0,0 +1,52 @@
+module Foobara
+  module Monorepo
+    # TODO: make this MonorepoProject and have a more generic Project so that other projects outside of the
+    # repo can have things like reset_all called on th.
+    class Project
+      attr_accessor :symbol
+
+      def initialize(symbol)
+        self.symbol = symbol
+      end
+
+      def project_path
+        "projects/#{symbol}"
+      end
+
+      def require_path
+        "foobara/#{symbol}"
+      end
+
+      def module_name
+        Util.classify(symbol)
+      end
+
+      def module
+        Foobara.const_get(module_name)
+      end
+
+      def load
+        require require_path
+        Util.require_directory("#{__dir__}/../../../../../#{project_path}/src")
+      end
+
+      def install!
+        if self.module.respond_to?(:install!)
+          self.module.install!
+        end
+      end
+
+      def reset_all
+        if self.module.respond_to?(:reset_all)
+          self.module.reset_all
+        end
+      end
+
+      def new_project_added(project)
+        if self.module.respond_to?(:new_project_added)
+          self.module.new_project_added(project)
+        end
+      end
+    end
+  end
+end

data/projects/monorepo/lib/foobara/monorepo.rb

@@ -0,0 +1,63 @@
+require_relative "monorepo/project"
+
+module Foobara
+  class << self
+    def require_project_file(project, path)
+      require_relative("../../../#{project}/src/#{path}")
+    end
+
+    def reset_alls
+      Monorepo.reset_alls
+    end
+  end
+
+  # TODO: We should rename this to Projects or something else because we need to manage this stuff for projects
+  # inside and outside of the monorepo.
+  module Monorepo
+    class << self
+      attr_accessor :is_installed
+
+      def all_projects
+        @all_projects ||= {}
+      end
+
+      def projects(*symbols)
+        symbols.each do |symbol|
+          project(symbol)
+        end
+      end
+
+      def project(symbol)
+        if all_projects.key?(symbol)
+          # :nocov:
+          raise ArgumentError, "Project #{symbol} already loaded"
+          # :nocov:
+        end
+
+        project = Project.new(symbol)
+        project.load
+
+        all_projects[symbol] = project
+
+        if is_installed
+          project.install!
+
+          all_projects.each_pair do |key, existing_project|
+            next if key == symbol
+
+            existing_project.new_project_added(project)
+          end
+        end
+      end
+
+      def install!
+        self.is_installed = true
+        all_projects.each_value(&:install!)
+      end
+
+      def reset_alls
+        all_projects.each_value(&:reset_all)
+      end
+    end
+  end
+end

data/projects/namespace/lib/foobara/namespace.rb

@@ -0,0 +1,4 @@
+module Foobara
+  class Namespace
+  end
+end

data/projects/namespace/src/ambiguous_registry.rb

@@ -0,0 +1,104 @@
+module Foobara
+  class Namespace
+    class AmbiguousRegistry < BaseRegistry
+      def registry
+        @registry ||= {}
+      end
+
+      def register(scoped)
+        short_name = scoped.scoped_short_name
+        registry[short_name] ||= []
+        registry[short_name] |= [scoped]
+      end
+
+      def unregister(scoped)
+        short_name = scoped.scoped_short_name
+        entry = registry[short_name]
+
+        unless entry
+          # :nocov:
+          raise NotRegisteredError, "Not registered: #{short_name.inspect}"
+          # :nocov:
+        end
+
+        registered = lookup([short_name])
+
+        unless registered
+          # :nocov:
+          raise NotRegisteredError, "Not registered: #{short_name.inspect}"
+          # :nocov:
+        end
+
+        unless entry.delete(registered)
+          # :nocov:
+          raise NotRegisteredError, "Not registered: #{short_name.inspect}"
+          # :nocov:
+        end
+      end
+
+      def lookup(path, filter = nil)
+        *prefix, short_name = path
+        matches = apply_filter(registry[short_name], filter)
+
+        if matches && !matches.empty?
+          _best_match(prefix, matches, path)
+        end
+      end
+
+      def each_scoped_without_filter(&)
+        registry.each_value do |scoped_objects|
+          scoped_objects.each(&)
+        end
+      end
+
+      private
+
+      def _best_match(prefix, matches, path)
+        candidates = nil
+        candidate_hits = -1
+        candidate_misses = 1
+
+        matches.each do |match|
+          hits, misses = _score(prefix, match)
+
+          if hits
+            if hits == candidate_hits
+              if misses == candidate_misses
+                candidates << match
+              elsif misses > candidate_misses
+                candidates = [match]
+                candidate_misses = misses
+                candidate_hits = hits
+              end
+            elsif hits > candidate_hits
+              candidates = [match]
+              candidate_misses = misses
+              candidate_hits = hits
+            end
+          end
+        end
+
+        if candidates
+          if candidates.size > 1
+            raise AmbiguousLookupError,
+                  "Ambiguous match for #{path.inspect}. Matches the following: #{candidates.inspect}"
+          end
+
+          candidates.first
+        end
+      end
+
+      def _score(prefix, match)
+        prefix_path = Util.array(match.scoped_prefix)
+        matching_parts = prefix_path & prefix
+
+        if matching_parts == prefix
+          hits = matching_parts.size
+          misses = hits - prefix_path.size
+
+          [hits, misses]
+        end
+      end
+    end
+  end
+end

data/projects/namespace/src/base_registry.rb

@@ -0,0 +1,66 @@
+module Foobara
+  class Namespace
+    class AmbiguousLookupError < StandardError; end
+
+    class BaseRegistry
+      class WouldMakeRegistryAmbiguousError < StandardError; end
+      class NotRegisteredError < StandardError; end
+
+      def register(_scoped)
+        # :nocov:
+        raise "Subclass responsibility"
+        # :nocov:
+      end
+
+      def registered?(path)
+        !lookup(path).nil?
+      end
+
+      def unregister(_scoped)
+        # :nocov:
+        raise "Subclass responsibility"
+        # :nocov:
+      end
+
+      def lookup(_path, filter: nil)
+        # :nocov:
+        raise "Subclass responsibility"
+        # :nocov:
+      end
+
+      # TODO: should return an enumerator
+      def each_scoped(filter: nil, &block)
+        each_scoped_without_filter do |scoped|
+          scoped = apply_filter(scoped, filter) if filter
+          block.call(scoped) if scoped
+        end
+      end
+
+      def all_scoped(filter: nil)
+        all = []
+        each_scoped(filter:) do |scoped|
+          all << scoped
+        end
+        all
+      end
+
+      def each_scoped_without_filter(&)
+        # :nocov:
+        raise "Subclass responsibility"
+        # :nocov:
+      end
+
+      def apply_filter(object, filter)
+        if filter
+          if object.is_a?(::Array)
+            object.select { |o| o.instance_eval(&filter) }
+          elsif object&.instance_eval(&filter)
+            object
+          end
+        else
+          object
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+require_relative "../namespace_helpers"
+
+class Module
+  include Foobara::Namespace::NamespaceHelpers
+end