rom-core 4.0.0.beta1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013-2017 rom-rb team
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,18 @@
+[gem]: https://rubygems.org/gems/rom-core
+[gemnasium]: https://gemnasium.com/rom-rb/rom-core
+
+# rom-core [![Gitter chat](https://badges.gitter.im/rom-rb/chat.svg)](https://gitter.im/rom-rb/chat)
+
+[![Gem Version](https://badge.fury.io/rb/rom-core.svg)][gem]
+[![Dependency Status](https://gemnasium.com/rom-rb/rom-core.svg)][gemnasium]
+
+Core API for rom-rb and its adapters and extensions.
+
+Resources:
+
+* [User documentation](http://rom-rb.org/learn/core)
+* [API documentation](http://rubydoc.info/gems/rom-core)
+
+## License
+
+See `LICENSE` file.

data/lib/rom-core.rb

@@ -0,0 +1 @@
+require 'rom/core'

data/lib/rom/array_dataset.rb

@@ -0,0 +1,44 @@
+require 'rom/initializer'
+require 'rom/enumerable_dataset'
+
+module ROM
+  # A helper module that adds data-proxy behavior to an array-like object
+  #
+  # @see EnumerableDataset
+  #
+  # @api public
+  module ArrayDataset
+    extend DataProxy::ClassMethods
+    include EnumerableDataset
+
+    # Extends the class with data-proxy behavior
+    #
+    # @api private
+    def self.included(klass)
+      klass.class_eval do
+        extend Initializer
+        include DataProxy
+
+        param :data
+      end
+    end
+
+    forward(
+      :*, :+, :-, :compact, :compact!, :flatten, :flatten!, :length, :pop,
+      :reverse, :reverse!, :sample, :size, :shift, :shuffle, :shuffle!,
+      :slice, :slice!, :sort!, :uniq, :uniq!, :unshift, :values_at
+    )
+
+    [
+      :map!, :combination, :cycle, :delete_if, :keep_if, :permutation, :reject!,
+      :select!, :sort_by!
+    ].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(*args, &block)
+          return to_enum unless block
+          self.class.new(data.send(:#{method}, *args, &block), options)
+        end
+      RUBY
+    end
+  end
+end

data/lib/rom/association_set.rb

@@ -0,0 +1,16 @@
+require 'rom/registry'
+
+module ROM
+  # @api public
+  class AssociationSet < ROM::Registry
+    # @api private
+    def initialize(*)
+      super
+      elements.values.each do |assoc|
+        if assoc.aliased? && !key?(assoc.name)
+          elements[assoc.name] = assoc
+        end
+      end
+    end
+  end
+end

data/lib/rom/associations/abstract.rb

@@ -0,0 +1,135 @@
+require 'dry/core/constants'
+require 'dry/core/class_attributes'
+
+require 'rom/types'
+require 'rom/initializer'
+require 'rom/support/memoizable'
+
+module ROM
+  module Associations
+    # Abstract association class
+    #
+    # @api public
+    class Abstract
+      extend Initializer
+
+      include Memoizable
+      include Dry::Equalizer(:definition, :source, :target)
+
+      # @!attribute [r] definition
+      #   @return [ROM::Associations::Definition] Association configuration object
+      param :definition
+
+      # @!attribute [r] relations
+      #   @return [ROM::RelationRegistry] Relation registry
+      option :relations, reader: true
+
+      # @!attribute [r] source
+      #   @return [ROM::SQL::Relation] the source relation
+      option :source, reader: true
+
+      # @!attribute [r] target
+      #   @return [ROM::SQL::Relation::Name] the target relation
+      option :target, reader: true
+
+      # @api public
+      def self.new(definition, relations)
+        super(
+          definition,
+          relations: relations,
+          source: relations[definition.source.relation],
+          target: relations[definition.target.relation]
+        )
+      end
+
+      # @api public
+      def aliased?
+        definition.aliased?
+      end
+
+      # @api public
+      def as
+        definition.as
+      end
+
+      # @api public
+      def name
+        definition.name
+      end
+
+      # @api public
+      def view
+        definition.view
+      end
+
+      # @api public
+      def foreign_key
+        definition.foreign_key
+      end
+
+      # @api public
+      def result
+        definition.result
+      end
+
+      # @api public
+      def override?
+        definition.override
+      end
+
+      # @api public
+      def key
+        as || name
+      end
+
+      # @api protected
+      def apply_view(schema, relation)
+        view_rel = relation.public_send(view)
+        schema.merge(view_rel.schema).uniq(&:key).(view_rel)
+      end
+
+      # @api public
+      def combine_keys
+        { source_key => target_key }
+      end
+
+      # @api private
+      def join_key_map
+        join_keys.to_a.flatten(1).map(&:key)
+      end
+
+      # @api private
+      def node
+        target.with(
+          name: target.name.as(key),
+          meta: { keys: combine_keys, combine_type: result, combine_name: key }
+        )
+      end
+
+      # @api private
+      def wrap
+        target.with(
+          name: target.name.as(key),
+          schema: target.schema.wrap,
+          meta: { wrap: true, combine_name: key }
+        )
+      end
+
+      # @api private
+      def prepare(target)
+        if override?
+          target.public_send(view)
+        else
+          call(target: target)
+        end
+      end
+
+      # @api private
+      def self_ref?
+        source.name.dataset == target.name.dataset
+      end
+
+      memoize :combine_keys, :join_key_map
+    end
+  end
+end

data/lib/rom/associations/definitions.rb

@@ -0,0 +1,5 @@
+require 'rom/associations/definitions/many_to_many'
+require 'rom/associations/definitions/many_to_one'
+require 'rom/associations/definitions/one_to_many'
+require 'rom/associations/definitions/one_to_one'
+require 'rom/associations/definitions/one_to_one_through'

data/lib/rom/associations/definitions/abstract.rb

@@ -0,0 +1,116 @@
+require 'dry/core/class_attributes'
+
+require 'rom/constants'
+require 'rom/types'
+require 'rom/initializer'
+require 'rom/relation/name'
+require 'rom/associations/through_identifier'
+
+module ROM
+  module Associations
+    module Definitions
+      # Abstract association definition object
+      #
+      # @api public
+      class Abstract
+        include Dry::Equalizer(:source, :target, :result)
+        extend Initializer
+        extend Dry::Core::ClassAttributes
+
+        defines :result
+
+        # @!attribute [r] source
+        #   @return [Relation::Name] the source relation name
+        param :source
+
+        # @!attribute [r] target
+        #   @return [Relation::Name] the target relation name
+        param :target
+
+        # @!attribute [r] relation
+        #   @return [Symbol] an optional relation identifier for the target
+        option :relation, Types::Strict::Symbol, optional: true
+
+        # @!attribute [r] result
+        #   @return [Symbol] either :one or :many
+        option :result, Types::Strict::Symbol, default: -> { self.class.result }
+
+        # @!attribute [r] name
+        #   @return [Symbol] The name of an association
+        option :name, Types::Strict::Symbol, default: -> { target.to_sym }
+
+        # @!attribute [r] alias
+        #   @return [Symbol] An optional association alias
+        option :as, Types::Strict::Symbol.optional, optional: true
+
+        # @!attribute [r] foreign_key
+        #   @return [Symbol] an optional association alias name
+        option :foreign_key, Types::Optional::Strict::Symbol, optional: true
+
+        # @!attribute [r] view
+        #   @return [Symbol] An optional view that should be used to extend assoc relation
+        option :view, optional: true
+
+        # @!attribute [r] override
+        #   @return [TrueClass,FalseClass] Whether custom view should override default one or not
+        option :override, optional: true, default: -> { false }
+
+        # Instantiate a new association definition
+        #
+        # @param [Symbol] source The name of the source dataset
+        # @param [Symbol] target The name of the target dataset
+        # @param [Hash] options The option hash
+        # @option options [Symbol] :as The name of the association (defaults to target)
+        # @option options [Symbol] :relation The name of the target relation (defaults to target)
+        # @option options [Symbol] :foreign_key The name of a custom foreign key
+        # @option options [Symbol] :view The name of a custom relation view on the target's relation side
+        # @option options [TrueClass,FalseClass] :override Whether provided :view should override association's default view
+        #
+        # @api public
+        def self.new(source, target, opts = EMPTY_HASH)
+          source_name = Relation::Name[source]
+          target_name = resolve_target_name(target, opts)
+          options = process_options(target_name, Hash[opts])
+
+          super(source_name, target_name, options)
+        end
+
+        # @api private
+        def self.resolve_target_name(target, options)
+          dataset = target
+          relation = options.fetch(:relation, target)
+
+          Relation::Name[relation, dataset, options[:as]]
+        end
+
+        # @api private
+        def self.process_options(target, options)
+          through = options[:through]
+
+          if through
+            options[:through] = ThroughIdentifier[through, target.relation, options[:assoc]]
+          end
+
+          options[:name] = target.relation
+
+          options
+        end
+
+        # @api public
+        def override?
+          options[:override].equal?(true)
+        end
+
+        # @api public
+        def aliased?
+          options.key?(:as)
+        end
+
+        # @api public
+        def type
+          Dry::Core::Inflector.demodulize(self.class.name).to_sym
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'rom/types'
+require 'rom/associations/definitions/abstract'
+
+module ROM
+  module Associations
+    module Definitions
+      class ManyToMany < Abstract
+        result :many
+
+        option :through, reader: true
+
+        # @api private
+        def through_relation
+          through.relation
+        end
+
+        # @api private
+        def through_assoc_name
+          through.assoc_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'rom/associations/definitions/abstract'
+
+module ROM
+  module Associations
+    module Definitions
+      class ManyToOne < Abstract
+        result :one
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'rom/associations/definitions/abstract'
+
+module ROM
+  module Associations
+    module Definitions
+      class OneToMany < Abstract
+        result :many
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'rom/associations/definitions/abstract'
+
+module ROM
+  module Associations
+    module Definitions
+      class OneToOne < Abstract
+        result :one
+      end
+    end
+  end
+end

data/lib/rom/associations/definitions/one_to_one_through.rb

@@ -0,0 +1,11 @@
+require 'rom/associations/definitions/abstract'
+
+module ROM
+  module Associations
+    module Definitions
+      class OneToOneThrough < ManyToMany
+        result :one
+      end
+    end
+  end
+end