rom-rails 1.1.0 → 2.3.0

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

@@ -0,0 +1,70 @@
+require 'addressable/uri'
+
+module ROM
+  module Rails
+    module ActiveRecord
+      class UriBuilder
+        def build(adapter, uri_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.
+          if RUBY_ENGINE == 'jruby' && adapter != 'postgresql'
+            uri = "jdbc:#{uri}"
+          end
+
+          uri
+        end
+
+        def sqlite3_uri(config)
+          path = Pathname.new(config.fetch(:root)).join(config.fetch(:database))
+
+          build_uri(
+            scheme: 'sqlite',
+            host: '',
+            path: path.to_s
+          )
+        end
+
+        def postgresql_uri(config)
+          generic_uri(config.merge(
+                        host: config.fetch(:host) { '' },
+                        scheme: 'postgres'
+                      ))
+        end
+
+        def mysql_uri(config)
+          if config.key?(:username) && !config.key?(:password)
+            config.update(password: '')
+          end
+
+          generic_uri(config)
+        end
+
+        def generic_uri(config)
+          build_uri(
+            scheme: config.fetch(:scheme),
+            user: escape_option(config[:username]),
+            password: escape_option(config[:password]),
+            host: config[:host],
+            port: config[:port],
+            path: config[:database]
+          )
+        end
+
+        def build_uri(attrs)
+          Addressable::URI.new(attrs).to_s
+        end
+
+        def escape_option(option)
+          option.nil? ? option : CGI.escape(option)
+        end
+      end
+    end
+  end
+end

data/lib/rom/rails/configuration.rb

@@ -11,7 +11,7 @@ module ROM
       end
 
       config_accessor :auto_registration_paths do
-        []
+        ['app']
       end
     end
   end

data/lib/rom/rails/railtie.rb

@@ -16,20 +16,21 @@ module ROM
 
       # Make `ROM::Rails::Configuration` instance available to the user via
       # `Rails.application.config` before other initializers run.
-      config.before_initialize do |_app|
+      config.before_configuration do |_app|
         config.rom = Configuration.new
       end
 
       initializer 'rom.configure_action_controller' do
         ActiveSupport.on_load(:action_controller) do
           ActionController::Base.send(:include, ControllerExtension)
+          ActionController::API.send(:include, ControllerExtension) if defined?(ActionController::API)
         end
       end
 
       initializer 'rom.adjust_eager_load_paths' do |app|
         paths =
           auto_registration_paths.inject([]) do |result, root_path|
-            result.concat(COMPONENT_DIRS.map { |dir| root_path.join('app', dir).to_s })
+            result.concat(COMPONENT_DIRS.map { |dir| ::Rails.root.join(root_path, dir).to_s })
           end
 
         app.config.eager_load_paths -= paths
@@ -44,6 +45,10 @@ module ROM
         ROM.env = Railtie.create_container
       end
 
+      console do |_app|
+        Railtie.configure_console_logger
+      end
+
       # Behaves like `Railtie#configure` if the given block does not take any
       # arguments. Otherwise yields the ROM configuration to the block.
       #
@@ -73,7 +78,7 @@ module ROM
         configuration = create_configuration
 
         auto_registration_paths.each do |root_path|
-          configuration.auto_registration(root_path.join('app'), namespace: false)
+          configuration.auto_registration(::Rails.root.join(root_path), namespace: false)
         end
 
         ROM.container(configuration)
@@ -81,10 +86,14 @@ module ROM
 
       # @api private
       def gateways
-        config.rom.gateways[:default] ||= infer_default_gateway if active_record?
+        if active_record?
+          load_active_record_config.each do |name, spec|
+            config.rom.gateways[name] ||= [:sql, spec[:uri], spec[:options]]
+          end
+        end
 
         if config.rom.gateways.empty?
-          Rails.logger.warn "It seems that you have not configured any gateways"
+          ::Rails.logger.warn "It seems that you have not configured any gateways"
 
           config.rom.gateways[:default] = [ :memory, "memory://test" ]
         end
@@ -92,13 +101,9 @@ module ROM
         config.rom.gateways
       end
 
-      # If there's no default gateway configured, try to infer it from
-      # other sources, e.g. ActiveRecord.
-      #
-      # @api private
-      def infer_default_gateway
-        spec = ROM::Rails::ActiveRecord::Configuration.call
-        [:sql, spec[:uri], spec[:options]]
+      # Attempt to infer all configured gateways from activerecord
+      def load_active_record_config
+        ROM::Rails::ActiveRecord::Configuration.new.call
       end
 
       def load_initializer
@@ -129,6 +134,19 @@ module ROM
       def active_record?
         defined?(::ActiveRecord)
       end
+
+      # @api private
+      def std_err_out_logger?
+        ActiveSupport::Logger.logger_outputs_to?(::Rails.logger, STDERR, STDOUT)
+      end
+
+      # @api private
+      def configure_console_logger
+        return if active_record? || std_err_out_logger?
+
+        console = ActiveSupport::Logger.new(STDERR)
+        ::Rails.logger.extend ActiveSupport::Logger.broadcast console
+      end
     end
   end
 end

data/lib/rom/rails/tasks/db.rake

@@ -1,3 +1,9 @@
+begin
+  require "rom/sql/rake_task"
+rescue LoadError
+  # rom-sql is optional
+end
+
 namespace :db do
   desc 'Set up ROM gateways'
   task :setup do

data/lib/rom/rails/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module Rails
-    VERSION = '1.1.0'.freeze
+    VERSION = '2.3.0'.freeze
   end
 end

data/rom-rails.gemspec

@@ -1,13 +1,12 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rom/rails/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "rom-rails"
   spec.version       = ROM::Rails::VERSION.dup
-  spec.authors       = ["Piotr Solnica"]
-  spec.email         = ["piotr.solnica@gmail.com"]
+  spec.authors       = ["Chris Flipse", "Piotr Solnica"]
+  spec.email         = ["cflipse@gmail.com", "piotr.solnica@gmail.com"]
   spec.summary       = 'Integrate Ruby Object Mapper with Rails'
   spec.homepage      = "http://rom-rb.org"
   spec.license       = "MIT"
@@ -17,14 +16,14 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'rom', '~> 4.0'
-  spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
-  spec.add_runtime_dependency 'dry-core', '~> 0.3'
   spec.add_runtime_dependency 'addressable', '~> 2.3'
-  spec.add_runtime_dependency 'railties', '>= 3.0', '< 6.0'
+  spec.add_runtime_dependency 'dry-core', '~> 0.4'
+  spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
+  spec.add_runtime_dependency 'railties', '>= 3.0', '< 6.2'
+  spec.add_runtime_dependency 'rom', '~> 5.2'
 
-  spec.add_development_dependency "rom-repository"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rom-repository"
   spec.add_development_dependency "rubocop", "~> 0.50"
 end

data/spec/dummy/app/commands/create_user.rb

@@ -6,5 +6,4 @@ class CreateUser < ROM::Commands::Create[:sql]
   use :timestamps
 
   timestamp :created_at
-
 end

data/spec/dummy/app/forms/user_form.rb

@@ -25,11 +25,10 @@ class UserForm
   end
 
   def persisted?
-    !!id
+    id.present?
   end
 
   def self.model_name
     ActiveModel::Name.new(User)
   end
-
 end

data/spec/dummy/app/relations/dummy_relation.rb

@@ -1,5 +1,5 @@
 class DummyRelation < ROM::Relation[:test_adapter]
-  gateway :test
+  gateway :default
 
   schema(:dummy, infer: true)
 end

data/spec/dummy/app/relations/tasks.rb

@@ -1,4 +1,5 @@
 class Tasks < ROM::Relation[:sql]
+  gateway :sql
   schema(:tasks, infer: true)
 
   def by_id(id)

data/spec/dummy/app/relations/users.rb

@@ -1,4 +1,5 @@
 class Users < ROM::Relation[:sql]
+  gateway :sql
   schema(:users, infer: true)
 
   def by_id(id)

data/spec/dummy/bin/bundle

@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
 load Gem.bin_path('bundler', 'bundle')

data/spec/dummy/bin/rails

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
-APP_PATH = File.expand_path('../../config/application', __FILE__)
+APP_PATH = File.expand_path('../config/application', __dir__)
 require_relative '../config/boot'
 require 'rails/commands'

data/spec/dummy/config/initializers/rom.rb

@@ -1,6 +1,7 @@
 ROM::Rails::Railtie.configure do |config|
   scheme = RUBY_ENGINE == 'jruby' ? 'jdbc:sqlite' : 'sqlite'
-  config.gateways[:default] = [:sql, "#{scheme}://#{Rails.root}/db/#{Rails.env}.sqlite3"]
-  config.gateways[:test] = [:test_adapter, foo: :bar]
-  config.auto_registration_paths += [Rails.root.join('lib', 'additional_app')]
+  config.gateways[:arro] = [:test_adapter, uri: 'http://example.org' ]
+  config.gateways[:sql] = [:sql, "#{scheme}://#{Rails.root}/db/#{Rails.env}.sqlite3"]
+  config.gateways[:default] = [:test_adapter, foo: :bar]
+  config.auto_registration_paths += [Rails.root.join('lib', 'additional_app', 'persistence')]
 end

data/spec/dummy/lib/rom/test_adapter.rb

@@ -6,6 +6,7 @@ module ROM
 
     class Gateway < ROM::Gateway
       include Dry::Equalizer(:args)
+      adapter :test_adapter
 
       attr_reader :args, :datasets
 

data/spec/integration/controller_extensions_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe "including controller extensions" do
+  describe "An application controller" do
+    let(:controller) do
+      Class.new(ActionController::Base)
+    end
+
+    it "includes the controller extensions" do
+      expect(controller.ancestors).to include(ROM::Rails::ControllerExtension)
+    end
+  end
+
+  if defined?(ActionController::API)
+    describe "An API controller" do
+      let(:controller) do
+        Class.new(ActionController::API)
+      end
+
+      it "includes the controller extensions" do
+        expect(controller.ancestors).to include(ROM::Rails::ControllerExtension)
+      end
+    end
+  end
+end

data/spec/integration/initializer_spec.rb

@@ -3,7 +3,7 @@ RSpec.describe 'ROM initializer' do
     gateway = ROM::TestAdapter::Gateway.new(foo: :bar)
     relation = DummyRelation.new([])
 
-    expect(rom.gateways[:test]).to eql(gateway)
+    expect(rom.gateways[:default]).to eql(gateway)
     expect(rom.relations.dummy).to eql(relation)
   end
 

data/spec/integration/user_commands_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe 'User commands' do
       relation = rom.relations[:users]
       relation.insert(name: 'Piotr', email: 'piotr@test.com')
 
-      expect{ 
+      expect {
         users.delete.by_name('Piotr').call
       }.to change(relation, :count).by(-1)
     end

data/spec/lib/active_record/configuration_spec.rb

@@ -1,15 +1,19 @@
 require 'rom/rails/active_record/configuration'
+require 'active_record'
+require 'active_record/database_configurations' if Rails::VERSION::MAJOR >= 6
 
 RSpec.describe ROM::Rails::ActiveRecord::Configuration do
   let(:root) { Pathname.new('/path/to/app') }
 
+  subject(:configuration) { described_class.new(root: root) }
+
   def uri_for(config)
     result = read(config)
     result.is_a?(Hash) ? result[:uri] : result
   end
 
   def read(config)
-    described_class.build(config.merge(root: root))
+    configuration.build(config)
   end
 
   def parse(uri)
@@ -112,6 +116,88 @@ RSpec.describe ROM::Rails::ActiveRecord::Configuration do
 
         expect(read(config)).to eq uri: expected_uri, options: { pool: 5 }
       end
+
+      it 'handles special characters in username and password' do
+        config = {
+          pool: 5,
+          adapter: 'mysql2',
+          username: 'r@o%ot',
+          password: 'p@ssw0rd#',
+          database: 'database',
+          host: 'example.com'
+        }
+
+        expected_uri = 'mysql2://r%40o%25ot:p%40ssw0rd%23@example.com/database'
+        expected_uri = "jdbc:#{expected_uri}" if RUBY_ENGINE == 'jruby'
+
+        expect(read(config)).to eq uri: expected_uri, options: { pool: 5 }
+      end
+    end
+  end
+
+  if Rails::VERSION::MAJOR >= 6
+    context "with an activerecord 6 configuration" do
+      subject(:configuration) { described_class.new(root: root, configurations: railsconfig, env: "test") }
+      let(:railsconfig) { ActiveRecord::DatabaseConfigurations.new(config_file) }
+
+      context "with only a single database" do
+        let(:config_file) {
+          {
+            test: {
+              adapter: 'mysql',
+              host: 'example.com',
+              database: 'test',
+              username: 'user',
+              encoding: 'utf8'
+            }
+          }
+        }
+
+        it "returns the default hash" do
+          expected_uri = uri_for(config_file[:test])
+          expect(configuration.call[:default]).to match(uri: expected_uri, options: { encoding: 'utf8' })
+        end
+      end
+
+      context "with multiple configured databases" do
+        let(:config_file) {
+          {
+            test: {
+              reader: {
+                adapter: 'mysql',
+                host: 'example.com',
+                database: 'test_reader',
+                username: 'user',
+                encoding: 'utf8'
+              },
+              writer: {
+                adapter: 'mysql',
+                host: 'write.example.com',
+                database: 'test_writer',
+                username: 'user',
+                encoding: 'utf8'
+              }
+            }
+          }
+        }
+
+        it "configures the first database as the default" do
+          expected_uri = uri_for(config_file[:test][:reader])
+          expect(configuration.call[:default]).to match(uri: expected_uri, options: {encoding: 'utf8'})
+        end
+
+        it "returns each configured database" do
+          options = { encoding: 'utf8' }
+          expected_reader_uri = uri_for(config_file[:test][:reader])
+          expected_writer_uri = uri_for(config_file[:test][:writer])
+
+          expect(configuration.call).to include(
+            reader: { uri: expected_reader_uri, options: options },
+            writer: { uri: expected_writer_uri, options: options }
+          )
+        end
+      end
     end
+
   end
 end