rom-rails 0.2.1 → 0.3.0.beta1

data/lib/rom/rails/active_record/configuration.rb

@@ -0,0 +1,105 @@
+require 'addressable/uri'
+
+module ROM
+  module Rails
+    module ActiveRecord
+      # A helper class to derive `rom-sql` configuration from ActiveRecord.
+      #
+      # @private
+      class Configuration
+        BASE_OPTIONS = [
+          :root,
+          :adapter,
+          :database,
+          :password,
+          :username,
+          :hostname,
+          :root
+        ].freeze
+
+        # Returns repository configuration for the current environment.
+        #
+        # @note This relies on ActiveRecord being initialized already.
+        # @param [Rails::Application]
+        #
+        # @api private
+        def self.call
+          configuration = ::ActiveRecord::Base.configurations.fetch(::Rails.env)
+          build(configuration.symbolize_keys.update(root: ::Rails.root))
+        end
+
+        # Builds a configuration hash from a flat database config hash.
+        #
+        # This is used to support typical database.yml-complaint configs. It
+        # also uses adapter interface for things that are adapter-specific like
+        # handling schema naming.
+        #
+        # @param [Hash,String]
+        # @return [Hash]
+        #
+        # @api private
+        def self.build(config)
+          adapter = config.fetch(:adapter)
+          uri_options = config.except(:adapter).merge(scheme: adapter)
+          other_options = config.except(*BASE_OPTIONS)
+
+          builder_method = :"#{adapter}_uri"
+          uri = if respond_to?(builder_method)
+                  send(builder_method, uri_options)
+                else
+                  generic_uri(uri_options)
+                end
+
+          # JRuby connection strings require special care.
+          uri = if RUBY_ENGINE == 'jruby' && adapter != 'postgresql'
+                  "jdbc:#{uri}"
+                else
+                  uri
+                end
+
+          { uri: uri, options: other_options }
+        end
+
+        def self.sqlite3_uri(config)
+          path = Pathname.new(config.fetch(:root)).join(config.fetch(:database))
+
+          build_uri(
+            scheme: 'sqlite',
+            host: '',
+            path: path.to_s
+          )
+        end
+
+        def self.postgresql_uri(config)
+          generic_uri(config.merge(
+            host: config.fetch(:host) { '' },
+            scheme: 'postgres'
+          ))
+        end
+
+        def self.mysql_uri(config)
+          if config.key?(:username) && !config.key?(:password)
+            config.update(password: '')
+          end
+
+          generic_uri(config)
+        end
+
+        def self.generic_uri(config)
+          build_uri(
+            scheme: config.fetch(:scheme),
+            user: config[:username],
+            password: config[:password],
+            host: config[:host],
+            port: config[:port],
+            path: config[:database]
+          )
+        end
+
+        def self.build_uri(attrs)
+          Addressable::URI.new(attrs).to_s
+        end
+      end
+    end
+  end
+end

data/lib/rom/rails/configuration.rb

@@ -1,34 +1,11 @@
+require 'virtus'
+
 module ROM
   module Rails
     class Configuration
-      attr_reader :config, :setup, :env
-
-      def self.build(app)
-        config = app.config.database_configuration[::Rails.env].
-          symbolize_keys.update(root: app.config.root)
-
-        new(ROM::Config.build(config))
-      end
-
-      def initialize(config)
-        @config = config
-      end
-
-      def setup!
-        @setup = ROM.setup(@config.symbolize_keys)
-      end
-
-      def load!
-        Railtie.load_all
-      end
+      include Virtus.model(strict: true)
 
-      def finalize!
-        # rescuing fixes the chicken-egg problem where we have a relation
-        # defined but the table doesn't exist yet
-        @env = ROM.finalize.env
-      rescue Registry::ElementNotFoundError => e
-        warn "Skipping ROM setup => #{e.message}"
-      end
+      attribute :repositories, Hash, default: {}
     end
   end
 end

data/lib/rom/rails/model/form.rb

@@ -0,0 +1,59 @@
+require 'rom/rails/model/form/dsl'
+
+module ROM
+  module Model
+    class Form
+      include Equalizer.new(:params, :model, :result)
+
+      extend ROM::ClassMacros
+      extend Form::DSL
+
+      defines :relation
+
+      attr_reader :params, :model, :result
+
+      delegate :model_name, :persisted?, :to_key, to: :model
+      alias_method :to_model, :model
+
+      class << self
+        delegate :model_name, to: :params
+      end
+
+      def initialize(params = {}, options = {})
+        @params = params
+        @model  = self.class.model.new(params.merge(options.slice(*self.class.key)))
+        @result = nil
+        @errors =  ActiveModel::Errors.new([])
+        options.each { |key, value| instance_variable_set("@#{key}", value) }
+      end
+
+      def commit!
+        raise NotImplementedError, "#{self.class}#commit! must be implemented"
+      end
+
+      def save(*args)
+        @result = commit!(*args)
+        self
+      end
+
+      def success?
+        errors.nil? || !errors.any?
+      end
+
+      def validate!
+        validator = self.class::Validator.new(attributes)
+        validator.validate
+
+        @errors = validator.errors
+      end
+
+      def attributes
+        self.class.params[params]
+      end
+
+      def errors
+        (result && result.error) || @errors
+      end
+    end
+  end
+end

data/lib/rom/rails/model/form/dsl.rb

@@ -0,0 +1,173 @@
+module ROM
+  module Model
+    class Form
+      module DSL
+        attr_reader :params, :validator, :self_commands, :injectible_commands,
+          :model, :input_block, :validations_block
+
+        def inherited(klass)
+          klass.inject_commands_for(*injectible_commands) if injectible_commands
+          klass.commands(*self_commands) if self_commands
+          klass.input(readers: false, &input_block) if input_block
+          klass.validations(&validations_block) if validations_block
+          super
+        end
+
+        def commands(names)
+          names.each { |relation, _action| attr_reader(relation) }
+          @self_commands = names
+          self
+        end
+
+        def key(*keys)
+          if keys.any? && !@key
+            @key = keys
+            attr_reader(*keys)
+          elsif !@key
+            @key = [:id]
+            attr_reader :id
+          elsif keys.any?
+            @key = keys
+          end
+          @key
+        end
+
+        def input(options = {}, &block)
+          readers = options.fetch(:readers) { true }
+          define_params!(block)
+          define_attribute_readers! if readers
+          define_model!
+          self
+        end
+
+        def validations(&block)
+          define_validator!(block)
+          self
+        end
+
+        def inject_commands_for(*names)
+          @injectible_commands = names
+          names.each { |name| attr_reader(name) }
+          self
+        end
+
+        def build(input = {}, options = {})
+          new(clear_input(input), options.merge(command_registry))
+        end
+
+        def command_registry
+          @command_registry ||= setup_command_registry
+        end
+
+        def clear_input(input)
+          input.each_with_object({}) { |(key, value), object|
+            next if value.is_a?(String) && value.blank?
+
+            object[key] =
+              if value.is_a?(Hash)
+                clear_input(value)
+              elsif value.is_a?(Array)
+                value.map { |v| v.is_a?(Hash) ? clear_input(v) : v }
+              else
+                value
+              end
+          }.symbolize_keys
+        end
+
+        def define_params!(block)
+          @input_block = block
+          @params = ClassBuilder.new(name: "#{name}::Params", parent: Object).call { |klass|
+            klass.send(:include, ROM::Model::Params)
+          }
+          @params.class_eval(&block)
+          const_set(:Params, @params)
+        end
+
+        def define_attribute_readers!
+          @params.attribute_set.each do |attribute|
+            if public_instance_methods.include?(attribute.name)
+              raise(
+                ArgumentError,
+                "#{attribute.name} attribute is in conflict with #{self}##{attribute.name}"
+              )
+            end
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{attribute.name}
+                params[:#{attribute.name}]
+              end
+            RUBY
+          end
+        end
+
+        def define_model!
+          @model = ClassBuilder.new(name: "#{name}::Model", parent: @params).call { |klass|
+            klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def persisted?
+                to_key.any?
+              end
+
+              def to_key
+                to_h.values_at(#{key.map(&:inspect).join(', ')}).compact
+              end
+            RUBY
+          }
+          key.each { |name| @model.attribute(name) }
+          const_set(:Model, @model)
+        end
+
+        def define_validator!(block)
+          @validations_block = block
+          @validator = ClassBuilder.new(name: "#{name}::Validator", parent: Object).call { |klass|
+            klass.send(:include, ROM::Model::Validator)
+          }
+          @validator.class_eval(&block)
+          const_set(:Validator, @validator)
+        end
+
+        private
+
+        def rom
+          ROM.env
+        end
+
+        def adapter
+          ROM.adapters.keys.first
+        end
+
+        def setup_command_registry
+          commands = {}
+
+          if self_commands
+            self_commands.each do |rel_name, name|
+              command = build_command(name, rel_name)
+              commands[rel_name] = CommandRegistry.new(name => command)
+            end
+          end
+
+          if injectible_commands
+            injectible_commands.each do |relation|
+              commands[relation] = rom.command(relation)
+            end
+          end
+
+          commands
+        end
+
+        def build_command(name, rel_name)
+          klass = Command.build_class(name, rel_name, adapter: adapter)
+
+          klass.result :one
+          klass.input @params
+          klass.validator @validator
+
+          relation = rom.relations[rel_name]
+          repository = rom.repositories[relation.repository]
+          repository.extend_command_class(klass, relation.dataset)
+
+          klass.build(relation)
+        end
+      end
+    end
+  end
+end

data/lib/rom/rails/model/params.rb

@@ -0,0 +1,72 @@
+require 'virtus'
+require 'active_model/conversion'
+
+module ROM
+  module Model
+    # Mixin for validatable and coercible parameters
+    #
+    # @example
+    #
+    #   class UserParams
+    #     include ROM::Model::Params
+    #
+    #     attribute :email, String
+    #     attribute :age, Integer
+    #
+    #     validates :email, :age, presence: true
+    #   end
+    #
+    #   user_params = UserParams.new(email: '', age: '18')
+    #
+    #   user_params.email # => ''
+    #   user_params.age # => 18
+    #
+    #   user_params.valid? # => false
+    #   user_params.errors # => #<ActiveModel::Errors:0x007fd2423fadb0 ...>
+    #
+    # @api public
+    module Params
+      VirtusModel = Virtus.model(strict: true, required: false)
+
+      def self.included(base)
+        base.class_eval do
+          include VirtusModel
+          include ActiveModel::Conversion
+        end
+        base.extend(ClassMethods)
+      end
+
+      def model_name
+        self.class.model_name
+      end
+
+      module ClassMethods
+        DEFAULT_TIMESTAMPS = [:created_at, :updated_at].freeze
+
+        def [](input)
+          input.is_a?(self) ? input : new(input)
+        end
+
+        def set_model_name(name)
+          class_eval <<-RUBY
+            def self.model_name
+              @model_name ||= ActiveModel::Name.new(self, nil, #{name.inspect})
+            end
+          RUBY
+        end
+
+        def timestamps(*attrs)
+          if attrs.empty?
+            DEFAULT_TIMESTAMPS.each do |t|
+              attribute t, DateTime, default: proc { DateTime.now }
+            end
+          else
+            attrs.each do |attr|
+              attribute attr, DateTime, default: proc { DateTime.now }
+            end
+          end
+        end
+      end
+    end
+  end
+end