rom-roda 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2a2b37009c1e6d3b9bd3bb8895d531ad3428ee1
-  data.tar.gz: 25463288f42e47240460faeb43b7d2b65b822c68
+  metadata.gz: 7e861bfecc7fde3d430801f8b00322a40882cdb0
+  data.tar.gz: c948e4e5150d773338385794726a20f4e24fbf1b
 SHA512:
-  metadata.gz: d9ef17fbe99c4d04775bed831c976997d5f9dc7abe68941be63b49d7feb6b6784903e4f5b480bea8c94c53efd6523d5ff06c3cb7cedd731e2f3dc405ad38507d
-  data.tar.gz: bc4ac81939e20bf024f708ac17f118d1a073f949e066c3d22314bc7d9acc7b9b53c32efbad650e1d449c372bdf4b3d7ffe89743c816e67ef66effe08e2edbe87
+  metadata.gz: 7d1b5003d145863a943b467f9d78d5c9e08cce5af73e4766887544d314c5988a06daba0f28e4f7a0feb13c59b180045b0470366e0a84a817c313781b3a57f4fb
+  data.tar.gz: b6bcc32532e979d73434bd107d132e6875a8432c281017b1f26ad1f139dc7bc99b2c6a78d8c76fc06d3b4a0a8c025913f5e218b33e46f0120084563955499752

data/.gitignore

@@ -9,6 +9,7 @@ InstalledFiles
 _yardoc
 coverage
 doc/
+vendor/
 lib/bundler/man
 pkg
 rdoc

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## v0.2.0 2015-08-19
+
+## Added
+
+- Support for multi-envs (AMHOL)
+
+## Changed
+
+- Updated to work with ROM 0.9.0 and `auto_registration` plugin (AMHOL)
+
+## v0.1.1 2015-07-13
+
+TODO
+
+## v0.1.0 2015-07-13
+
+TODO
+
 ## v0.0.2 2015-04-05
 
 - Hook `ROM.finalize` into `Roda.freeze` so that ROM environment is sealed at the same time as the Roda app.

data/README.md

@@ -4,7 +4,7 @@ Roda plugin for [Ruby Object Mapper](https://github.com/rom-rb/rom).
 
 ## Issues
 
-Please report any issues in the main [rom-rb/rom](https://github.com/rom-rb/rom/issues) issue tracker.
+Please report any issues in the [issue tracker](https://github.com/rom-rb/rom-roda/issues/new).
 
 ## Usage
 
@@ -21,17 +21,29 @@ Embed a ROM environment in your Roda app using the `plugin` hook:
 
 ```ruby
 class App < Roda
-  plugin :rom
+  plugin :rom, {
+    default: {
+      setup: :memory
+    },
+    plugins: [:auto_registration]
+  }
 end
 ```
 
-Options passed to the plugin are used to set up one or more adapters, using the [repository args format](http://www.rubydoc.info/gems/rom/ROM/Global#setup-instance_method) supported by `ROM.setup`.
+Options passed to the environment under the `:setup` key are used to set up one or more adapters, using the [repository args format](http://www.rubydoc.info/gems/rom/ROM/Global#setup-instance_method) supported by `ROM.setup`.
+
+Plugins passed to the environment under the `:plugins` key will be applied to the environment. 
 
-To register a single `sql` repository with an Sqlite data source:
+To register a single `sql` repository with an Sqlite data source and use the `auto_registration` environment plugin:
 
 ```ruby
 class App < Roda
-  plugin :rom, :sql, 'sqlite::memory'
+  plugin :rom, {
+    default: {
+      setup: [:sql, 'sqlite::memory'],
+      plugins: [:auto_registration]
+    }
+  }
 end
 ```
 
@@ -40,22 +52,72 @@ To register a 'default' and a 'warehouse' repository:
 ```ruby
 class App < Roda
   plugin :rom, {
-    default: [:sql, 'sqlite::memory'],
-    warehouse: [:sql, 'postgres://localhost/warehouse']
+    default: {
+      setup: {
+        default: [:sql, 'sqlite::memory'],
+        warehouse: [:sql, 'postgres://localhost/warehouse']
+      }
+    }
+  }
+end
+```
+
+You can also register multiple ROM environments, when doing so, it can be useful to pass configuration options to environment plugins, the following example will register items defined in the `Web` namespace with the `memory` environment and items defined in the `API` namespace with the `sql` environment:
+
+```ruby
+class App < Roda
+  plugin :rom, {
+    memory: {
+      setup: :memory,
+      plugins: {
+        auto_registration: {
+          if: ->(item) { item.to_s[/(.*)(?=::)/] == 'Web' }
+        }
+      }
+    },
+    sql: {
+      setup: [:sql, 'sqlite::memory'],
+      plugins: {
+        auto_registration: {
+          if: ->(item) { item.to_s[/(.*)(?=::)/] == 'API' }
+        }
+      }
+    }
   }
 end
 ```
 
 ### Loading ROM components
 
-Relations, commands and mappers are automatically registered with the ROM environment when their classes are loaded. This means that these components must be required by the app in a specific order during setup.
+Relations, commands and mappers need to be registered with the ROM environment before the environment is finalized (this can also be done via the `auto_registration` plugin). This means that these components must be required by the app in a specific order during setup.
 
 You can autoload ROM components from a local path in your app by passing the `:load_path` option to the plugin:
 
 ```ruby
 class App < Roda
   # register ROM components from './models'
-  plugin :rom, :sql, 'sqlite::memory', load_path: 'models'
+  plugin :rom, {
+    default: {
+      setup: [:sql, 'sqlite::memory'],
+      plugins: [:auto_registration]
+    },
+    load_path: 'models'
+  }
+end
+```
+
+You can also pass an array of paths to be autoloaded:
+
+```ruby
+class App < Roda
+  # register ROM components from './models' and './lib'
+  plugin :rom, {
+    default: {
+      setup: [:sql, 'sqlite::memory'],
+      plugins: [:auto_registration]
+    },
+    load_paths: ['models', 'lib']
+  }
 end
 ```
 
@@ -67,7 +129,13 @@ class MyApplication < Roda
   opts[:root] = 'app'
 
   # register ROM components from './app/model'
-  plugin :rom, :sql, 'sqlite::memory', load_path: 'model'
+  plugin :rom, {
+    default: {
+      setup: [:sql, 'sqlite::memory'],
+      plugins: [:auto_registration]
+    },
+    load_path: 'model'
+  }
 end
 ```
 
@@ -81,27 +149,38 @@ Provides an instance of the ROM environment:
 
 ```ruby
 route do |r|
-  rom
+  rom          # access :default ROM environment
+  rom(:memory) # access :memory ROM environment
 end
 ```
 
-#### relation(name)
+#### relation(name, environment = :default)
 
 Provides an instance of the named relation:
 
 ```ruby
 route do |r|
   r.on('catalog') do
+    # access :products relation from the :default ROM environment
     @products = relation(:products).in_stock
 
     r.is('category/:category') do |category|
       @products.by_category(category)
     end
   end
+
+  r.on('users') do
+    # access :users relation from the :sql ROM environment
+    @users = relation(:users, :sql)
+
+    r.is(':user_id') do |user_id|
+      @users.by_id(user_id)
+    end
+  end
 end
 ```
 
-#### command(name)
+#### command(name, environment = :default)
 
 Provides an instance of the named command:
 
@@ -109,9 +188,17 @@ Provides an instance of the named command:
 route do |r|
   r.is('products') do
     r.post do
+      # access :products commands from :default ROM environment
       command(:products).create.call(r['product'])
     end
   end
+
+  r.is('users') do
+    r.post do
+      # access :users commands from :sql ROM environment
+      command(:users, :sql).create.call(r['user'])
+    end
+  end
 end
 ```
 

data/lib/rom/roda/plugin.rb

@@ -1,43 +1,63 @@
 module ROM
   module Roda
     module Plugin
-      def self.configure(app, *args)
-        args = args.dup
+      class << self
+        attr_reader :environments
 
-        if args.last.is_a?(Hash) && args.last.key?(:load_path)
-          load_path = File.expand_path(args.pop.delete(:load_path), app.opts[:root])
-        end
+        def configure(app, config)
+          load_paths = [*(config.delete(:load_path) || config.delete(:load_paths))].map do |path|
+            File.expand_path(
+              path,
+              app.opts[:root]
+            )
+          end if config[:load_path] || config[:load_paths]
 
-        ROM.setup(*args)
+          @environments = config.each_with_object({}) do |(env_name, env_config), container|
+            container[env_name] = ROM::Environment.new.tap do |env|
+              env.setup(*[env_config.fetch(:setup)].flatten)
 
-        self.load_files(load_path) if load_path
-      end
+              env_config.fetch(:plugins, {}).each do |*args|
+                env.use(*args.flatten)
+              end
+            end
+          end
+
+          load_paths.map { |path| load_files(path) } if load_paths
+        end
 
-      def self.load_files(path)
-        Dir["#{path}/**/*.rb"].each do |class_file|
-          require class_file
+        def load_files(path)
+          Dir["#{path}/**/*.rb"].each do |class_file|
+            require class_file
+          end
         end
       end
 
       module ClassMethods
         def freeze
-          ROM.finalize
+          @__rom__ = ROM::Roda::Plugin.environments.each_with_object({}) do |(name, env), container|
+            container[name] = env.finalize.container
+          end
 
           super
         end
+
+        def rom(environment = nil)
+          environment = :default if environment.nil?
+          @__rom__.fetch(environment)
+        end
       end
 
       module InstanceMethods
-        def rom
-          ROM.env
+        def rom(environment = nil)
+          self.class.rom(environment)
         end
 
-        def relation(name)
-          ROM.env.relation(name)
+        def relation(name, environment = nil)
+          rom(environment).relation(name)
         end
 
-        def command(name)
-          ROM.env.command(name)
+        def command(name, environment = nil)
+          rom(environment).command(name)
         end
       end
     end

data/lib/rom/roda/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module Roda
-    VERSION = '0.1.1'.freeze
+    VERSION = '0.2.0'.freeze
   end
 end

data/rom-roda.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'rom', '~> 0.8', '>= 0.8.1'
+  spec.add_runtime_dependency 'rom', '~> 0.9', '>= 0.9.0'
   spec.add_runtime_dependency 'inflecto'
 
   spec.add_development_dependency 'bundler'

data/spec/integration/load_path_spec.rb

@@ -1,11 +1,95 @@
 require 'spec_helper'
 
 describe ROM::Roda::Plugin do
-  it 'uses load_path relative to application by default' do
-    subject.should_receive(:load_files).with(File.expand_path('models'))
+  before do
+    allow(ROM::Roda::Plugin).to receive(:load_files)
+  end
+
+  before do
+    Class.new(Roda).plugin :rom, config
+  end
+
+  context 'single path' do
+    context 'under :load_path as string' do
+      let(:config) do
+        {
+          default: {
+            setup: :memory
+          },
+          load_path: 'models'
+        }
+      end
+
+      it { expect(ROM::Roda::Plugin).to have_received(:load_files).with(File.expand_path('models')) }
+    end
+
+    context 'under :load_path as array' do
+      let(:config) do
+        {
+          default: {
+            setup: :memory
+          },
+          load_path: ['models']
+        }
+      end
+
+      it { expect(ROM::Roda::Plugin).to have_received(:load_files).with(File.expand_path('models')) }
+    end
+
+    context 'under :load_paths as string' do
+      let(:config) do
+        {
+          default: {
+            setup: :memory
+          },
+          load_paths: 'models'
+        }
+      end
+
+      it { expect(ROM::Roda::Plugin).to have_received(:load_files).with(File.expand_path('models')) }
+    end
+
+    context 'under :load_paths as string' do
+      let(:config) do
+        {
+          default: {
+            setup: :memory
+          },
+          load_paths: ['models']
+        }
+      end
+
+      it { expect(ROM::Roda::Plugin).to have_received(:load_files).with(File.expand_path('models')) }
+    end
+  end
+
+  context 'multiple paths' do
+    context 'under :load_path' do
+      let(:config) do
+        {
+          default: {
+            setup: :memory
+          },
+          load_path: ['api/models', 'web/models']
+        }
+      end
+
+      it { expect(ROM::Roda::Plugin).to have_received(:load_files).with(File.expand_path('api/models')) }
+      it { expect(ROM::Roda::Plugin).to have_received(:load_files).with(File.expand_path('web/models')) }
+    end
+
+    context 'under :load_paths' do
+      let(:config) do
+        {
+          default: {
+            setup: :memory
+          },
+          load_paths: ['api/models', 'web/models']
+        }
+      end
 
-    class RelativeLoadPathExample < Roda
-      plugin :rom, :memory, load_path: 'models'
+      it { expect(ROM::Roda::Plugin).to have_received(:load_files).with(File.expand_path('api/models')) }
+      it { expect(ROM::Roda::Plugin).to have_received(:load_files).with(File.expand_path('web/models')) }
     end
   end
 end

data/spec/integration/plugin_setup_spec.rb

@@ -6,12 +6,16 @@ describe ROM::Roda::Plugin do
   context 'single adapter' do
     let(:default_gateway) do
       class MemoryAdapterExample < Roda
-        plugin :rom, :memory
+        plugin :rom, {
+          default: {
+            setup: :memory
+          }
+        }
       end
 
       MemoryAdapterExample.freeze
 
-      ROM.env.gateways[:default]
+      MemoryAdapterExample.rom.gateways[:default]
     end
 
     it 'configures gateway with empty args' do
@@ -22,12 +26,16 @@ describe ROM::Roda::Plugin do
   context 'single adapter with settings' do
     let(:default_gateway) do
       class SqliteAdapterExample < Roda
-        plugin :rom, :sql, SQL_DSN
+        plugin :rom, {
+          default: {
+            setup: [:sql, SQL_DSN]
+          }
+        }
       end
 
       SqliteAdapterExample.freeze
 
-      ROM.env.gateways[:default]
+      SqliteAdapterExample.rom.gateways[:default]
     end
 
     it 'configures gateway with a connection string' do
@@ -39,15 +47,19 @@ describe ROM::Roda::Plugin do
     let(:gateways) do
       class MultipleAdaptersExample < Roda
         plugin :rom, {
-          default: [:sql, SQL_DSN],
-          warehouse: [:sql, SQL_DSN],
-          transient: :memory
+          default: {
+            setup: {
+              default: [:sql, SQL_DSN],
+              warehouse: [:sql, SQL_DSN],
+              transient: :memory
+            }
+          }
         }
       end
 
       MultipleAdaptersExample.freeze
 
-      ROM.env.gateways
+      MultipleAdaptersExample.rom.gateways
     end
 
     it 'configures gateways with given settings' do
@@ -56,4 +68,100 @@ describe ROM::Roda::Plugin do
       expect(gateways[:transient]).to be_a(ROM::Memory::Gateway)
     end
   end
+
+  context 'multiple environments' do
+    let(:gateways) do
+      class MultipleEnvironmentsExample < Roda
+        plugin :rom, {
+          memory: {
+            setup: :memory
+          },
+          sql: {
+            setup: {
+              default: [:sql, SQL_DSN],
+              warehouse: [:sql, SQL_DSN],
+              transient: :memory
+            }
+          }
+        }
+      end
+
+      MultipleEnvironmentsExample.freeze
+
+      {
+        memory: MultipleEnvironmentsExample.rom(:memory).gateways,
+        sql: MultipleEnvironmentsExample.rom(:sql).gateways
+      }
+    end
+
+    it 'configures gateways with given settings' do
+      expect(gateways[:memory][:default]).to be_a(ROM::Memory::Gateway)
+      expect(gateways[:sql][:default]).to be_a(ROM::SQL::Gateway)
+      expect(gateways[:sql][:warehouse]).to be_a(ROM::SQL::Gateway)
+      expect(gateways[:sql][:transient]).to be_a(ROM::Memory::Gateway)
+    end
+  end
+
+  context 'with environment plugin settings' do
+    context 'without plugin config' do
+      let(:relations) do
+        class PluginExample < Roda
+          plugin :rom, {
+            default: {
+              setup: :memory,
+              plugins: [:auto_registration]
+            }
+          }
+        end
+
+        class Users < ROM::Relation[:memory]
+          dataset :users
+        end
+
+        PluginExample.freeze
+
+        PluginExample.rom.relations
+      end
+
+      it 'configures gateway with a connection string' do
+        expect(relations[:users]).to be_a(ROM::Memory::Relation)
+      end
+    end
+
+    context 'with plugin config' do
+      let(:relations) do
+        class PluginWithConfigExample < Roda
+          plugin :rom, {
+            default: {
+              setup: :memory,
+              plugins: {
+                auto_registration: {
+                  if: ->(item) { item.to_s[/(.*)(?=::)/] == 'API' }
+                }
+              }
+            }
+          }
+        end
+
+        class Posts < ROM::Relation[:memory]
+          dataset :posts
+        end
+
+        module API
+          class Comments < ROM::Relation[:memory]
+            dataset :comments
+          end
+        end
+
+        PluginWithConfigExample.freeze
+
+        PluginWithConfigExample.rom.relations
+      end
+
+      it 'configures gateway with a connection string' do
+        expect { relations[:posts] }.to raise_error ROM::Registry::ElementNotFoundError
+        expect(relations[:comments]).to be_a(ROM::Memory::Relation)
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom-roda
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Mark Rickerby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-13 00:00:00.000000000 Z
+date: 2015-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rom
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: 0.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
   name: inflecto
   requirement: !ruby/object:Gem::Requirement
@@ -127,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Integrate Ruby Object Mapper with Roda
@@ -135,4 +135,3 @@ test_files:
 - spec/integration/load_path_spec.rb
 - spec/integration/plugin_setup_spec.rb
 - spec/spec_helper.rb
-has_rdoc: