rom 1.0.0 → 2.0.0

data/lib/rom/relation/name.rb

@@ -0,0 +1,102 @@
+require 'dry/equalizer'
+require 'concurrent/map'
+
+module ROM
+  class Relation
+    # Relation name container
+    #
+    # This is a simple struct with two fields.
+    # It handles both relation registration name (i.e. Symbol) and dataset name.
+    # The reason we need it is a simplification of passing around these two objects.
+    # It is quite common to have a dataset named differently from a relation
+    # built on top if you are dealing with a legacy DB and often you need both
+    # to support things such as associations (rom-sql as an example).
+    #
+    # @api private
+    class Name
+      include Dry::Equalizer(:relation, :dataset)
+
+      # Coerce an object to a Name instance
+      #
+      # @return [ROM::Relation::Name]
+      #
+      # @api private
+      def self.[](*args)
+        cache.fetch_or_store(args.hash) do
+          relation, dataset = args
+
+          if relation.is_a?(Name)
+            relation
+          else
+            new(relation, dataset)
+          end
+        end
+      end
+
+      # @api private
+      def self.cache
+        @cache ||= Concurrent::Map.new
+      end
+
+      # Relation registration name
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      attr_reader :relation
+
+      # Underlying dataset name
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      attr_reader :dataset
+
+      # @api private
+      def initialize(relation, dataset = nil)
+        @relation = relation
+        @dataset = dataset || relation
+      end
+
+      # Return relation name
+      #
+      # @return [String]
+      #
+      # @api private
+      def to_s
+        if relation == dataset
+          relation
+        else
+          "#{relation} on #{dataset}"
+        end
+      end
+
+      # Alias for registration key implicitly called by ROM::Registry
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      def to_sym
+        relation
+      end
+
+      # Return inspected relation
+      #
+      # @return [String]
+      #
+      # @api private
+      def inspect
+        "#{self.class.name}(#{to_s})"
+      end
+
+      # Build a new name. Useful for Curried and other relation proxies
+      #
+      # @return [ROM::Relation::Name]
+      #
+      # @api private
+      def with(relation)
+        self.class[relation, dataset]
+      end
+    end
+  end
+end

data/lib/rom/relation_registry.rb

@@ -1,4 +1,9 @@
 module ROM
   class RelationRegistry < Registry
+    def initialize(elements = {}, name = self.class.name)
+      super
+
+      yield(self, elements) if block_given?
+    end
   end
 end

data/lib/rom/schema.rb

@@ -0,0 +1,87 @@
+require 'dry-equalizer'
+
+require 'rom/support/constants'
+require 'rom/schema/dsl'
+require 'rom/association_set'
+
+module ROM
+  # Relation schema
+  #
+  # @api public
+  class Schema
+    EMPTY_ASSOCIATION_SET = AssociationSet.new(EMPTY_HASH).freeze
+
+    include Dry::Equalizer(:name, :attributes, :associations)
+    include Enumerable
+
+    # @!attribute [r] name
+    #   @return [Symbol] The name of this schema
+    attr_reader :name
+
+    # @!attribute [r] attributes
+    #   @return [Hash] The hash with schema attribute types
+    attr_reader :attributes
+
+    # @!attribute [r] associations
+    #   @return [AssociationSet] Optional association set (this is adapter-specific)
+    attr_reader :associations
+
+    # @!attribute [r] inferrer
+    #   @return [#call] An optional inferrer object used in `finalize!`
+    attr_reader :inferrer
+
+    # @!attribute [r] primary_key
+    #   @return [Array<Dry::Types::Definition] Primary key array
+    attr_reader :primary_key
+
+    alias_method :to_h, :attributes
+
+    # @api private
+    def initialize(name, attributes, inferrer: nil, associations: EMPTY_ASSOCIATION_SET)
+      @name = name
+      @attributes = attributes
+      @associations = associations
+      @inferrer = inferrer
+    end
+
+    # Iterate over schema's attributes
+    #
+    # @yield [Dry::Data::Type]
+    #
+    # @api public
+    def each(&block)
+      attributes.each_value(&block)
+    end
+
+    # Return attribute
+    #
+    # @api public
+    def [](name)
+      attributes.fetch(name)
+    end
+
+    # Return FK attribute for a given relation name
+    #
+    # @return [Dry::Types::Definition]
+    #
+    # @api public
+    def foreign_key(relation)
+      detect { |attr| attr.meta[:foreign_key] && attr.meta[:relation] == relation }
+    end
+
+    # This hook is called when relation is being build during container finalization
+    #
+    # When block is provided it'll be called just before freezing the instance
+    # so that additional ivars can be set
+    #
+    # @return [self]
+    #
+    # @api private
+    def finalize!(gateway = nil, &block)
+      @attributes = inferrer.call(name.dataset, gateway) if inferrer
+      @primary_key = select { |attr| attr.meta[:primary_key] == true }
+      block.call if block
+      freeze
+    end
+  end
+end

data/lib/rom/schema/dsl.rb

@@ -0,0 +1,58 @@
+require 'dry-equalizer'
+require 'rom/types'
+
+module ROM
+  # Relation schema
+  #
+  # @api public
+  class Schema
+    include Dry::Equalizer(:name, :attributes)
+    include Enumerable
+
+    attr_reader :name, :attributes, :inferrer
+
+    # @api public
+    class DSL < BasicObject
+      attr_reader :name, :attributes, :inferrer
+
+      # @api private
+      def initialize(name, inferrer, &block)
+        @name = name
+        @inferrer = inferrer
+        @attributes = nil
+
+        if block
+          instance_exec(&block)
+        elsif inferrer.nil?
+          raise ArgumentError,
+            'You must pass a block to define a schema or set an inferrer for automatic inferring'
+        end
+      end
+
+      # Defines a relation attribute with its type
+      #
+      # @see Relation.schema
+      #
+      # @api public
+      def attribute(name, type)
+        @attributes ||= {}
+        @attributes[name] = type.meta(name: name)
+      end
+
+      # Specify which key(s) should be the primary key
+      #
+      # @api public
+      def primary_key(*names)
+        names.each do |name|
+          attributes[name] = attributes[name].meta(primary_key: true)
+        end
+        self
+      end
+
+      # @api private
+      def call
+        Schema.new(name, attributes, inferrer: inferrer && inferrer.new(self))
+      end
+    end
+  end
+end

data/lib/rom/setup/auto_registration.rb

@@ -14,9 +14,9 @@ module ROM
 
     def initialize(directory, options = EMPTY_HASH)
       super
-      @directory = directory
+      @directory = Pathname(directory)
       @globs = Hash[[:relations, :commands, :mappers].map { |name|
-        [name, Pathname(directory).join("#{name}/**/*.rb")]
+        [name, @directory.join("#{name}/**/*.rb")]
       }]
     end
 

data/lib/rom/setup/finalize.rb

@@ -6,9 +6,9 @@ require 'rom/command_registry'
 require 'rom/mapper_registry'
 
 require 'rom/container'
-require 'rom/setup/finalize/commands'
-require 'rom/setup/finalize/relations'
-require 'rom/setup/finalize/mappers'
+require 'rom/setup/finalize/finalize_commands'
+require 'rom/setup/finalize/finalize_relations'
+require 'rom/setup/finalize/finalize_mappers'
 
 # temporary
 require 'rom/configuration_dsl/relation'
@@ -57,7 +57,7 @@ module ROM
     #
     # @api private
     def run!
-      infer_relations_relations
+      infer_relations
 
       relations = load_relations
       mappers = load_mappers
@@ -112,7 +112,7 @@ module ROM
     # Relations explicitly defined are being skipped
     #
     # @api private
-    def infer_relations_relations
+    def infer_relations
       datasets.each do |gateway, schema|
         schema.each do |name|
           if infer_relation?(gateway, name)

data/lib/rom/setup/finalize/{commands.rb → finalize_commands.rb}

@@ -31,37 +31,17 @@ module ROM
           gateway = @gateways[relation.class.gateway]
           gateway.extend_command_class(klass, relation.dataset)
 
-          klass.send(:include, relation_methods_mod(relation.class))
+          klass.extend_for_relation(relation) if klass.restrictable
 
           (h[rel_name] ||= {})[name] = klass.build(relation)
         end
 
         commands = registry.each_with_object({}) do |(name, rel_commands), h|
-          h[name] = CommandRegistry.new(rel_commands)
+          h[name] = CommandRegistry.new(name, rel_commands)
         end
 
         Registry.new(commands)
       end
-
-      # @api private
-      def relation_methods_mod(relation_class)
-        mod = Module.new
-        relation_class.view_methods.each do |meth|
-          mod.module_eval <<-RUBY
-          def #{meth}(*args)
-            response = relation.public_send(:#{meth}, *args)
-
-            if response.is_a?(relation.class)
-              new(response)
-            else
-              response
-            end
-          end
-          RUBY
-        end
-
-        mod
-      end
     end
   end
 end

data/lib/rom/setup/finalize/finalize_relations.rb

@@ -0,0 +1,60 @@
+require 'rom/relation_registry'
+
+module ROM
+  class Finalize
+    class FinalizeRelations
+      # Build relation registry of specified descendant classes
+      #
+      # This is used by the setup
+      #
+      # @param [Hash] gateways
+      # @param [Array] relation_classes a list of relation descendants
+      #
+      # @api private
+      def initialize(gateways, relation_classes)
+        @gateways = gateways
+        @relation_classes = relation_classes
+      end
+
+      # @return [Hash]
+      #
+      # @api private
+      def run!
+        RelationRegistry.new do |registry, relations|
+          @relation_classes.each do |klass|
+            relation = build_relation(klass, registry)
+
+            key = relation.name.to_sym
+
+            if registry.key?(key)
+              raise RelationAlreadyDefinedError,
+                    "Relation with `register_as #{key.inspect}` registered more " \
+                    "than once"
+            end
+
+            relations[key] = relation
+          end
+
+          relations.each_value do |relation|
+            relation.class.finalize(registry, relation)
+          end
+        end
+      end
+
+      # @return [ROM::Relation]
+      #
+      # @api private
+      def build_relation(klass, registry)
+        # TODO: raise a meaningful error here and add spec covering the case
+        #       where klass' gateway points to non-existant repo
+        gateway = @gateways.fetch(klass.gateway)
+        ds_proc = klass.dataset_proc || -> _ { self }
+
+        klass.schema.finalize!(gateway) if klass.schema
+        dataset = gateway.dataset(klass.dataset).instance_exec(klass, &ds_proc)
+
+        klass.new(dataset, __registry__: registry)
+      end
+    end
+  end
+end

data/lib/rom/types.rb

@@ -0,0 +1,18 @@
+require 'dry-types'
+
+module ROM
+  module Types
+    include Dry::Types.module
+
+    def self.included(other)
+      other.extend(Methods)
+      super
+    end
+
+    module Methods
+      def ForeignKey(relation, type = Types::Int)
+        type.meta(foreign_key: true, relation: relation)
+      end
+    end
+  end
+end

data/lib/rom/version.rb

@@ -1,3 +1,3 @@
 module ROM
-  VERSION = '1.0.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/rom.gemspec

@@ -15,9 +15,11 @@ Gem::Specification.new do |gem|
   gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
   gem.license       = 'MIT'
 
+  gem.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
   gem.add_runtime_dependency 'dry-equalizer', '~> 0.2'
-  gem.add_runtime_dependency 'rom-support', '~> 1.0.0'
-  gem.add_runtime_dependency 'rom-mapper', '~> 0.3.0'
+  gem.add_runtime_dependency 'dry-types', '~> 0.8'
+  gem.add_runtime_dependency 'rom-support', '~> 2.0'
+  gem.add_runtime_dependency 'rom-mapper', '~> 0.4.0'
 
   gem.add_development_dependency 'rake', '~> 10.3'
   gem.add_development_dependency 'rspec', '~> 3.3'