rom-http 0.0.1

data/lib/rom/http/relation.rb

@@ -0,0 +1,25 @@
+module ROM
+  module HTTP
+    class Relation < ROM::Relation
+      include Enumerable
+
+      adapter :http
+
+      forward :with_request_method, :with_path, :append_path, :with_options,
+              :with_params, :clear_params
+
+      def insert(*args)
+        dataset.insert(*args)
+      end
+      alias_method :<<, :insert
+
+      def update(*args)
+        dataset.update(*args)
+      end
+
+      def delete
+        dataset.delete
+      end
+    end
+  end
+end

data/lib/rom/http/version.rb

@@ -0,0 +1,5 @@
+module ROM
+  module HTTP
+    VERSION = '0.0.1'.freeze
+  end
+end

data/rakelib/rubocop.rake

@@ -0,0 +1,18 @@
+begin
+  require 'rubocop/rake_task'
+
+  Rake::Task[:default].enhance [:rubocop]
+
+  RuboCop::RakeTask.new do |task|
+    task.options << '--display-cop-names'
+  end
+
+  namespace :rubocop do
+    desc 'Generate a configuration file acting as a TODO list.'
+    task :auto_gen_config do
+      exec 'bundle exec rubocop --auto-gen-config'
+    end
+  end
+
+rescue LoadError
+end

data/rom-http.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rom/http/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rom-http'
+  spec.version       = ROM::HTTP::VERSION.dup
+  spec.authors       = ['Piotr Solnica', 'Andy Holland']
+  spec.email         = ['piotr.solnica@gmail.com', 'andyholland1991@aol.com']
+  spec.summary       = 'HTTP support for ROM'
+  spec.description   = spec.summary
+  spec.homepage      = 'http://rom-rb.org'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'rom', '0.9.0.beta1'
+  spec.add_runtime_dependency 'equalizer', '~> 0.0', '>= 0.0.9'
+  spec.add_runtime_dependency 'thread_safe'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/spec/integration/abstract/commands/create_spec.rb

@@ -0,0 +1,126 @@
+RSpec.describe ROM::HTTP::Commands::Create do
+  let(:uri) { 'http://localhost:3000' }
+  let(:headers) { { accept: 'application/json' } }
+  let(:rom) { ROM::Environment.new }
+  let(:container) { rom.finalize.env }
+  let(:request_handler) { double(Proc) }
+  let(:response_handler) { double(Proc) }
+  let(:relation) do
+    Class.new(ROM::HTTP::Relation) do
+      dataset :users
+    end
+  end
+
+  before do
+    rom.setup(
+      :http,
+      uri: uri,
+      headers: headers,
+      request_handler: request_handler,
+      response_handler: response_handler
+    )
+  end
+
+  context 'with single tuple' do
+    let(:response) { double }
+    let(:tuple) { double }
+    let(:attributes) { { first_name: 'John', last_name: 'Jackson' } }
+    let(:command) do
+      Class.new(ROM::HTTP::Commands::Create) do
+        register_as :create
+        relation :users
+        result :one
+      end
+    end
+    let(:dataset) do
+      ROM::HTTP::Dataset.new(
+        {
+          uri: uri,
+          headers: headers,
+          request_handler: request_handler,
+          response_handler: response_handler,
+          name: :users
+        },
+        request_method: :post,
+        params: attributes
+      )
+    end
+
+    before do
+      rom.register_relation(relation)
+      rom.register_command(command)
+
+      allow(request_handler).to receive(:call).and_return(response)
+      allow(response_handler).to receive(:call).and_return(tuple)
+    end
+
+    subject! { container.command(:users).create.call(attributes) }
+
+    it do
+      expect(request_handler).to have_received(:call).with(dataset)
+      expect(response_handler).to have_received(:call).with(response, dataset)
+      is_expected.to eq(tuple)
+    end
+  end
+
+  context 'with a collection' do
+    let(:response_1) { double }
+    let(:response_2) { double }
+    let(:tuple_1) { double }
+    let(:tuple_2) { double }
+    let(:attributes_1) { { first_name: 'John', last_name: 'Jackson' } }
+    let(:attributes_2) { { first_name: 'Jill', last_name: 'Smith' } }
+    let(:attributes) { [attributes_1, attributes_2] }
+    let(:command) do
+      Class.new(ROM::HTTP::Commands::Create) do
+        register_as :create
+        relation :users
+        result :many
+      end
+    end
+    let(:dataset_1) do
+      ROM::HTTP::Dataset.new(
+        {
+          uri: uri,
+          headers: headers,
+          request_handler: request_handler,
+          response_handler: response_handler,
+          name: :users
+        },
+        request_method: :post,
+        params: attributes_1
+      )
+    end
+    let(:dataset_2) do
+      ROM::HTTP::Dataset.new(
+        {
+          uri: uri,
+          headers: headers,
+          request_handler: request_handler,
+          response_handler: response_handler,
+          name: :users
+        },
+        request_method: :post,
+        params: attributes_2
+      )
+    end
+
+    before do
+      rom.register_relation(relation)
+      rom.register_command(command)
+
+      allow(request_handler).to receive(:call).and_return(response_1, response_2)
+      allow(response_handler).to receive(:call).and_return(tuple_1, tuple_2)
+    end
+
+    subject! { container.command(:users).create.call(attributes) }
+
+    it do
+      expect(request_handler).to have_received(:call).with(dataset_1)
+      expect(response_handler).to have_received(:call).with(response_1, dataset_1)
+      expect(request_handler).to have_received(:call).with(dataset_2)
+      expect(response_handler).to have_received(:call).with(response_2, dataset_2)
+      is_expected.to eq([tuple_1, tuple_2])
+    end
+  end
+end

data/spec/integration/abstract/commands/delete_spec.rb

@@ -0,0 +1,61 @@
+RSpec.describe ROM::HTTP::Commands::Delete do
+  let(:uri) { 'http://localhost:3000' }
+  let(:headers) { { accept: 'application/json' } }
+  let(:rom) { ROM::Environment.new }
+  let(:container) { rom.finalize.env }
+  let(:request_handler) { double(Proc) }
+  let(:response_handler) { double(Proc) }
+  let(:relation) do
+    Class.new(ROM::HTTP::Relation) do
+      dataset :users
+    end
+  end
+  let(:response) { double }
+  let(:tuple) { double }
+  let(:tuples) { double(first: tuple) }
+  let(:command) do
+    Class.new(ROM::HTTP::Commands::Delete) do
+      register_as :delete
+      relation :users
+      result :one
+    end
+  end
+  let(:dataset) do
+    ROM::HTTP::Dataset.new(
+      {
+        uri: uri,
+        headers: headers,
+        request_handler: request_handler,
+        response_handler: response_handler,
+        name: :users
+      },
+      request_method: :delete
+    )
+  end
+
+  before do
+    rom.setup(
+      :http,
+      uri: uri,
+      headers: headers,
+      request_handler: request_handler,
+      response_handler: response_handler
+    )
+  end
+
+  before do
+    rom.register_relation(relation)
+    rom.register_command(command)
+
+    allow(request_handler).to receive(:call).and_return(response)
+    allow(response_handler).to receive(:call).and_return(tuples)
+  end
+
+  subject! { container.command(:users).delete.call }
+
+  it do
+    expect(request_handler).to have_received(:call).with(dataset)
+    expect(response_handler).to have_received(:call).with(response, dataset)
+    is_expected.to eq(tuple)
+  end
+end

data/spec/integration/abstract/commands/update_spec.rb

@@ -0,0 +1,126 @@
+RSpec.describe ROM::HTTP::Commands::Update do
+  let(:uri) { 'http://localhost:3000' }
+  let(:headers) { { accept: 'application/json' } }
+  let(:rom) { ROM::Environment.new }
+  let(:container) { rom.finalize.env }
+  let(:request_handler) { double(Proc) }
+  let(:response_handler) { double(Proc) }
+  let(:relation) do
+    Class.new(ROM::HTTP::Relation) do
+      dataset :users
+    end
+  end
+
+  before do
+    rom.setup(
+      :http,
+      uri: uri,
+      headers: headers,
+      request_handler: request_handler,
+      response_handler: response_handler
+    )
+  end
+
+  context 'with single tuple' do
+    let(:response) { double }
+    let(:tuple) { double }
+    let(:attributes) { { first_name: 'John', last_name: 'Jackson' } }
+    let(:command) do
+      Class.new(ROM::HTTP::Commands::Update) do
+        register_as :update
+        relation :users
+        result :one
+      end
+    end
+    let(:dataset) do
+      ROM::HTTP::Dataset.new(
+        {
+          uri: uri,
+          headers: headers,
+          request_handler: request_handler,
+          response_handler: response_handler,
+          name: :users
+        },
+        request_method: :put,
+        params: attributes
+      )
+    end
+
+    before do
+      rom.register_relation(relation)
+      rom.register_command(command)
+
+      allow(request_handler).to receive(:call).and_return(response)
+      allow(response_handler).to receive(:call).and_return(tuple)
+    end
+
+    subject! { container.command(:users).update.call(attributes) }
+
+    it do
+      expect(request_handler).to have_received(:call).with(dataset)
+      expect(response_handler).to have_received(:call).with(response, dataset)
+      is_expected.to eq(tuple)
+    end
+  end
+
+  context 'with a collection' do
+    let(:response_1) { double }
+    let(:response_2) { double }
+    let(:tuple_1) { double }
+    let(:tuple_2) { double }
+    let(:attributes_1) { { first_name: 'John', last_name: 'Jackson' } }
+    let(:attributes_2) { { first_name: 'Jill', last_name: 'Smith' } }
+    let(:attributes) { [attributes_1, attributes_2] }
+    let(:command) do
+      Class.new(ROM::HTTP::Commands::Update) do
+        register_as :update
+        relation :users
+        result :many
+      end
+    end
+    let(:dataset_1) do
+      ROM::HTTP::Dataset.new(
+        {
+          uri: uri,
+          headers: headers,
+          request_handler: request_handler,
+          response_handler: response_handler,
+          name: :users
+        },
+        request_method: :put,
+        params: attributes_1
+      )
+    end
+    let(:dataset_2) do
+      ROM::HTTP::Dataset.new(
+        {
+          uri: uri,
+          headers: headers,
+          request_handler: request_handler,
+          response_handler: response_handler,
+          name: :users
+        },
+        request_method: :put,
+        params: attributes_2
+      )
+    end
+
+    before do
+      rom.register_relation(relation)
+      rom.register_command(command)
+
+      allow(request_handler).to receive(:call).and_return(response_1, response_2)
+      allow(response_handler).to receive(:call).and_return(tuple_1, tuple_2)
+    end
+
+    subject! { container.command(:users).update.call(attributes) }
+
+    it do
+      expect(request_handler).to have_received(:call).with(dataset_1)
+      expect(response_handler).to have_received(:call).with(response_1, dataset_1)
+      expect(request_handler).to have_received(:call).with(dataset_2)
+      expect(response_handler).to have_received(:call).with(response_2, dataset_2)
+      is_expected.to eq([tuple_1, tuple_2])
+    end
+  end
+end

data/spec/integration/abstract/relation_spec.rb

@@ -0,0 +1,64 @@
+RSpec.describe ROM::HTTP::Relation do
+  let(:uri) { 'http://localhost:3000' }
+  let(:headers) { { accept: 'application/json' } }
+  let(:rom) { ROM::Environment.new }
+  let(:container) { rom.finalize.env }
+  let(:request_handler) { double(Proc) }
+  let(:response_handler) { double(Proc) }
+  let(:relation) do
+    Class.new(ROM::HTTP::Relation) do
+      dataset :users
+
+      def by_id(id)
+        append_path(id.to_s)
+      end
+
+      def filter(params)
+        with_params(params)
+      end
+    end
+  end
+  let(:response) { double }
+  let(:tuples) { [] }
+  let(:dataset) do
+    ROM::HTTP::Dataset.new(
+      {
+        uri: uri,
+        headers: headers,
+        request_handler: request_handler,
+        response_handler: response_handler,
+        name: :users
+      },
+      request_method: :get,
+      path: "/#{id}",
+      params: params
+    )
+  end
+  let(:id) { 1337 }
+  let(:params) { { filters: { first_name: 'John' } } }
+
+  before do
+    rom.setup(
+      :http,
+      uri: uri,
+      headers: headers,
+      request_handler: request_handler,
+      response_handler: response_handler
+    )
+  end
+
+  before do
+    rom.register_relation(relation)
+
+    allow(request_handler).to receive(:call).and_return(response)
+    allow(response_handler).to receive(:call).and_return(tuples)
+  end
+
+  subject! { container.relation(:users).by_id(id).filter(params).to_a }
+
+  it do
+    expect(request_handler).to have_received(:call).with(dataset).once
+    expect(response_handler).to have_received(:call).with(response, dataset).once
+    is_expected.to eq(tuples)
+  end
+end