rom 5.4.2 → 6.0.0.alpha1

data/lib/rom/attribute.rb

@@ -0,0 +1,425 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+
+require "rom/initializer"
+require "rom/support/memoizable"
+require "rom/types"
+
+module ROM
+  # Schema attributes provide meta information about types and an API
+  # for additional operations. This class can be extended by adapters to provide
+  # database-specific features. In example rom-sql provides SQL::Attribute
+  # with more features like creating SQL expressions for queries.
+  #
+  # Schema attributes are accessible through canonical relation schemas and
+  # instance-level schemas.
+  #
+  # @api public
+  class Attribute
+    include Dry::Equalizer(:type, :options)
+    include Memoizable
+
+    extend Initializer
+
+    META_OPTIONS = %i[primary_key foreign_key source target relation].freeze
+
+    # @!attribute [r] type
+    #   @return [Dry::Types::Nominal, Dry::Types::Sum, Dry::Types::Constrained] The attribute's type object
+    param :type
+
+    # @!attribute [r] name
+    #
+    # Return the canonical name of this attribute name
+    #
+    # This *always* returns the name that is used in the datastore, even when
+    # an attribute is aliased
+    #
+    # @example
+    #   class Users < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :user_id, Types::Integer, alias: :id
+    #       attribute :email, Types::String
+    #     end
+    #   end
+    #
+    #   users[:user_id].name
+    #   # => :user_id
+    #
+    #   users[:email].name
+    #   # => :email
+    #
+    # @return [Symbol]
+    #
+    # @api public
+    option :name, optional: true, type: Types::Strict::Symbol
+
+    # @!attribute [r] type
+    #   @return [Symbol, nil] Alias to use instead of attribute name
+    option :alias, optional: true, type: Types::Strict::Symbol.optional
+
+    # @api private
+    def [](value = Undefined)
+      type[value]
+    end
+
+    # Return true if this attribute type is a primary key
+    #
+    # @example
+    #   class Users < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :id, Types::Integer
+    #       attribute :name, Types::String
+    #
+    #       primary_key :id
+    #     end
+    #   end
+    #
+    #   Users.schema[:id].primary_key?
+    #   # => true
+    #
+    #   Users.schema[:name].primary_key?
+    #   # => false
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @api public
+    def primary_key?
+      meta[:primary_key].equal?(true)
+    end
+
+    # Return true if this attribute type is a foreign key
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :id, Types::Integer
+    #       attribute :user_id, Types.ForeignKey(:users)
+    #     end
+    #   end
+    #
+    #   Users.schema[:user_id].foreign_key?
+    #   # => true
+    #
+    #   Users.schema[:id].foreign_key?
+    #   # => false
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @api public
+    def foreign_key?
+      meta[:foreign_key].equal?(true)
+    end
+
+    # Return true if this attribute has a configured alias
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :user_id, Types::Integer, alias: :id
+    #       attribute :name, Types::String
+    #     end
+    #   end
+    #
+    #   Users.schema[:user_id].aliased?
+    #   # => true
+    #
+    #   Users.schema[:name].aliased?
+    #   # => false
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @api public
+    def aliased?
+      !self.alias.nil?
+    end
+
+    # Return source relation of this attribute type
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :id, Types::Integer
+    #       attribute :user_id, Types.ForeignKey(:users)
+    #     end
+    #   end
+    #
+    #   Users.schema[:id].source
+    #   # => :tasks
+    #
+    #   Users.schema[:user_id].source
+    #   # => :tasks
+    #
+    # @return [Symbol, Relation::Name]
+    #
+    # @api public
+    def source
+      meta[:source]
+    end
+
+    # Return target relation of this attribute type
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :id, Types::Integer
+    #       attribute :user_id, Types.ForeignKey(:users)
+    #     end
+    #   end
+    #
+    #   Users.schema[:id].target
+    #   # => nil
+    #
+    #   Users.schema[:user_id].target
+    #   # => :users
+    #
+    # @return [NilClass, Symbol, Relation::Name]
+    #
+    # @api public
+    def target
+      meta[:target]
+    end
+
+    # Return tuple key
+    #
+    # When schemas are projected with aliased attributes, we need a simple access to tuple keys
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :user_id, Types::Integer, alias: :id
+    #       attribute :name, Types::String
+    #     end
+    #   end
+    #
+    #   Users.schema[:id].key
+    #   # :id
+    #
+    #   Users.schema.project(Users.schema[:id].aliased(:user_id)).key
+    #   # :user_id
+    #
+    # @return [Symbol]
+    #
+    # @api public
+    def key
+      self.alias || name
+    end
+
+    # Return new attribute type with provided alias
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :user_id, Types::Integer
+    #       attribute :name, Types::String
+    #     end
+    #   end
+    #
+    #   aliased_user_id = Users.schema[:user_id].aliased(:id)
+    #
+    #   aliased_user_id.aliased?
+    #   # => true
+    #
+    #   aliased_user_id.name
+    #   # => :user_id
+    #
+    #   aliased_user_id.alias
+    #   # => :id
+    #
+    # @param [Symbol] name The alias
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def aliased(name)
+      with(alias: name)
+    end
+    alias_method :as, :aliased
+
+    # Return new attribute type with an alias using provided prefix
+    #
+    # @example
+    #   class Users < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :id, Types::Integer
+    #       attribute :name, Types::String
+    #     end
+    #   end
+    #
+    #   prefixed_id = Users.schema[:id].prefixed
+    #
+    #   prefixed_id.aliased?
+    #   # => true
+    #
+    #   prefixed_id.name
+    #   # => :id
+    #
+    #   prefixed_id.alias
+    #   # => :users_id
+    #
+    #   prefixed_id = Users.schema[:id].prefixed(:user)
+    #
+    #   prefixed_id.alias
+    #   # => :user_id
+    #
+    # @param [Symbol] prefix The prefix (defaults to source.dataset)
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def prefixed(prefix = source.dataset)
+      aliased(:"#{prefix}_#{name}")
+    end
+
+    # Return if the attribute type is from a wrapped relation
+    #
+    # Wrapped attributes are used when two schemas from different relations
+    # are merged together. This way we can identify them easily and handle
+    # correctly in places like auto-mapping.
+    #
+    # @api public
+    def wrapped?
+      meta[:wrapped].equal?(true)
+    end
+
+    # Return attribute type wrapped for the specified relation name
+    #
+    # @param [Symbol] name The name of the source relation (defaults to source.dataset)
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def wrapped(name = source.dataset)
+      prefixed(name).meta(wrapped: true)
+    end
+
+    # Return attribute type with additional meta information
+    #
+    # Return meta information hash if no opts are provided
+    #
+    # @param [Hash] opts The meta options
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def meta(opts = nil)
+      if opts
+        self.class.new(type.meta(opts), **options)
+      else
+        type.meta
+      end
+    end
+
+    # Return string representation of the attribute type
+    #
+    # @return [String]
+    #
+    # @api public
+    def inspect
+      opts = options.reject { |k| %i[type name].include?(k) }
+      meta_and_opts = meta.merge(opts).map { |k, v| "#{k}=#{v.inspect}" }
+      %(#<#{self.class}[#{type.name}] name=#{name.inspect} #{meta_and_opts.join(" ")}>)
+    end
+    alias_method :pretty_inspect, :inspect
+
+    # Check if the attribute type is equal to another
+    #
+    # @param [Dry::Type, Attribute] other
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @api public
+    def eql?(other)
+      other.is_a?(self.class) ? super : type.eql?(other)
+    end
+
+    # Return if this attribute type has additional attribute type for reading
+    # tuple values
+    #
+    # @return [TrueClass, FalseClass]
+    #
+    # @api private
+    def read?
+      !meta[:read].nil?
+    end
+
+    # Return read type
+    #
+    # @return [Dry::Types::Type]
+    #
+    # @api private
+    def to_read_type
+      read? ? meta[:read] : type
+    end
+
+    # Return write type
+    #
+    # @return [Dry::Types::Type]
+    #
+    # @api private
+    def to_write_type
+      type
+    end
+
+    # Return nullable attribute
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def optional
+      sum = self.class.new(super, **options)
+      read? ? sum.meta(read: meta[:read].optional) : sum
+    end
+
+    # @api private
+    def respond_to_missing?(name, include_private = false)
+      type.respond_to?(name) || super
+    end
+
+    # Return AST for the type
+    #
+    # @return [Array]
+    #
+    # @api public
+    def to_ast
+      [:attribute, [name, type.to_ast(meta: false), meta_options_ast]]
+    end
+
+    # Return AST for the read type
+    #
+    # @return [Array]
+    #
+    # @api public
+    def to_read_ast
+      [:attribute, [name, to_read_type.to_ast(meta: false), meta_options_ast]]
+    end
+
+    # @api private
+    def meta_options_ast
+      keys = %i[wrapped primary_key alias]
+      ast = meta.merge(options).select { |k, _| keys.include?(k) }
+      ast[:source] = source.to_sym if source
+      ast
+    end
+
+    memoize :to_ast, :to_read_ast, :meta_options_ast
+
+    private
+
+    # @api private
+    def method_missing(meth, *args, &block)
+      if type.respond_to?(meth)
+        response = type.__send__(meth, *args, &block)
+
+        if response.is_a?(type.class)
+          self.class.new(response, **options)
+        else
+          response
+        end
+      else
+        super
+      end
+    end
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+  end
+end

data/lib/rom/auto_curry.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ROM
+  # Relation extension which provides auto-currying of relation view methods
+  #
+  # @api private
+  module AutoCurry
+    def self.extended(klass)
+      klass.define_singleton_method(:method_added) do |name|
+        return if auto_curry_busy?
+
+        auto_curry_guard { auto_curry(name) }
+        super(name)
+      end
+    end
+
+    # @api private
+    def auto_curry_guard
+      @__auto_curry_busy__ = true
+      yield
+    ensure
+      @__auto_curry_busy__ = false
+    end
+
+    # @api private
+    def auto_curry_busy?
+      @__auto_curry_busy__ ||= false
+    end
+
+    # @api private
+    def auto_curried_methods
+      @__auto_curried_methods__ ||= Set.new
+    end
+
+    # Auto-curry a method
+    #
+    # @param [Symbol] name The name of a method
+    #
+    # @api private
+    def auto_curry(name, &block)
+      arity = instance_method(name).arity
+
+      return unless public_instance_methods.include?(name) && arity != 0
+
+      mod = Module.new
+
+      mod.module_eval do
+        define_method(name) do |*args, &mblock|
+          response =
+            if arity.negative? || arity == args.size
+              super(*args, &mblock)
+            else
+              self.class.curried.new(self, view: name, curry_args: args, arity: arity)
+            end
+
+          if block
+            response.instance_exec(&block)
+          else
+            response
+          end
+        end
+        ruby2_keywords(name) if respond_to?(:ruby2_keywords, true)
+      end
+
+      auto_curried_methods << name
+
+      prepend(mod)
+    end
+  end
+end

data/lib/rom/cache.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+module ROM
+  # Thread-safe cache used by various rom components
+  #
+  # @api private
+  class Cache
+    attr_reader :objects
+
+    # @api private
+    class Namespaced
+      # @api private
+      attr_reader :cache
+
+      # @api private
+      attr_reader :namespace
+
+      # @api private
+      attr_reader :parent
+
+      # @api private
+      def initialize(cache, namespace, parent:)
+        @cache = cache
+        @namespace = namespace
+        @parent = parent
+      end
+
+      # @api private
+      def namespaced(namespace)
+        parent.namespaced(namespace)
+      end
+
+      # @api private
+      def [](key)
+        cache[[namespace, key].hash]
+      end
+
+      # @api private
+      def fetch_or_store(*args, &block)
+        cache.fetch_or_store([namespace, args.hash].hash, &block)
+      end
+
+      # @api private
+      def size
+        cache.size
+      end
+
+      # @api private
+      def inspect
+        %(#<#{self.class} size=#{size}>)
+      end
+    end
+
+    # @api private
+    def initialize
+      @objects = Concurrent::Map.new
+      @namespaced = {}
+    end
+
+    # @api private
+    def [](key)
+      cache[key]
+    end
+
+    # @api private
+    def fetch_or_store(*args, &block)
+      objects.fetch_or_store(args.hash, &block)
+    end
+
+    # @api private
+    def size
+      objects.size
+    end
+
+    # @api private
+    def namespaced(namespace)
+      @namespaced[namespace] ||= Namespaced.new(objects, namespace, parent: self)
+    end
+
+    # @api private
+    def inspect
+      %(#<#{self.class} size=#{size} namespaced=#{@namespaced.inspect}>)
+    end
+  end
+end

data/lib/rom/changeset/associated.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "rom/initializer"
+
+module ROM
+  class Changeset
+    # Associated changesets automatically set up FKs
+    #
+    # @api public
+    class Associated
+      extend Initializer
+
+      # @!attribute [r] left
+      #   @return [Changeset::Create] Child changeset
+      param :left
+
+      # @!attribute [r] associations
+      #   @return [Array] List of association identifiers from relation schema
+      option :associations
+
+      # Infer association name from an object with a schema
+      #
+      # This expects other to be an object with a schema that includes a primary key
+      # attribute with :source meta information. This makes it work with both structs
+      # and relations
+      #
+      # @see Stateful#associate
+      #
+      # @api private
+      def self.infer_assoc_name(other)
+        schema = other.class.schema
+        attrs = schema.is_a?(Hash) ? schema.values : schema
+        pk = attrs.detect { |attr| attr.meta[:primary_key] }
+
+        if pk
+          pk.meta[:source]
+        else
+          raise ArgumentError, "can't infer association name for #{other}"
+        end
+      end
+
+      # Commit changeset's composite command
+      #
+      # @example
+      #   task_changeset = tasks.
+      #     changeset(title: 'Task One').
+      #     associate(user, :user).
+      #     commit
+      #   # {:id => 1, :user_id => 1, title: 'Task One'}
+      #
+      # @return [Array<Hash>, Hash]
+      #
+      # @api public
+      def commit
+        command.call
+      end
+
+      # Associate with other changesets
+      #
+      # @see Changeset#associate
+      #
+      # @return [Associated]
+      #
+      # @api public
+      def associate(other, name = Associated.infer_assoc_name(other))
+        self.class.new(left, associations: associations.merge(name => other))
+      end
+
+      # Create a composed command
+      #
+      # @example using existing parent data
+      #   user_changeset = users.changeset(name: 'Jane')
+      #   task_changeset = tasks.changeset(title: 'Task One')
+      #
+      #   user = users.create(user_changeset)
+      #   task = tasks.create(task_changeset.associate(user, :user))
+      #
+      # @example saving both parent and child in one go
+      #   user_changeset = users.changeset(name: 'Jane')
+      #   task_changeset = tasks.changeset(title: 'Task One')
+      #
+      #   task = tasks.create(task_changeset.associate(user, :user))
+      #
+      # This works *only* with parent => child(ren) changeset hierarchy
+      #
+      # @return [ROM::Command::Composite]
+      #
+      # @api public
+      def command
+        associations.reduce(left.command.curry(left)) do |a, (assoc, other)|
+          case other
+          when Changeset
+            a >> other.command.with_association(assoc).curry(other)
+          when Associated
+            a >> other.command.with_association(assoc)
+          when Array
+            raise NotImplementedError, "Changeset::Associate does not support arrays yet"
+          else
+            a.with_association(assoc, parent: other)
+          end
+        end
+      end
+
+      # @api private
+      def relation
+        left.relation
+      end
+    end
+  end
+end

data/lib/rom/changeset/create.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ROM
+  class Changeset
+    # Changeset specialization for create commands
+    #
+    # @see Changeset::Stateful
+    #
+    # @api public
+    class Create < Stateful
+      command_type :create
+
+      def command
+        super.new(relation)
+      end
+    end
+  end
+end

data/lib/rom/changeset/delete.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ROM
+  class Changeset
+    # Changeset specialization for delete commands
+    #
+    # Delete changesets will execute delete command for its relation, which
+    # means proper restricted relations should be used with this changeset.
+    #
+    # @api public
+    class Delete < Changeset
+      command_type :delete
+    end
+  end
+end