rom-rails 1.1.0 → 2.3.0

data/README.md

@@ -1,6 +1,5 @@
 [gem]: https://rubygems.org/gems/rom-rails
-[travis]: https://travis-ci.org/rom-rb/rom-rails
-[gemnasium]: https://gemnasium.com/rom-rb/rom-rails
+[actions]: https://github.com/rom-rb/rom-rails/actions
 [codeclimate]: https://codeclimate.com/github/rom-rb/rom-rails
 [coveralls]: https://coveralls.io/r/rom-rb/rom-rails
 [inchpages]: http://inch-ci.org/github/rom-rb/rom-rails
@@ -8,8 +7,7 @@
 # rom-rails
 
 [![Gem Version](https://badge.fury.io/rb/rom-rails.svg)][gem]
-[![Build Status](https://travis-ci.org/rom-rb/rom-rails.svg?branch=master)][travis]
-[![Dependency Status](https://gemnasium.com/rom-rb/rom-rails.svg)][gemnasium]
+[![CI Status](https://github.com/rom-rb/rom-rails/workflows/ci/badge.svg)][actions]
 [![Code Climate](https://codeclimate.com/github/rom-rb/rom-rails/badges/gpa.svg)][codeclimate]
 [![Test Coverage](https://codeclimate.com/github/rom-rb/rom-rails/badges/coverage.svg)][codeclimate]
 [![Inline docs](http://inch-ci.org/github/rom-rb/rom-rails.svg?branch=master)][inchpages]
@@ -34,7 +32,7 @@ To run tests:
 You can read more about ROM and Rails on the official website:
 
 * [Introduction to ROM](http://rom-rb.org/learn/)
-* [Rails setup](http://rom-rb.org/learn/getting-started/rails-setup/)
+* [Rails setup](http://rom-rb.org/learn/rails/)
 
 
 ## Community

data/Rakefile

@@ -3,7 +3,7 @@ require 'rubocop/rake_task'
 
 task default: %w(app:spec rubocop)
 
-APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
 load 'rails/tasks/engine.rake'
 
 RuboCop::RakeTask.new do |task|

data/docsite/source/index.html.md

@@ -0,0 +1,165 @@
+---
+position: 3
+chapter: Rails
+title: Setup
+---
+
+Rails integration is provided by [rom-rails](https://github.com/rom-rb/rom-rails) project. Simply add it to your Gemfile:
+
+``` ruby
+gem 'rom-rails'
+```
+
+## Configuring Railtie
+
+Create a rom initializer:
+
+``` ruby
+# config/initializers/rom.rb
+ROM::Rails::Railtie.configure do |config|
+  config.gateways[:default] = [:sql, ENV.fetch('DATABASE_URL')]
+end
+```
+
+You can provide additional adapter-specific options, for example you can enable specific sql plugins for postgres:
+
+``` ruby
+# config/initializers/rom.rb
+ROM::Rails::Railtie.configure do |config|
+  config.gateways[:default] = [:sql,
+    ENV.fetch('DATABASE_URL'), extensions: [:pg_hstore]
+  ]
+end
+```
+
+You can also provide a list of relations that should not be inferred from your schema automatically:
+
+``` ruby
+# config/initializers/rom.rb
+ROM::Rails::Railtie.configure do |config|
+  config.gateways[:default] = [:sql,
+    ENV.fetch('DATABASE_URL'), not_inferrable_relations: [:schema_migrations]
+  ]
+end
+```
+
+## Migration Tasks
+
+The railtie provides rake tasks for managing your database schema. You need to enable them in your `Rakefile`:
+
+``` ruby
+require 'rom/sql/rake_task'
+```
+
+After that, you have access to following tasks:
+
+* `rake db:create_migration[migration_name]` - creates a new migration file
+* `rake db:migrate` - runs pending migrations
+* `rake db:clean` - cleans the database
+* `rake db:reset` - drops tables and re-runs migrations
+
+## Accessing Container
+
+In Rails environment ROM container is accessible via `ROM.env`:
+
+``` ruby
+ROM.env # returns the container
+```
+
+In your controllers you can access ROM container by `rom` variable:
+
+``` ruby
+class UsersController < ApplicationController
+  def show
+    @user = rom.relation(:users).by_id(params[:id]).one
+  end
+end
+```
+
+^WARNING
+Accessing the global container directly is considered as a bad practice. The recommended way is to use a DI mechanism to inject specific ROM components as dependencies into your objects.
+
+For example you can use [dry-container](https://github.com/dryrb/dry-container) and [dry-auto_inject](https://github.com/dryrb/dry-auto_inject) to define your own application container and specify dependencies there to have them automatically injected.
+
+See [rom-rails-skeleton](https://github.com/solnic/rom-rails-skeleton) for an example of such setup.
+^
+
+## Defining Relations
+
+Relation class definitions are automatically loaded from `app/relations`. The following code defines a `users` relation for the `:sql` adapter:
+
+``` ruby
+class Users < ROM::Relation[:sql]
+  # some methods
+end
+
+# access registered relation via container
+ROM.env.relations[:users]
+```
+
+## Defining Commands
+
+Command class definitions are automatically loaded from `app/commands`. The following code defines a command which inserts data into `users` relation:
+
+``` ruby
+# app/commands/create_user.rb
+class CreateUser < ROM::Commands::Create[:sql]
+  relation :users
+  register_as :create
+  result :one
+end
+
+# access registered relation via container
+ROM.env.commands[:users][:create]
+```
+
+## Defining Custom Mappers
+
+If you want to use custom mappers you can place them under `app/mappers`:
+
+``` ruby
+# app/mappers/user_mapper.rb
+class UserMapper < ROM::Mapper
+  relation :users
+
+  # some mapping logic
+end
+```
+
+## Running alongside ActiveRecord
+
+There might be some cases where you will want to run ROM alongside ActiveRecord. Since ROM is designed to work independently, you will need to take few additional steps. ROM creates its own connections and Rails above version 5 won't allow you to drop the database since there are active connections on it.
+
+``` ruby
+# lib/tasks/db.rake
+task :remove_rom_connection => [:environment] do
+  ROM.env && ROM.env.disconnect
+end
+
+Rake::Task["db:drop"].clear_prerequisites()
+Rake::Task["db:drop"].enhance [:remove_rom_connection, :load_config, :check_protected_environments]
+
+Rake::Task["db:reset"].clear_prerequisites()
+Rake::Task["db:reset"].enhance [:remove_rom_connection, "db:drop", "db:setup"]
+```
+
+Since migrations (and other) tasks require environment, ROM will be loaded and will throw an exception, because relations will try to load tables before migrations have actually run. We know this is an ugly solution, but we are working hard to solve this case. This monkey patch will give you reasonable information to act upon if the necessity arises.
+
+``` ruby
+# config/initializers/rom_monkey.rb
+module ROM
+  module Rails
+    class Railtie < ::Rails::Railtie
+      alias_method :create_container!, :create_container
+      def create_container
+        begin
+          create_container!
+        rescue => e
+          puts "Container failed to initialize because of #{e.inspect}"
+          puts "This message comes from the monkey patch in #{__FILE__}, if you are using rake, then this is fine"
+        end
+      end
+    end
+  end
+end
+```

data/lib/generators/rom.rb

@@ -18,6 +18,14 @@ module ROM
           __FILE__
         )
       end
+
+      def self.default_gateway
+        ROM.env.gateways[:default]
+      end
+
+      def self.default_adapter
+        (default_gateway && default_gateway.adapter)
+      end
     end
   end
 end

data/lib/generators/rom/commands/templates/create.rb.erb

@@ -3,9 +3,7 @@ class Create<%= model_name %> < ROM::Commands::Create<%= "[:#{adapter}]" %>
   register_as :create
   result :one
 
-<% if adapter.to_sym == :sql -%>
   # set Timestamp plugin
   # use :timestamps
   # timestamp :created_at, :updated_at
-<% end -%>
 end

data/lib/generators/rom/commands/templates/delete.rb.erb

@@ -2,5 +2,4 @@ class Delete<%= model_name %> < ROM::Commands::Delete<%= "[:#{adapter}]" %>
   relation :<%= relation %>
   register_as :delete
   result :one
-
 end

data/lib/generators/rom/commands/templates/update.rb.erb

@@ -3,9 +3,7 @@ class Update<%= model_name %> < ROM::Commands::Update<%= "[:#{adapter}]" %>
   register_as :update
   result :one
 
-<% if adapter.to_sym == :sql -%>
   # set Timestamp plugin
   # use :timestamps
   # timestamp :updated_at
-<% end -%>
 end

data/lib/generators/rom/commands_generator.rb

@@ -6,7 +6,7 @@ module ROM
       class_option :adapter,
         banner: "--adapter=adapter",
         desc: "specify an adapter to use", required: true,
-        default: ROM.adapters.keys.first
+        default: default_adapter
 
       def create_create_command
         template 'create.rb.erb', command_file(:create)

data/lib/generators/rom/install/templates/application_model.rb

@@ -1,10 +1,10 @@
-require 'types'
+require "types"
 
 class ApplicationModel < ROM::Struct
   def self.inherited(base)
     super
 
-    base.constructor_type :schema
+    base.transform_types(&:omittable)
 
     base.extend ActiveModel::Naming
     base.include ActiveModel::Conversion

data/lib/generators/rom/install/templates/initializer.rb.erb

@@ -1,3 +1,3 @@
 ROM::Rails::Railtie.configure do |config|
-  config.gateways[:default] = [:<%= adapter %>, ENV.fetch('DATABASE_URL')]
+  # config.gateways[:default] = [:<%= adapter %>, ENV.fetch('DATABASE_URL')]
 end

data/lib/generators/rom/install/templates/types.rb

@@ -1,9 +1,9 @@
-require 'dry/types'
+require "dry/types"
 
 module Types
-  include Dry::Types.module
+  include Dry.Types
 
-  ID = Coercible::Int.optional.meta(primary_key: true)
+  ID = Coercible::Integer.optional.meta(primary_key: true)
 
   # Include your own type definitions and coersions here.
   # See http://dry-rb.org/gems/dry-types

data/lib/generators/rom/install_generator.rb

@@ -8,7 +8,7 @@ module ROM
       end
 
       def self.source_root
-        File.expand_path("../install/templates", __FILE__)
+        File.expand_path('install/templates', __dir__)
       end
 
       class_option :adapter,
@@ -29,14 +29,11 @@ module ROM
         copy_file "application_model.rb", "app/models/application_model.rb"
       end
 
-
-
     private
 
       def adapter
         options[:adapter].to_sym
       end
-
     end
   end
 end

data/lib/generators/rom/relation_generator.rb

@@ -6,7 +6,7 @@ module ROM
       class_option :adapter,
         banner: "--adapter=adapter",
         desc: "specify an adapter to use", required: true,
-        default: ROM.adapters.keys.first
+        default: default_adapter
 
       class_option :gateway,
         banner: "--gateway=repo",

data/lib/generators/rom/repository/templates/repository.rb.erb

@@ -4,4 +4,12 @@ class <%= model_name %>Repository < ROM::Repository::Root
   commands :create, update: :by_pk, delete: :by_pk
 
   struct_namespace <%= struct_namespace %>
+
+  def by_id(id)
+    root.by_pk(id).one
+  end
+
+  def all
+    root.to_a
+  end
 end

data/lib/generators/rom/repository_generator.rb

@@ -4,11 +4,10 @@ if defined? ROM::Repository
   module ROM
     module Generators
       class RepositoryGenerator < Base
-
         class_option :namespace,
           banner: '--namespace=namespace',
           desc: "specify a struct namespace for the relation", required: true,
-          default: ::Rails.application.class.name.split("::").first 
+          default: ::Rails.application.class.name.split("::").first
 
         def create_repository_file
           template(

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

@@ -1,4 +1,4 @@
-require 'addressable/uri'
+require_relative 'uri_builder'
 
 module ROM
   module Rails
@@ -17,15 +17,43 @@ module ROM
           :host
         ].freeze
 
+        attr_reader :configurations
+        attr_reader :env
+        attr_reader :root
+        attr_reader :uri_builder
+
+        def initialize(env: ::Rails.env, root: ::Rails.root, configurations: ::ActiveRecord::Base.configurations)
+          @configurations = configurations
+          @env  = env
+          @root = root
+
+          @uri_builder = ROM::Rails::ActiveRecord::UriBuilder.new
+        end
+
         # Returns gateway 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))
+        def call
+          specs = { default: build(default_configuration.symbolize_keys) }
+
+          if rails6?
+            configurations.configs_for(env_name: env).each do |config|
+              specs[config.spec_name.to_sym] = build(config.config.symbolize_keys)
+            end
+          end
+
+          specs
+        end
+
+        def default_configuration
+          if rails6?
+            configurations.default_hash(env)
+          else
+            configurations.fetch(env)
+          end
         end
 
         # Builds a configuration hash from a flat database config hash.
@@ -38,64 +66,22 @@ module ROM
         # @return [Hash]
         #
         # @api private
-        def self.build(config)
+        def build(config)
           adapter = config.fetch(:adapter)
-          uri_options = config.except(:adapter).merge(scheme: adapter)
+          uri_options = config.except(:adapter).merge(
+            root: root,
+            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.
-          if RUBY_ENGINE == 'jruby' && adapter != 'postgresql'
-            uri = "jdbc:#{uri}"
-          end
-
+          uri = uri_builder.build(adapter, uri_options)
           { 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
+        private
 
-        def self.build_uri(attrs)
-          Addressable::URI.new(attrs).to_s
+        def rails6?
+          ::ActiveRecord::VERSION::MAJOR >= 6
         end
       end
     end