rom-sql 0.9.1 → 1.0.0.beta1

data/lib/rom/sql/dsl.rb

@@ -0,0 +1,29 @@
+module ROM
+  module SQL
+    class DSL < BasicObject
+      # @api private
+      attr_reader :schema
+
+      # @api private
+      def initialize(schema)
+        @schema = schema
+      end
+
+      # @api private
+      def call(&block)
+        result = instance_exec(&block)
+
+        if result.is_a?(::Array)
+          result
+        else
+          [result]
+        end
+      end
+
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        super || schema.key?(name)
+      end
+    end
+  end
+end

data/lib/rom/sql/expression.rb

@@ -0,0 +1,26 @@
+module ROM
+  module SQL
+    class Expression
+      attr_reader :expr, :type
+
+      def initialize(type, expr = type.sql_expr)
+        @type = type
+        @expr = expr
+      end
+
+      def sql_literal(ds)
+        expr.sql_literal(ds)
+      end
+
+      private
+
+      def method_missing(meth, *args, &block)
+        if type.respond_to?(meth)
+          self.class.new(type.__send__(meth, *args, &block))
+        else
+          self.class.new(type, expr.__send__(meth, *args, &block))
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/function.rb

@@ -0,0 +1,23 @@
+module ROM
+  module SQL
+    class Function < ROM::Schema::Type
+      def as(name)
+        meta(name: name)
+      end
+
+      def sql_literal(ds)
+        func.as(name).sql_literal(ds)
+      end
+
+      private
+
+      def func
+        Sequel::SQL::Function.new(meta[:op], *meta[:args])
+      end
+
+      def method_missing(op, *args)
+        meta(op: op, args: args)
+      end
+    end
+  end
+end

data/lib/rom/sql/gateway.rb

@@ -1,8 +1,12 @@
 require 'logger'
 
+require 'dry/core/constants'
+
+require 'rom/types'
 require 'rom/gateway'
 require 'rom/sql/migration'
 require 'rom/sql/commands'
+require 'rom/sql/transaction'
 
 module ROM
   module SQL
@@ -16,7 +20,7 @@ module ROM
     #
     # @api public
     class Gateway < ROM::Gateway
-      include Options
+      include Dry::Core::Constants
       include Migration
 
       class << self
@@ -24,7 +28,7 @@ module ROM
       end
 
       CONNECTION_EXTENSIONS = {
-        postgres: %i(pg_array pg_json)
+        postgres: %i(pg_array pg_json pg_enum)
       }.freeze
 
       # Return optionally configured logger
@@ -34,6 +38,9 @@ module ROM
       # @api public
       attr_reader :logger
 
+      # @api private
+      attr_reader :options
+
       # SQL gateway interface
       #
       # @overload connect(uri, options)
@@ -55,14 +62,13 @@ module ROM
       #   gateway = ROM::SQL::Gateway.new(DB)
       #
       # @api public
-      def initialize(uri, options = {})
-        repo_options = self.class.option_definitions.names
-        conn_options = options.reject { |k, _| repo_options.include?(k) }
-
-        @connection = connect(uri, conn_options)
+      def initialize(uri, options = EMPTY_HASH)
+        @connection = connect(uri, options)
         load_extensions(Array(options[:extensions]))
 
-        super(uri, options.reject { |k, _| conn_options.keys.include?(k) })
+        @options = options
+
+        super
 
         self.class.instance = self
       end
@@ -191,8 +197,17 @@ module ROM
           ROM::SQL.load_extensions(db_type)
         end
 
-        extensions = (CONNECTION_EXTENSIONS.fetch(db_type) { [] } + exts).uniq
+        extensions = (CONNECTION_EXTENSIONS.fetch(db_type, EMPTY_ARRAY) + exts).uniq
         connection.extension(*extensions)
+
+        # this will be default in Sequel 5.0.0 and since we don't rely
+        # on dataset mutation it is safe to enable it already
+        connection.extension(:freeze_datasets) unless RUBY_ENGINE == 'rbx'
+      end
+
+      # @api private
+      def transaction_runner(_)
+        ROM::SQL::Transaction.new(connection)
       end
     end
   end

data/lib/rom/sql/migration.rb

@@ -30,13 +30,12 @@ module ROM
     module Migration
       Sequel.extension :migration
 
-      def self.included(klass)
-        super
-        klass.class_eval do
-          option :migrator, reader: true, default: proc { |gateway|
-            Migrator.new(gateway.connection)
-          }
-        end
+      # @api public
+      attr_reader :migrator
+
+      # @api private
+      def initialize(uri, options = EMPTY_HASH)
+        @migrator = options.fetch(:migrator) { Migrator.new(connection) }
       end
 
       # @see ROM::SQL::Migration.pending?

data/lib/rom/sql/migration/migrator.rb

@@ -1,20 +1,19 @@
+require 'pathname'
+require 'rom/types'
+require 'rom/initializer'
+
 module ROM
   module SQL
     module Migration
       class Migrator
-        include Options
+        extend Initializer
 
         DEFAULT_PATH = 'db/migrate'.freeze
         VERSION_FORMAT = '%Y%m%d%H%M%S'.freeze
 
-        option :path, reader: true, default: DEFAULT_PATH
-
-        attr_reader :connection
+        param :connection
 
-        def initialize(connection, options = {})
-          super
-          @connection = connection
-        end
+        option :path, type: ROM::Types.Definition(Pathname), reader: true, default: proc { DEFAULT_PATH }
 
         def run(options = {})
           Sequel::Migrator.run(connection, path.to_s, options)

data/lib/rom/sql/order_dsl.rb

@@ -0,0 +1,20 @@
+require 'rom/sql/dsl'
+require 'rom/sql/expression'
+
+module ROM
+  module SQL
+    class OrderDSL < DSL
+      private
+
+      # @api private
+      def method_missing(meth, *args, &block)
+        if schema.key?(meth)
+          attr = schema[meth]
+          ::ROM::SQL::Expression.new(schema[meth])
+        else
+          ::Sequel::VIRTUAL_ROW.__send__(meth, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/plugin/associates.rb

@@ -1,5 +1,3 @@
-require 'rom/support/deprecations'
-
 module ROM
   module SQL
     module Plugin
@@ -9,51 +7,38 @@ module ROM
       module Associates
         # @api private
         def self.included(klass)
-          klass.extend(ClassMethods)
-          super
-        end
+          klass.class_eval do
+            extend ClassMethods
+            include InstanceMethods
+            defines :associations
 
-        module InstanceMethods
-          attr_reader :assoc, :__registry__
+            associations []
 
-          # @api private
-          def initialize(*)
-            super
-            @__registry__ = relation.__registry__
-            assoc_name, assoc_opts = self.class.associations[0]
-            @assoc =
-              if assoc_opts.any?
-                assoc_opts[:key]
-              else
-                relation.associations[assoc_name]
-              end
+            option :associations, reader: true, optional: true, default: -> cmd { cmd.class.associations }
           end
+          super
+        end
 
+        module InstanceMethods
           # Set fk on tuples from parent tuple
           #
           # @param [Array<Hash>, Hash] tuples The input tuple(s)
           # @param [Hash] parent The parent tuple with its pk already set
           #
-          # @return [Array<Hash>,Hash]
-          #
-          # @overload SQL::Commands::Create#execute
+          # @return [Array<Hash>]
           #
           # @api public
-          def execute(tuples, parent)
+          def associate(tuples, parent, assoc:, keys:)
             input_tuples =
               case assoc
-              when Array
-                fk, pk = assoc
+              when Symbol
+                fk, pk = keys
 
-                input_tuples = with_input_tuples(tuples).map { |tuple|
+                with_input_tuples(tuples).map { |tuple|
                   tuple.merge(fk => parent.fetch(pk))
                 }
-
-                super(input_tuples)
               when Association::ManyToMany
-                new_tuples = super(tuples)
-
-                join_tuples = assoc.associate(__registry__, new_tuples, parent)
+                join_tuples = assoc.associate(__registry__, tuples, parent)
                 join_relation = assoc.join_relation(__registry__)
                 join_relation.multi_insert(join_tuples)
 
@@ -63,22 +48,54 @@ module ROM
 
                 pk_extend = { fk => parent[pk] }
 
-                new_tuples.map { |tuple| tuple.update(pk_extend) }
+                tuples.map { |tuple| tuple.update(pk_extend) }
               when Association
-                input_tuples = with_input_tuples(tuples).map { |tuple|
+                with_input_tuples(tuples).map { |tuple|
                   assoc.associate(relation.__registry__, tuple, parent)
                 }
-                super(input_tuples)
               end
           end
+
+          # @api public
+          def with_association(name, opts = EMPTY_HASH)
+            self.class.build(relation, options.merge(associations: [[name, opts]]))
+          end
+
+          # @api private
+          def __registry__
+            relation.__registry__
+          end
         end
 
         module ClassMethods
-          # @api private
-          def inherited(klass)
-            klass.defines :associations
-            klass.associations []
-            super
+          # @see ROM::Command::ClassInterface.build
+          #
+          # @api public
+          def build(relation, options = EMPTY_HASH)
+            command = super
+            associations = command.associations
+
+            before_hooks = associations.each_with_object([]) do |(name, opts), acc|
+              relation.associations.try(name) do |assoc|
+                unless assoc.is_a?(Association::ManyToMany)
+                  acc << { associate: { assoc: assoc, keys: assoc.join_keys(relation.__registry__) } }
+                else
+                  true
+                end
+              end or acc << { associate: { assoc: name, keys: opts[:key] } }
+            end
+
+            after_hooks = associations.each_with_object([]) do |(name, opts), acc|
+              next unless relation.associations.key?(name)
+
+              assoc = relation.associations[name]
+
+              if assoc.is_a?(Association::ManyToMany)
+                acc << { associate: { assoc: assoc, keys: assoc.join_keys(relation.__registry__) } }
+              end
+            end
+
+            command.before(*before_hooks).after(*after_hooks)
           end
 
           # Set command to associate tuples with a parent tuple using provided keys
@@ -102,17 +119,13 @@ module ROM
           # @option options [Array] :key The association keys
           #
           # @api public
-          def associates(name, options = {})
+          def associates(name, options = EMPTY_HASH)
             if associations.map(&:first).include?(name)
               raise ArgumentError,
-                "#{name} association is already defined for #{self.class}"
+                    "#{name} association is already defined for #{self.class}"
             end
 
-            option :association, reader: true, default: {}
-
-            include InstanceMethods
-
-            associations << [name, options]
+            associations(associations.dup << [name, options])
           end
         end
       end

data/lib/rom/sql/plugin/pagination.rb

@@ -1,20 +1,17 @@
+require 'rom/initializer'
+
 module ROM
   module SQL
     module Plugin
       module Pagination
         class Pager
-          include Options
+          extend Initializer
           include Dry::Equalizer(:dataset, :options)
 
-          option :current_page, reader: true, default: 1
-          option :per_page, reader: true
-
-          attr_reader :dataset
+          param :dataset
 
-          def initialize(dataset, options = {})
-            super
-            @dataset = dataset
-          end
+          option :current_page, reader: true, default: proc { 1 }
+          option :per_page, reader: true
 
           def next_page
             num = current_page + 1
@@ -71,7 +68,7 @@ module ROM
         # @api public
         def page(num)
           next_pager = pager.at(dataset, num)
-          __new__(next_pager.dataset, pager: next_pager)
+          new(next_pager.dataset, pager: next_pager)
         end
 
         # Set limit for pagination
@@ -82,7 +79,7 @@ module ROM
         # @api public
         def per_page(num)
           next_pager = pager.at(dataset, pager.current_page, num)
-          __new__(next_pager.dataset, pager: next_pager)
+          new(next_pager.dataset, pager: next_pager)
         end
       end
     end

data/lib/rom/sql/plugins.rb

@@ -1,10 +1,8 @@
-require 'rom/sql/plugin/assoc_macros'
 require 'rom/sql/plugin/associates'
 require 'rom/sql/plugin/pagination'
 
 ROM.plugins do
   adapter :sql do
-    register :assoc_macros, ROM::SQL::Plugin::AssocMacros, type: :relation
     register :pagination, ROM::SQL::Plugin::Pagination, type: :relation
     register :associates, ROM::SQL::Plugin::Associates, type: :command
   end

data/lib/rom/sql/projection_dsl.rb

@@ -0,0 +1,41 @@
+require 'rom/sql/dsl'
+require 'rom/sql/function'
+
+module ROM
+  module SQL
+    class ProjectionDSL < DSL
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        super || type(name)
+      end
+
+      private
+
+      # @api private
+      def type(identifier)
+        type_name = ::Dry::Core::Inflector.classify(identifier)
+        types.const_get(type_name) if types.const_defined?(type_name)
+      end
+
+      # @api private
+      def types
+        ::ROM::SQL::Types
+      end
+
+      # @api private
+      def method_missing(meth, *args, &block)
+        if schema.key?(meth)
+          schema[meth]
+        else
+          type = type(meth)
+
+          if type
+            ::ROM::SQL::Function.new(type)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end