foobara 0.3.0 → 0.4.1

data/projects/manifest/spec/type_declaration_spec.rb

@@ -0,0 +1,39 @@
+RSpec.describe Foobara::Manifest do
+  after do
+    Foobara.reset_alls
+  end
+
+  let(:model_class) do
+    stub_class("SomeModel", Foobara::Model) do
+      attributes do
+        foo :string
+      end
+    end
+  end
+
+  let(:command_class) do
+    stub_class("SomeCommand", Foobara::Command) do
+      inputs do
+        some_model SomeModel, :allow_nil
+      end
+    end
+  end
+
+  let(:root_manifest) { Foobara::Manifest::RootManifest.new(raw_manifest) }
+  let(:raw_manifest) do
+    model_class
+    command_class
+    Foobara.manifest
+  end
+
+  describe "#to_model" do
+    context "when an allow_nil type declaration of a model" do
+      let(:type_declaration) { Foobara::Manifest::TypeDeclaration.new(root_manifest, path) }
+      let(:path) { [:command, "SomeCommand", :inputs_type, :element_type_declarations, :some_model] }
+
+      it "can still cast it to a model from a type_declaration" do
+        expect(type_declaration.to_model).to be_a(Foobara::Manifest::Model)
+      end
+    end
+  end
+end

data/projects/manifest/src/{foobara/manifest/array.rb → array.rb}

@@ -6,7 +6,7 @@ module Foobara
       alias array_manifest relevant_manifest
 
       def element_type
-        @element_type ||= TypeDeclaration.new(root_manifest, [*path, :element_type_declaration])
+        @element_type ||= TypeDeclaration.new(root_manifest, [*manifest_path, :element_type_declaration])
       end
     end
   end

data/projects/manifest/src/{foobara/manifest/attributes.rb → attributes.rb}

@@ -27,7 +27,7 @@ module Foobara
         element_type_declarations.keys.to_h do |attribute_name|
           [
             attribute_name.to_sym,
-            TypeDeclaration.new(root_manifest, [*path, :element_type_declarations, attribute_name])
+            TypeDeclaration.new(root_manifest, [*manifest_path, :element_type_declarations, attribute_name])
           ]
         end
       end

data/projects/manifest/src/{foobara/manifest/base_manifest.rb → base_manifest.rb}

@@ -5,7 +5,7 @@ module Foobara
     class BaseManifest
       include TruncatedInspect
 
-      attr_accessor :root_manifest, :path
+      attr_accessor :root_manifest, :manifest_path
 
       class << self
         attr_accessor :category_symbol
@@ -25,6 +25,7 @@ module Foobara
             values.each do |value|
               value = value.to_sym
               optional_keys << value
+
               if default
                 optional_key_defaults[value] = default
               end
@@ -49,17 +50,24 @@ module Foobara
         end
       end
 
-      def initialize(root_manifest, path)
+      def initialize(root_manifest, manifest_path)
         self.root_manifest = root_manifest
-        self.path = path
+        self.manifest_path = manifest_path
 
         if relevant_manifest.nil?
           # :nocov:
-          raise InvalidPath, "invalid path #{path}"
+          raise InvalidPath, "invalid path #{manifest_path}"
           # :nocov:
         end
       end
 
+      def path
+        # :nocov:
+        warn "[DEPRECATION] `path` is deprecated. Please use `manifest_path` instead."
+        manifest_path
+        # :nocov:
+      end
+
       def domain
         domain_reference = self[:domain]
 
@@ -93,7 +101,7 @@ module Foobara
       end
 
       def relevant_manifest
-        @relevant_manifest ||= Foobara::DataPath.values_at(path, root_manifest).first
+        @relevant_manifest ||= Foobara::DataPath.values_at(manifest_path, root_manifest).first
       end
 
       def find_type(type_declaration)
@@ -154,7 +162,7 @@ module Foobara
       end
 
       def symbol_path
-        @symbol_path ||= path.map(&:to_sym)
+        @symbol_path ||= manifest_path.map(&:to_sym)
       end
 
       def hash

data/projects/manifest/src/{foobara/manifest/command.rb → command.rb}

@@ -22,18 +22,18 @@ module Foobara
       end
 
       def inputs_type
-        Attributes.new(root_manifest, [*path, :inputs_type])
+        Attributes.new(root_manifest, [*manifest_path, :inputs_type])
       end
 
       def result_type
-        TypeDeclaration.new(root_manifest, [*path, :result_type])
+        TypeDeclaration.new(root_manifest, [*manifest_path, :result_type])
       rescue Foobara::Manifest::InvalidPath
         nil
       end
 
       def possible_errors
         (super || {}).keys.to_h do |key|
-          [key, PossibleError.new(root_manifest, [*path, :possible_errors, key])]
+          [key, PossibleError.new(root_manifest, [*manifest_path, :possible_errors, key])]
         end
       end
 

data/projects/manifest/src/{foobara/manifest/detached_entity.rb → detached_entity.rb}

@@ -15,7 +15,7 @@ module Foobara
       end
 
       def primary_key_type
-        @primary_key_type ||= TypeDeclaration.new(root_manifest, [*path, :primary_key_type])
+        @primary_key_type ||= TypeDeclaration.new(root_manifest, [*manifest_path, :primary_key_type])
       end
 
       def attribute_names

data/projects/manifest/src/{foobara/manifest/model.rb → model.rb}

@@ -8,7 +8,7 @@ module Foobara
       alias model_manifest relevant_manifest
 
       def attributes_type
-        Attributes.new(root_manifest, [*path, :attributes_type])
+        Attributes.new(root_manifest, [*manifest_path, :declaration_data, :attributes_declaration])
       end
 
       def attribute_names

data/projects/manifest/src/{foobara/manifest/possible_error.rb → possible_error.rb}

@@ -20,6 +20,8 @@ module Foobara
       end
 
       # oops, shadowed the convenience method
+      # TODO: come up with a name other than _path since this isn't private.
+      # ideally we could just call this path and rename the convenience method.
       def _path
         method_missing(:path)
       end

data/projects/manifest/src/{foobara/manifest/type.rb → type.rb}

@@ -10,11 +10,11 @@ module Foobara
 
           if self == Type
             if type.entity?
-              type = Entity.new(type.root_manifest, type.path)
+              type = Entity.new(type.root_manifest, type.manifest_path)
             elsif type.detached_entity?
-              type = DetachedEntity.new(type.root_manifest, type.path)
+              type = DetachedEntity.new(type.root_manifest, type.manifest_path)
             elsif type.model?
-              type = Model.new(type.root_manifest, type.path)
+              type = Model.new(type.root_manifest, type.manifest_path)
             end
           end
 
@@ -105,7 +105,7 @@ module Foobara
       end
 
       def to_type_declaration_from_declaration_data
-        TypeDeclaration.new(root_manifest, [*path, :declaration_data])
+        TypeDeclaration.new(root_manifest, [*manifest_path, :declaration_data])
       end
     end
   end

data/projects/manifest/src/{foobara/manifest/type_declaration.rb → type_declaration.rb}

@@ -12,9 +12,9 @@ module Foobara
           if self == TypeDeclaration
             case type_declaration.type.to_sym
             when :attributes
-              Attributes.new(type_declaration.root_manifest, type_declaration.path)
+              Attributes.new(type_declaration.root_manifest, type_declaration.manifest_path)
             when :array
-              Array.new(type_declaration.root_manifest, type_declaration.path)
+              Array.new(type_declaration.root_manifest, type_declaration.manifest_path)
             else
               type_declaration
             end
@@ -37,7 +37,7 @@ module Foobara
       def attribute?
         return @is_attribute if defined?(@is_attribute)
 
-        parent_path_atom = path[2..][-2]
+        parent_path_atom = manifest_path[2..][-2]
         @is_attribute = [:element_type_declarations, "element_type_declarations"].include?(parent_path_atom)
       end
       # rubocop:enable Naming/MemoizedInstanceVariableName
@@ -47,7 +47,7 @@ module Foobara
 
         raise "Not an attribute" unless attribute?
 
-        @parent_attributes = Attributes.new(root_manifest, path[0..-3])
+        @parent_attributes = Attributes.new(root_manifest, manifest_path[0..-3])
       end
 
       def attribute_name
@@ -55,7 +55,7 @@ module Foobara
 
         raise "Not an attribute" unless attribute?
 
-        @attribute_name = path[-1]
+        @attribute_name = manifest_path[-1]
       end
 
       def required?

data/projects/model_plumbing/lib/foobara/model_plumbing.rb

@@ -0,0 +1,13 @@
+module Foobara
+  module ModelPlumbing
+    class << self
+      def install!
+        Model.on_reregister do
+          GlobalDomain.foobara_each_command(&:handle_reregistered_types!)
+        end
+      end
+    end
+  end
+end
+
+Foobara.project("model_plumbing", project_path: "#{__dir__}/../..")

data/projects/{namespace/lib/foobara/namespace.rb → model_plumbing/src/model_plumbing.rb}

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

data/projects/{builtin_types → typesystem/projects/builtin_types}/lib/foobara/builtin_types.rb

@@ -1,3 +1,5 @@
+require "foobara/type_declarations"
+
 require "date"
 require "time"
 require "bigdecimal"
@@ -82,3 +84,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("builtin_types", project_path: "#{__dir__}/../..")

data/projects/{builtin_types → typesystem/projects/builtin_types}/src/builtin_types.rb

@@ -25,7 +25,7 @@ module Foobara
         casters_module = Util.constant_value(builtin_type_module, :Casters)
         caster_classes = if casters_module
                            Util.constant_values(casters_module, extends: Value::Processor)
-                         end
+                         end&.sort_by(&:name)
         casters = []
         caster_classes&.each do |caster_class|
           if caster_class.respond_to?(:requires_type?) && caster_class.requires_type?

data/projects/typesystem/projects/callback/lib/foobara/callback.rb

@@ -0,0 +1,3 @@
+module Foobara::Callback; end
+
+Foobara.project("callback", project_path: "#{__dir__}/../..")

data/projects/{callback → typesystem/projects/callback}/src/block/concerns/type.rb

@@ -1,3 +1,5 @@
+require "foobara/concerns"
+
 module Foobara
   module Callback
     class Block

data/projects/{callback → typesystem/projects/callback}/src/set.rb

@@ -11,7 +11,9 @@ module Foobara
         end
       end
 
-      foobara_delegate :size, to: :callbacks
+      def size
+        callbacks.size
+      end
 
       def union(set)
         unioned = Set.new(callbacks)

data/projects/{common → typesystem/projects/common}/lib/foobara/common.rb

@@ -9,3 +9,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("common", project_path: "#{__dir__}/../..")

data/projects/{common → typesystem/projects/common}/src/data_path.rb

@@ -5,7 +5,7 @@ module Foobara
     class BadPathError < StandardError; end
 
     # TODO: use this wherever it makes sense
-    EMPTY_PATH = [].freeze
+    EMPTY_PATH = EMPTY_ARRAY
 
     class TooManyValuesAtPathError < StandardError
       attr_accessor :path, :values

data/projects/{common → typesystem/projects/common}/src/error.rb

@@ -1,3 +1,5 @@
+require "foobara/domain"
+
 module Foobara
   class Error < StandardError
     foobara_autoregister_subclasses(default_namespace: Foobara::GlobalDomain)
@@ -188,15 +190,37 @@ module Foobara
       end
     end
 
-    foobara_delegate :runtime_path,
-                     :runtime_path=,
-                     :category,
-                     :category=,
-                     :path,
-                     :path=,
-                     :symbol,
-                     :symbol=,
-                     to: :error_key
+    def runtime_path
+      error_key.runtime_path
+    end
+
+    def runtime_path=(runtime_path)
+      error_key.runtime_path = runtime_path
+    end
+
+    def category
+      error_key.category
+    end
+
+    def category=(category)
+      error_key.category = category
+    end
+
+    def path
+      error_key.path
+    end
+
+    def path=(path)
+      error_key.path = path
+    end
+
+    def symbol
+      error_key.symbol
+    end
+
+    def symbol=(symbol)
+      error_key.symbol = symbol
+    end
 
     # 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...

data/projects/{common → typesystem/projects/common}/src/error_key.rb

@@ -2,7 +2,7 @@ module Foobara
   # TODO: paths have use outside of errors. Make this more general.
   class ErrorKey
     # TODO: use this wherever it makes sense
-    EMPTY_PATH = [].freeze
+    EMPTY_PATH = EMPTY_ARRAY
 
     class << self
       def to_s_type(key)

data/projects/{common → typesystem/projects/common}/src/outcome.rb

@@ -55,14 +55,18 @@ module Foobara
       end
     end
 
-    foobara_delegate :has_error, :add_errors, to: :error_collection
+    def has_error
+      # :nocov:
+      error_collection.has_error
+      # :nocov:
+    end
 
-    def has_errors?
-      error_collection.has_errors?
+    def add_errors(*errors)
+      error_collection.add_errors(*errors)
     end
 
-    def add_errors(...)
-      error_collection.add_errors(...)
+    def has_errors?
+      error_collection.has_errors?
     end
 
     def errors

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

@@ -0,0 +1,3 @@
+module Foobara::Concerns; end
+
+Foobara.project("concerns", project_path: "#{__dir__}/../..")

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

@@ -0,0 +1,6 @@
+require "foobara/project"
+
+module Foobara::Delegate; end
+
+# TODO: we should just kill this project
+Foobara.project("delegate", project_path: "#{__dir__}/../..")

data/projects/{delegate → typesystem/projects/delegate}/src/extensions/module.rb

@@ -1,5 +1,8 @@
 class Module
+  # :nocov:
   def foobara_delegate(*method_names, to:, allow_nil: false)
+    warn "[DEPRECATION] `foobara_delegate` is deprecated and will be removed in future versions"
+
     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
@@ -9,4 +12,5 @@ class Module
       end
     end
   end
+  # :nocov:
 end

data/projects/{domain → typesystem/projects/domain}/lib/foobara/domain.rb

@@ -17,3 +17,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("domain", project_path: "#{__dir__}/../..")

data/projects/{domain → typesystem/projects/domain}/src/domain.rb

@@ -20,14 +20,12 @@ module Foobara
         when Foobara::Scoped
           if object.is_a?(Module) && object.foobara_domain?
             object
+          elsif object == Namespace.global
+            GlobalDomain
+          elsif object.scoped_path_set? && object.scoped_path.empty?
+            object.foobara_lookup_domain!("")
           else
-            parent = object.scoped_namespace
-
-            if parent
-              to_domain(parent)
-            else
-              GlobalDomain
-            end
+            to_domain(object.scoped_namespace)
           end
         else
           # :nocov:
@@ -79,6 +77,36 @@ module Foobara
       def current
         to_domain(Namespace.current)
       end
+
+      def copy_constants(old_mod, new_class)
+        old_mod.constants.each do |const_name|
+          value = old_mod.const_get(const_name)
+          if new_class.const_defined?(const_name)
+            to_replace = new_class.const_get(const_name)
+            if to_replace != value
+              new_class.send(:remove_const, const_name)
+              new_class.const_set(const_name, value)
+            end
+          else
+            new_class.const_set(const_name, value)
+          end
+        end
+
+        lower_case_constants = old_mod.instance_variable_get(:@foobara_lowercase_constants)
+
+        if lower_case_constants && !lower_case_constants.empty?
+          lower_case_constants&.each do |lower_case_constant|
+            new_class.singleton_class.define_method lower_case_constant do
+              old_mod.send(lower_case_constant)
+            end
+          end
+
+          new_lowercase_constants = new_class.instance_variable_get(:@foobara_lowercase_constants) || []
+          new_lowercase_constants += lower_case_constants
+
+          new_class.instance_variable_set(:@foobara_lowercase_constants, new_lowercase_constants)
+        end
+      end
     end
   end
 end