foobara 0.0.1

data/projects/type_declarations/src/handlers/registered_type_declaration/type_desugarizer.rb

@@ -0,0 +1,24 @@
+Foobara.require_project_file("type_declarations", "desugarizer")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class RegisteredTypeDeclaration < TypeDeclarationHandler
+        # TODO: make a quick way to convert a couple simple procs into a transformer
+        class TypeDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            sugary_type_declaration.is_a?(Types::Type)
+          end
+
+          def desugarize(type)
+            type.reference_or_declaration_data
+          end
+
+          def priority
+            Priority::FIRST - 1
+          end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/handlers/registered_type_declaration.rb

@@ -0,0 +1,26 @@
+Foobara.require_project_file("type_declarations", "type_declaration_handler")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      # TODO: we should just use the symbol instead of {type: symbol} to save space and simplify some stuff...
+      class RegisteredTypeDeclaration < TypeDeclarationHandler
+        def applicable?(sugary_type_declaration)
+          strict_type_declaration = desugarize(sugary_type_declaration)
+
+          return false unless strict_type_declaration.is_a?(::Hash)
+
+          # we only handle case where it's a builtin type not an extension of one
+          if strict_type_declaration.keys == [:type]
+            type_symbol = strict_type_declaration[:type]
+            type_registered?(type_symbol)
+          end
+        end
+
+        def priority
+          Priority::HIGH
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/processor.rb

@@ -0,0 +1,7 @@
+module Foobara
+  module TypeDeclarations
+    class Processor < Value::Processor
+      include WithRegistries
+    end
+  end
+end

data/projects/type_declarations/src/to_type_transformer.rb

@@ -0,0 +1,11 @@
+Foobara.require_project_file("type_declarations", "transformer")
+
+module Foobara
+  module TypeDeclarations
+    class ToTypeTransformer < Transformer
+      def always_applicable?
+        true
+      end
+    end
+  end
+end

data/projects/type_declarations/src/transformer.rb

@@ -0,0 +1,7 @@
+module Foobara
+  module TypeDeclarations
+    class Transformer < Value::Transformer
+      include WithRegistries
+    end
+  end
+end

data/projects/type_declarations/src/type_builder.rb

@@ -0,0 +1,112 @@
+module Foobara
+  module TypeDeclarations
+    class TypeBuilder
+      class NoTypeDeclarationHandlerFoundError < StandardError; end
+
+      include TruncatedInspect
+
+      attr_accessor :name, :type_declaration_handler_registry, :accesses
+
+      def initialize(
+        name,
+        accesses: GlobalDomain.foobara_type_builder,
+        type_declaration_handler_registry: TypeDeclarations::TypeDeclarationHandlerRegistry.new
+      )
+        self.name = name
+        self.type_declaration_handler_registry = type_declaration_handler_registry
+        self.accesses = Util.array(accesses).to_set
+      end
+
+      def accesses_up_hierarchy
+        [self, *accesses, *accesses.map(&:accesses_up_hierarchy).flatten].uniq
+      end
+
+      # declaration handlers
+
+      def register_type_declaration_handler(type_declaration_handler)
+        type_declaration_handler_registry.register(type_declaration_handler)
+      end
+
+      def type_declaration_handler_registries
+        accesses_up_hierarchy.map(&:type_declaration_handler_registry)
+      end
+
+      def type_declaration_handler_for(type_declaration)
+        handlers.each do |handler|
+          return handler if handler.applicable?(type_declaration)
+        end
+
+        raise NoTypeDeclarationHandlerFoundError,
+              "No type declaration handler found for #{type_declaration}"
+      end
+
+      def handlers
+        type_declaration_handler_registries.map(&:handlers).flatten.sort_by(&:priority)
+      end
+
+      def handler_for_class(klass)
+        handlers.find { |handler| handler.instance_of?(klass) }
+      end
+
+      def type_for_strict_stringified_declaration(type_declaration)
+        TypeDeclarations.strict_stringified do
+          handler = type_declaration_handler_for(type_declaration)
+          handler.process_value!(type_declaration)
+        end
+      end
+
+      def type_for_strict_declaration(type_declaration)
+        TypeDeclarations.strict do
+          handler = type_declaration_handler_for(type_declaration)
+          handler.process_value!(type_declaration)
+        end
+      end
+
+      def type_for_declaration(*type_declaration_bits, &block)
+        type_declaration = if block
+                             unless type_declaration_bits.empty?
+                               # :nocov:
+                               raise ArgumentError, "Cannot provide both block and declaration"
+                               # :nocov:
+                             end
+
+                             block
+                           else
+                             case type_declaration_bits.size
+                             when 0
+                               # :nocov:
+                               raise ArgumentError, "expected 1 argument or a block but got 0 arguments and no block"
+                               # :nocov:
+                             when 1
+                               type_declaration_bits.first
+                             else
+                               type_declaration_bits_to_type_declaration(type_declaration_bits)
+                             end
+                           end
+
+        handler = type_declaration_handler_for(type_declaration)
+        handler.process_value!(type_declaration)
+      end
+
+      private
+
+      def type_declaration_bits_to_type_declaration(type_declaration_bits)
+        type, *symbolic_processors, processor_data = type_declaration_bits
+
+        if !symbolic_processors.empty?
+          symbolic_processors = symbolic_processors.to_h { |symbol| [symbol, true] }
+
+          if processor_data.is_a?(::Hash) && !processor_data.empty?
+            processor_data.merge(symbolic_processors)
+          else
+            symbolic_processors
+          end
+        elsif processor_data.is_a?(::Hash)
+          processor_data
+        else
+          { processor_data.to_sym => true }
+        end.merge(type:)
+      end
+    end
+  end
+end

data/projects/type_declarations/src/type_declaration_error.rb

@@ -0,0 +1,9 @@
+module Foobara
+  module TypeDeclarations
+    class TypeDeclarationError < Foobara::Value::DataError
+      def fatal?
+        true
+      end
+    end
+  end
+end

data/projects/type_declarations/src/type_declaration_handler.rb

@@ -0,0 +1,120 @@
+Foobara.require_project_file("type_declarations", "with_registries")
+
+module Foobara
+  module TypeDeclarations
+    class TypeDeclarationHandler < Value::Processor::Pipeline
+      class << self
+        def foobara_manifest(to_include:)
+          # :nocov:
+          super.merge(processor_type: :type_declaration_handler)
+          # :nocov:
+        end
+
+        def starting_desugarizers
+          starting_desugarizers_with_inherited
+        end
+
+        def starting_desugarizers_with_inherited
+          # TODO: this is not great because if new stuff gets registered at runtime then we can't really
+          # update this cached data easily
+          if superclass == TypeDeclarationHandler
+            starting_desugarizers_without_inherited
+          else
+            [*superclass.starting_desugarizers, *starting_desugarizers_without_inherited]
+          end
+        end
+
+        def starting_desugarizers_without_inherited
+          # TODO: this is not great because if new stuff gets registered at runtime then we can't really
+          # update this cached data easily
+          Util.constant_values(self, extends: TypeDeclarations::Desugarizer).map(&:instance)
+        end
+
+        def starting_type_declaration_validators
+          # TODO: this is not great because if new stuff gets registered at runtime then we can't really
+          # update this cached data easily
+          Util.constant_values(self, extends: Value::Validator, inherit: true).map(&:instance)
+        end
+      end
+
+      include WithRegistries
+
+      attr_accessor :desugarizers, :type_declaration_validators
+
+      def initialize(
+        *args,
+        processors: nil,
+        desugarizers: starting_desugarizers,
+        type_declaration_validators: starting_type_declaration_validators,
+        **opts
+      )
+        if processors && !processors.empty?
+          # :nocov:
+          raise ArgumentError, "Cannot set processors directly for a type declaration handler"
+          # :nocov:
+        end
+
+        self.desugarizers = Util.array(desugarizers)
+        self.type_declaration_validators = Util.array(type_declaration_validators)
+
+        super(*Util.args_and_opts_to_args(args, opts))
+      end
+
+      foobara_delegate :starting_desugarizers,
+                       :starting_desugarizers_with_inherited,
+                       :starting_desugarizers_without_inherited,
+                       :starting_type_declaration_validators,
+                       to: :class
+
+      def to_type_transformer
+        self.class::ToTypeTransformer.instance
+      end
+
+      def inspect
+        # :nocov:
+        s = super
+
+        if s.size > 400
+          s = "#{s[0..400]}..."
+        end
+
+        s
+        # :nocov:
+      end
+
+      def applicable?(_sugary_type_declaration)
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def processors
+        [desugarizer, type_declaration_validator, to_type_transformer]
+      end
+
+      def process_value(raw_type_declaration)
+        # TODO: deep_dup this again??
+        super(raw_type_declaration).tap do |type_outcome|
+          if type_outcome.success?
+            type_outcome.result.raw_declaration_data = raw_type_declaration
+          end
+        end
+      end
+
+      def desugarizer
+        # TODO: memoize this?
+        Value::Processor::Pipeline.new(processors: desugarizers)
+      end
+
+      def desugarize(value)
+        desugarizer.process_value!(value)
+      end
+
+      def type_declaration_validator
+        Value::Processor::Pipeline.new(processors: type_declaration_validators)
+      end
+
+      alias to_type process_value!
+    end
+  end
+end

data/projects/type_declarations/src/type_declaration_handler_registry.rb

@@ -0,0 +1,27 @@
+module Foobara
+  module TypeDeclarations
+    class TypeDeclarationHandlerRegistry < Value::Processor::Selection
+      class << self
+        def foobara_manifest(to_include:)
+          # :nocov:
+          super.merge(processor_type: :type_declaration_handler_registry)
+          # :nocov:
+        end
+      end
+
+      def initialize
+        super(enforce_unique: false)
+      end
+
+      def type_declaration_handler_for_handler_class(type_declaration_handler_class)
+        processors.find do |type_declaration_handler|
+          type_declaration_handler.instance_of?(type_declaration_handler_class)
+        end
+      end
+
+      alias type_declaration_handler_for processor_for!
+      alias handlers processors
+      alias type_for process_value!
+    end
+  end
+end

data/projects/type_declarations/src/type_declaration_validator.rb

@@ -0,0 +1,19 @@
+module Foobara
+  module TypeDeclarations
+    class TypeDeclarationValidator < Value::Validator
+      include WithRegistries
+
+      class << self
+        def foobara_manifest(to_include:)
+          # :nocov:
+          super.merge(processor_type: :type_declaration_validator)
+          # :nocov:
+        end
+      end
+
+      def always_applicable?
+        true
+      end
+    end
+  end
+end

data/projects/type_declarations/src/type_declarations.rb

@@ -0,0 +1,128 @@
+module Foobara
+  require_project_file("type_declarations", "type_builder")
+  require_project_file("type_declarations", "error_extension")
+
+  module TypeDeclarations
+    module Mode
+      STRICT = :strict
+      STRICT_STRINGIFIED = :strict_stringified
+    end
+
+    class << self
+      def global_type_declaration_handler_registry
+        GlobalDomain.foobara_type_builder.type_declaration_handler_registry
+      end
+
+      def register_type_declaration(type_declaration_handler)
+        global_type_declaration_handler_registry.register(type_declaration_handler)
+      end
+
+      def strict(&)
+        using_mode(Mode::STRICT, &)
+      end
+
+      def strict_stringified(&)
+        using_mode(Mode::STRICT_STRINGIFIED, &)
+      end
+
+      def using_mode(new_mode)
+        old_mode = Thread.foobara_var_get(:foobara_type_declarations_mode)
+        begin
+          Thread.foobara_var_set(:foobara_type_declarations_mode, new_mode)
+          yield
+        ensure
+          Thread.foobara_var_set(:foobara_type_declarations_mode, old_mode)
+        end
+      end
+
+      def strict?
+        Thread.foobara_var_get(:foobara_type_declarations_mode) == Mode::STRICT
+      end
+
+      def strict_stringified?
+        Thread.foobara_var_get(:foobara_type_declarations_mode) == Mode::STRICT_STRINGIFIED
+      end
+    end
+  end
+end
+
+=begin
+how many handlers do we need??
+
+
+find registered type by symbol
+
+extend registered type (find it by symbol and use it to construct new type with additional processors)
+
+Duck
+  AtomicDuck
+    Number
+      Integer
+        BigInteger
+      Float
+        BigDecimal
+    String
+      Email
+      Phone
+    Datetime
+    Date
+    Boolean
+  Duckture
+    Array
+      Tuple
+      AssociativeArray
+        Attributes
+          Model
+            Address
+              UsAddress
+            Entity
+
+Duck (RegisteredTypeExtensionTypeDeclarationHandler)
+  AtomicDuck (N/A)
+    Number (N/A)
+      Integer (RegisteredTypeExtensionTypeDeclarationHandler)
+        BigInteger (RegisteredTypeExtensionTypeDeclarationHandler)
+      Float (RegisteredTypeExtensionTypeDeclarationHandler)
+        BigDecimal (RegisteredTypeExtensionTypeDeclarationHandler)
+    String (RegisteredTypeExtensionTypeDeclarationHandler)
+      Email (implement in terms of string extension)
+      Phone (implement in terms of string extension)
+    Datetime (RegisteredTypeExtensionTypeDeclarationHandler)
+    Date (RegisteredTypeExtensionTypeDeclarationHandler)
+    Boolean (RegisteredTypeExtensionTypeDeclarationHandler)
+  Duckture (N/A)
+    Array (hmmmm we need an element processor initialized with the element type...)
+      Tuple (hmmmm we need an element processor initialized with the elements type...)
+      AssociativeArray (hmmmm we need an element processor initialized with the key type and the value type...)
+        Attributes (we need an element processor initialized with the attribute_types)
+          Model (same as above but need to add a name attribute...)
+            Address (implement in terms of model)
+              UsAddress (implement in terms of Address)
+            Entity (same as above but with a primary key processor of some sort)
+
+
+TypeDeclarationHandler
+  RegisteredAtomTypeExtensionTypeDeclarationHandler
+  RegisteredStructuredTypeExtensionTypeDeclarationHandler
+    ExtendArrayTypeDeclarationHandler
+    ExtendTupleTypeDeclarationHandler
+    ExtendAssociativeArrayTypeDeclaration
+    ExtendAttributesTypeDeclaration
+    ExtendModelTypeDeclarationHandler
+    ExtendEntityTypeDeclarationHandler
+
+I think we need these type declarations but not necessarily Type subclasses for all of these types
+
+Maybe just one Type class??
+
+let's see...
+
+for atom could just not support element_types nor size
+for array element_types could just be applied repeating?? Kind of goofy
+For tuple element_types could be applied repeating and size validator could be added
+for associative array... element_types need to be a hash instead of an array. Is that OK?
+  Or could be an array of pairs... like Hash#to_a ? Maybe we just operate off of #each? Seems that will work, wow...
+For Attributes same as associative array but with key processor of symbol plus an attributes_processor
+For model add a name processor
+for entity add a primary key processor of some sort...
+=end

data/projects/type_declarations/src/typed_transformer.rb

@@ -0,0 +1,89 @@
+module Foobara
+  module TypeDeclarations
+    # TODO: this should instead be a processor and have its own possible_errors
+    class TypedTransformer < Value::Transformer
+      class << self
+        # A,B,C,D
+        # let's say this transformer is C...
+        # If we are a noop, then we are going to output D.type and we expect B.type
+        # We obviously have a problem if D is incompatible with our output type.
+        # We need to know B.output_type in order to say what we are going to output.
+        #
+        # Conversely, we need to know what D expects in order to say what we expect to receive (sometimes)
+        #
+        # So logic is... For C to say what its type is, it must know B's output_type.
+        # or... I guess for an inputs transformer, we need to know what D expects as its type, right?
+        # since we have an obligation be compatible with it.
+        #
+        # Use case 1: command line interface gets awkward with models
+        # 1. Command takes model A
+        # 2. we want an inputs transformer that takes A.attributes_type
+        # 3. Therefore its type is A.attributes_type
+        # 4. And also, its output type is A.attributes_type in this case since there's no need to actually create the
+        #    models.
+        # 5. So to tell our type, we must know the type of what comes next.
+        #
+        # Use case 2:
+        # 1. Command takes foo: :integer but we want to take bar: :string
+        # 2. transformer has this hard-coded knowledge.
+        # 3. we don't need to receive either types to answer our input and output types.
+        #
+        # Use case 3: Changing a record into its primary key
+        # 1. Command has result type of A which is an Entity
+        # 2. transformer takes an A record and returns record.primary_key
+        # 3. To know the output type, we need to know the result type of the previous type.
+        # 4. To know the input type, we need to know the type of the previous transformer since they are the same.
+        #    (however, by convention we can just use nil in this case.)
+        #
+        # Use case 4: document upload
+        # 1. Command takes input stream plus some document info
+        # 2. controller action receives temporary file path
+        # 3. transformer opens input stream and replaces file path with input stream
+        # 4. In this case, we have hard-coded types.
+        #
+        # Challenge: we seem to not know in advance if the transformer needs to know what comes before it or what comes
+        # after it. Unless we are writing a one-off transformer then we have hard-coded knowledge.
+        #
+        # Seems like input transformer really needs to know what comes next, the target type.
+        # Seems like output transformer might require to know what came previously
+        #
+        # Plan:
+        # 1. Both inputs transformer and result have similar structure... they have a relevant type that they transform.
+        # The difference is that the result takes previous steps output and transforms it to a different type, whereas
+        # the input transformer needs to know what comes next in order to communicate its types.
+        # So we might be able to get away with a transformed_type that accepts the from_type. And the calling code can
+        # interpret how it goes. This might create some awkwardness or confusion at least when creating one of the
+        # two types of transformer.
+        def type_declaration(_from_type)
+          nil
+        end
+
+        def type(from_type)
+          dec = type_declaration(from_type)
+
+          if dec
+            if dec.is_a?(Types::Type)
+              dec
+            else
+              Domain.current.foobara_type_from_declaration(dec)
+
+            end
+          end
+        end
+      end
+
+      alias from_type declaration_data
+
+      def type
+        return @type if @type
+
+        @type = self.class.type(from_type)
+      end
+
+      def process_value(value)
+        output = transform(value)
+        Outcome.success(output)
+      end
+    end
+  end
+end

data/projects/type_declarations/src/validator.rb

@@ -0,0 +1,7 @@
+module Foobara
+  module TypeDeclarations
+    class Validator < Value::Validator
+      include WithRegistries
+    end
+  end
+end

data/projects/type_declarations/src/with_registries.rb

@@ -0,0 +1,41 @@
+module Foobara
+  module TypeDeclarations
+    module WithRegistries
+      include Concern
+
+      module ClassMethods
+        def type_for_declaration(...)
+          Domain.current.foobara_type_from_declaration(...)
+        end
+
+        def type_declaration_handler_for(...)
+          Domain.current.foobara_type_builder.type_declaration_handler_for(...)
+        end
+
+        def lookup_absolute_type!(*, **opts, &)
+          Foobara::Namespace.global.foobara_lookup_type!(*, **opts.merge(mode: Namespace::LookupMode::ABSOLUTE), &)
+        end
+
+        def lookup_type!(...)
+          Foobara::Namespace.current.foobara_lookup_type!(...)
+        end
+
+        def type_registered?(...)
+          Foobara::Namespace.current.foobara_type_registered?(...)
+        end
+
+        def handler_for_class(...)
+          Domain.current.foobara_type_builder.handler_for_class(...)
+        end
+      end
+
+      foobara_delegate :type_for_declaration,
+                       :type_declaration_handler_for,
+                       :lookup_type!,
+                       :lookup_absolute_type!,
+                       :type_registered?,
+                       :handler_for_class,
+                       to: :class
+    end
+  end
+end

data/projects/types/lib/foobara/types.rb

@@ -0,0 +1,11 @@
+require "singleton"
+
+module Foobara
+  module Types
+    class << self
+      def install!
+        Namespace.global.foobara_add_category_for_instance_of(:type, Type)
+      end
+    end
+  end
+end

data/projects/types/src/element_processor.rb

@@ -0,0 +1,7 @@
+module Foobara
+  module Types
+    # TODO: what is the point of this? Document it or delete this if there's no point.
+    class ElementProcessor < Value::Processor
+    end
+  end
+end