rom-core 4.2.1 → 5.0.0

data/lib/rom/mapper/builder.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'dry/core/class_builder'
+
+module ROM
+  class Mapper
+    # Setup DSL-specific mapper extensions
+    #
+    # @private
+    class Builder
+      # Generate a mapper subclass
+      #
+      # This is used by Setup#mappers DSL
+      #
+      # @api private
+      def self.build_class(name, mapper_registry, options = EMPTY_HASH, &block)
+        class_name = "ROM::Mapper[#{name}]"
+
+        parent = options[:parent]
+        inherit_header = options.fetch(:inherit_header) { ROM::Mapper.inherit_header }
+
+        parent_class =
+          if parent
+            mapper_registry.detect { |klass| klass.relation == parent }
+          else
+            ROM::Mapper
+          end
+
+        Dry::Core::ClassBuilder.new(name: class_name, parent: parent_class).call do |klass|
+          klass.register_as(name)
+          klass.relation(name)
+          klass.inherit_header(inherit_header)
+
+          klass.class_eval(&block) if block
+        end
+      end
+    end
+  end
+end

data/lib/rom/mapper/configuration_plugin.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rom/mapper/mapper_dsl'
+
+module ROM
+  class Mapper
+    # Model DSL allows setting a model class
+    #
+    # @private
+    module ConfigurationPlugin
+      # Mapper definition DSL used by Setup DSL
+      #
+      # @private
+
+      def self.apply(configuration, options = {})
+        configuration.extend Methods
+        configuration
+      end
+
+      module Methods
+        def mappers(&block)
+          register_mapper(*MapperDSL.new(self, mapper_classes, block).mapper_classes)
+        end
+      end
+
+    end
+  end
+end

data/lib/rom/mapper/dsl.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'dry/core/class_attributes'
+require 'rom/mapper/attribute_dsl'
+
+module ROM
+  class Mapper
+    # Mapper class-level DSL including Attribute DSL and Model DSL
+    module DSL
+      # Extend mapper class with macros and DSL methods
+      #
+      # @api private
+      def self.included(klass)
+        klass.extend(Dry::Core::ClassAttributes)
+        klass.extend(ClassMethods)
+      end
+
+      # Class methods for all mappers
+      #
+      # @private
+      module ClassMethods
+        # Set base ivars for the mapper class
+        #
+        # @api private
+        def inherited(klass)
+          super
+
+          klass.instance_variable_set('@attributes', nil)
+          klass.instance_variable_set('@header', nil)
+          klass.instance_variable_set('@dsl', nil)
+        end
+
+        # include a registered plugin in this mapper
+        #
+        # @param [Symbol] plugin
+        # @param [Hash] options
+        # @option options [Symbol] :adapter (:default) first adapter to check for plugin
+        #
+        # @api public
+        def use(plugin, options = {})
+          adapter = options.fetch(:adapter, :default)
+
+          ROM.plugin_registry.mappers.fetch(plugin, adapter).apply_to(self)
+        end
+
+        # Return base_relation used for creating mapper registry
+        #
+        # This is used to "gather" mappers under same root name
+        #
+        # @api private
+        def base_relation
+          if superclass.relation
+            superclass.relation
+          else
+            relation
+          end
+        end
+
+        # Return header of the mapper
+        #
+        # This is memoized so mutating mapper class won't have an effect wrt
+        # header after it was initialized for the first time.
+        #
+        # TODO: freezing mapper class here is probably a good idea
+        #
+        # @api private
+        def header
+          @header ||= dsl.header
+        end
+
+        # @api private
+        def respond_to_missing?(name, _include_private = false)
+          dsl.respond_to?(name) || super
+        end
+
+        private
+
+        # Return default Attribute DSL options based on settings of the mapper
+        # class
+        #
+        # @api private
+        def options
+          { copy_keys: copy_keys,
+            prefix: prefix,
+            prefix_separator: prefix_separator,
+            symbolize_keys: symbolize_keys,
+            reject_keys: reject_keys }
+        end
+
+        # Return default attributes that might have been inherited from the
+        # superclass
+        #
+        # @api private
+        def attributes
+          @attributes ||=
+            if superclass.respond_to?(:attributes, true) && inherit_header
+              superclass.attributes.dup
+            else
+              []
+            end
+        end
+
+        # Create the attribute DSL instance used by the mapper class
+        #
+        # @api private
+        def dsl
+          @dsl ||= AttributeDSL.new(attributes, options)
+        end
+
+        # Delegate Attribute DSL method to the dsl instance
+        #
+        # @api private
+        def method_missing(name, *args, &block)
+          if dsl.respond_to?(name)
+            dsl.public_send(name, *args, &block)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/mapper/mapper_dsl.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'rom/mapper/builder'
+
+module ROM
+  class Mapper
+    # Mapper definition DSL used by Setup DSL
+    #
+    # @private
+    class MapperDSL
+      attr_reader :configuration, :mapper_classes, :defined_mappers
+
+      # @api private
+      def initialize(configuration, mapper_classes, block)
+        @configuration = configuration
+        @mapper_classes = mapper_classes
+        @defined_mappers = []
+
+        instance_exec(&block)
+
+        @mapper_classes = @defined_mappers
+      end
+
+      # Define a mapper class
+      #
+      # @param [Symbol] name of the mapper
+      # @param [Hash] options
+      #
+      # @return [Class]
+      #
+      # @api public
+      def define(name, options = EMPTY_HASH, &block)
+        @defined_mappers << Builder.build_class(name, (@mapper_classes + @defined_mappers), options, &block)
+        self
+      end
+
+      # TODO
+      #
+      # @api public
+      def register(relation, mappers)
+        configuration.register_mapper(relation => mappers)
+      end
+    end
+  end
+end

data/lib/rom/mapper/model_dsl.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'rom/model_builder'
+
+module ROM
+  class Mapper
+    # Model DSL allows setting a model class
+    #
+    # @private
+    module ModelDSL
+      attr_reader :attributes, :builder, :klass
+
+      DEFAULT_TYPE = :poro
+
+      # Set or generate a model
+      #
+      # @example
+      #   class MyDefinition
+      #     include ROM::Mapper::ModelDSL
+      #
+      #     def initialize
+      #       @attributes = [[:name], [:title]]
+      #     end
+      #   end
+      #
+      #   definition = MyDefinition.new
+      #
+      #   # just set a model constant
+      #   definition.model(User)
+      #
+      #   # generate model class for the attributes
+      #   definition.model(name: 'User')
+      #
+      # @api public
+      def model(options = nil)
+        if options.is_a?(Class)
+          @klass = options
+        elsif options
+          type = options.fetch(:type) { DEFAULT_TYPE }
+          @builder = ModelBuilder[type].new(options)
+        end
+
+        build_class unless options
+      end
+
+      private
+
+      # Build a model class using a specialized builder
+      #
+      # @api private
+      def build_class
+        return klass if klass
+        included_attrs = attributes.reject do |_name, opts|
+          opts && opts[:exclude]
+        end
+        builder.call(included_attrs.map(&:first)) if builder
+      end
+    end
+  end
+end

data/lib/rom/mapper_compiler.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'dry/core/class_attributes'
+
+require 'rom/constants'
+require 'rom/initializer'
+require 'rom/mapper'
+require 'rom/struct'
+require 'rom/struct_compiler'
+require 'rom/cache'
+
+module ROM
+  # @api private
+  class MapperCompiler
+    extend Dry::Core::ClassAttributes
+    extend Initializer
+
+    defines :mapper_options
+
+    mapper_options(EMPTY_HASH)
+
+    option :cache, default: -> { Cache.new }
+
+    attr_reader :struct_compiler
+
+    attr_reader :mapper_options
+
+    def initialize(*args)
+      super
+      @struct_compiler = StructCompiler.new(cache: cache)
+      @cache = cache.namespaced(:mappers)
+      @mapper_options = self.class.mapper_options
+    end
+
+    def call(ast)
+      cache.fetch_or_store(ast.hash) { Mapper.build(Header.coerce(*visit(ast))) }
+    end
+    alias_method :[], :call
+
+    private
+
+    def visit(node)
+      name, node = node
+      __send__("visit_#{name}", node)
+    end
+
+    def visit_relation(node)
+      rel_name, header, meta_options = node
+      name = meta_options[:combine_name] || meta_options[:alias] || rel_name
+      namespace = meta_options.fetch(:struct_namespace)
+
+      model = meta_options.fetch(:model) do
+        if meta_options[:combine_name]
+          false
+        else
+          struct_compiler[name, header, namespace]
+        end
+      end
+
+      options = [header.map(&method(:visit)), mapper_options.merge(model: model)]
+
+      if meta_options[:combine_type]
+        type = meta_options[:combine_type] == :many ? :array : :hash
+        keys = meta_options.fetch(:keys)
+
+        [name, combine: true, type: type, keys: keys, header: Header.coerce(*options)]
+      elsif meta_options[:wrap]
+        [name, wrap: true, type: :hash, header: Header.coerce(*options)]
+      else
+        options
+      end
+    end
+
+    def visit_attribute(node)
+      name, _, meta_options = node
+
+      if meta_options[:alias]
+        [meta_options[:alias], from: name]
+      else
+        [name]
+      end
+    end
+  end
+end

data/lib/rom/mapper_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/struct'
 require 'rom/registry'
 require 'rom/mapper_compiler'

data/lib/rom/memory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/memory/gateway'
 require 'rom/memory/relation'
 require 'rom/memory/mapper_compiler'

data/lib/rom/memory/associations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/memory/associations/many_to_many'
 require 'rom/memory/associations/many_to_one'
 require 'rom/memory/associations/one_to_many'

data/lib/rom/memory/associations/many_to_many.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/associations/many_to_many'
 
 module ROM

data/lib/rom/memory/associations/many_to_one.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/associations/many_to_one'
 
 module ROM

data/lib/rom/memory/associations/one_to_many.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/associations/one_to_many'
 
 module ROM

data/lib/rom/memory/associations/one_to_one.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/memory/associations/one_to_many'
 
 module ROM

data/lib/rom/memory/commands.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/commands'
 
 module ROM

data/lib/rom/memory/dataset.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/array_dataset'
 
 module ROM