rom-http 0.7.0 → 0.9.0

data/examples/repository_with_combine.rb

@@ -1,154 +0,0 @@
-require 'inflecto'
-require 'json'
-require 'uri'
-require 'net/http'
-require 'rom-repository'
-
-class RequestHandler
-  def call(dataset)
-    uri = URI(dataset.uri)
-    uri.path = dataset.absolute_path
-    uri.query = URI.encode_www_form(dataset.params)
-
-    http = Net::HTTP.new(uri.host, uri.port)
-    request_klass = Net::HTTP.const_get(Inflecto.classify(dataset.request_method))
-
-    request = request_klass.new(uri.request_uri)
-    dataset.headers.each_with_object(request) do |(header, value), request|
-      request[header.to_s] = value
-    end
-
-    response = http.request(request)
-  end
-end
-
-class ResponseHandler
-  def call(response, dataset)
-    if %i(post put patch).include?(dataset.request_method)
-      JSON.parse(response.body, symbolize_names: true)
-    else
-      Array([JSON.parse(response.body, symbolize_names: true)]).flatten
-    end
-  end
-end
-
-class Users < ROM::Relation[:http]
-  schema(:users) do
-    attribute :id, ROM::Types::Int.meta(primary_key: true)
-    attribute :name, ROM::Types::String
-    attribute :username, ROM::Types::String
-    attribute :email, ROM::Types::String
-    attribute :phone, ROM::Types::String
-    attribute :website, ROM::Types::String
-  end
-
-  def by_id(id)
-    with_path(id.to_s)
-  end
-end
-
-class Posts < ROM::Relation[:http]
-  schema(:posts) do
-    attribute :id, ROM::Types::Int.meta(primary_key: true)
-    attribute :userId, ROM::Types::Int.meta(alias: :user_id)
-    attribute :title, ROM::Types::String
-    attribute :body, ROM::Types::String
-  end
-
-  def by_id(id)
-    with_path(id.to_s)
-  end
-
-  def for_user(user)
-    with_options(
-      base_path: 'users',
-      path: "#{user.first[:id]}/posts"
-    )
-  end
-end
-
-class UserRepository < ROM::Repository[:users]
-  relations :posts
-
-  def find(id)
-    users.by_id(id).first
-  end
-
-  def find_with_posts(user_id)
-    users.by_id(user_id).combine_children(many: posts.for_user).first
-  end
-end
-
-configuration = ROM::Configuration.new(:http, {
-  uri: 'http://jsonplaceholder.typicode.com',
-  headers: {
-    Accept: 'application/json'
-  },
-  request_handler: RequestHandler.new,
-  response_handler: ResponseHandler.new
-})
-configuration.register_relation(Users)
-configuration.register_relation(Posts)
-container = ROM.container(configuration)
-
-UserRepository.new(container).find_with_posts(1)
-# =>
-# #<ROM::Struct[User]
-#   id=1
-#   name="Leanne Graham"
-#   username="Bret"
-#   email="Sincere@april.biz"
-#   phone="1-770-736-8031 x56442"
-#   website="hildegard.org"
-#   posts=[
-#     #<ROM::Struct[Post]
-#       id=1
-#       user_id=1
-#       title="sunt aut facere repellat provident occaecati excepturi optio reprehenderit"
-#       body="quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto">,
-#     #<ROM::Struct[Post]
-#       id=2
-#       user_id=1
-#       title="qui est esse"
-#       body="est rerum tempore vitae\nsequi sint nihil reprehenderit dolor beatae ea dolores neque\nfugiat blanditiis voluptate porro vel nihil molestiae ut reiciendis\nqui aperiam non debitis possimus qui neque nisi nulla">,
-#     #<ROM::Struct[Post]
-#       id=3
-#       user_id=1
-#       title="ea molestias quasi exercitationem repellat qui ipsa sit aut"
-#       body="et iusto sed quo iure\nvoluptatem occaecati omnis eligendi aut ad\nvoluptatem doloribus vel accusantium quis pariatur\nmolestiae porro eius odio et labore et velit aut">,
-#     #<ROM::Struct[Post]
-#       id=4
-#       user_id=1
-#       title="eum et est occaecati"
-#       body="ullam et saepe reiciendis voluptatem adipisci\nsit amet autem assumenda provident rerum culpa\nquis hic commodi nesciunt rem tenetur doloremque ipsam iure\nquis sunt voluptatem rerum illo velit">,
-#     #<ROM::Struct[Post]
-#       id=5
-#       user_id=1
-#       title="nesciunt quas odio"
-#       body="repudiandae veniam quaerat sunt sed\nalias aut fugiat sit autem sed est\nvoluptatem omnis possimus esse voluptatibus quis\nest aut tenetur dolor neque">,
-#     #<ROM::Struct[Post]
-#       id=6
-#       user_id=1
-#       title="dolorem eum magni eos aperiam quia"
-#       body="ut aspernatur corporis harum nihil quis provident sequi\nmollitia nobis aliquid molestiae\nperspiciatis et ea nemo ab reprehenderit accusantium quas\nvoluptate dolores velit et doloremque molestiae">,
-#     #<ROM::Struct[Post]
-#       id=7
-#       user_id=1
-#       title="magnam facilis autem"
-#       body="dolore placeat quibusdam ea quo vitae\nmagni quis enim qui quis quo nemo aut saepe\nquidem repellat excepturi ut quia\nsunt ut sequi eos ea sed quas">,
-#     #<ROM::Struct[Post]
-#       id=8
-#       user_id=1
-#       title="dolorem dolore est ipsam"
-#       body="dignissimos aperiam dolorem qui eum\nfacilis quibusdam animi sint suscipit qui sint possimus cum\nquaerat magni maiores excepturi\nipsam ut commodi dolor voluptatum modi aut vitae">,
-#     #<ROM::Struct[Post]
-#       id=9
-#       user_id=1
-#       title="nesciunt iure omnis dolorem tempora et accusantium"
-#       body="consectetur animi nesciunt iure dolore\nenim quia ad\nveniam autem ut quam aut nobis\net est aut quod aut provident voluptas autem voluptas">,
-#     #<ROM::Struct[Post]
-#       id=10
-#       user_id=1
-#       title="optio molestias id quia eum"
-#       body="quo et expedita modi cum officia vel magni\ndoloribus qui repudiandae\nvero nisi sit\nquos veniam quod sed accusamus veritatis error">
-#   ]>

data/lib/rom/http/dataset/class_interface.rb

@@ -1,33 +0,0 @@
-module ROM
-  module HTTP
-    # HTTP Dataset
-    #
-    # Represents a specific HTTP collection resource
-    #
-    # @api public
-    class Dataset
-      # @api private
-      module ClassInterface
-        # TODO: Remove in favour of configuration
-        def default_request_handler(handler = Undefined)
-          ::Dry::Core::Deprecations.announce(
-            __method__,
-            'use configuration instead'
-          )
-          return config.default_request_handler if Undefined === handler
-          config.default_request_handler = handler
-        end
-
-        # TODO: Remove in favour of configuration
-        def default_response_handler(handler = Undefined)
-          ::Dry::Core::Deprecations.announce(
-            __method__,
-            'use configuration instead'
-          )
-          return config.default_response_handler if Undefined === handler
-          config.default_response_handler = handler
-        end
-      end
-    end
-  end
-end

data/rakelib/rubocop.rake

@@ -1,18 +0,0 @@
-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

@@ -1,32 +0,0 @@
-# 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', 'Chris Flipse']
-  spec.email         = ['piotr.solnica@gmail.com', 'andyholland1991@aol.com', 'cflipse@gmail.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 'concurrent-ruby'
-  spec.add_runtime_dependency 'addressable'
-  spec.add_runtime_dependency 'rom', '~> 4.0'
-  spec.add_runtime_dependency 'dry-core', '~> 0.2', '>= 0.2.3'
-  spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
-  spec.add_runtime_dependency 'dry-configurable', '~> 0.6'
-
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rspec', '~> 3.1'
-  spec.add_development_dependency 'rspec-its'
-  spec.add_development_dependency 'rake', '~> 10.0'
-end

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

@@ -1,119 +0,0 @@
-RSpec.describe ROM::HTTP::Commands::Create do
-  include_context 'setup'
-  let(:relation) do
-    Class.new(ROM::HTTP::Relation) do
-      schema(:users) do
-        attribute :id, ROM::Types::Int
-        attribute :first_name, ROM::Types::String
-        attribute :last_name, ROM::Types::String
-      end
-
-      def by_id(id)
-        with_params(id: id)
-      end
-    end
-  end
-
-  context 'with single tuple' do
-    let(:response) { double }
-    let(:attributes) { { first_name: 'John', last_name: 'Jackson' } }
-    let(:tuple) { attributes.merge(id: 1) }
-    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
-      configuration.register_relation(relation)
-      configuration.register_command(command)
-
-      allow(request_handler).to receive(:call).and_return(response)
-      allow(response_handler).to receive(:call).and_return(tuple)
-    end
-
-    subject! { container.commands[: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(:attributes_1) { { first_name: 'John', last_name: 'Jackson' } }
-    let(:attributes_2) { { first_name: 'Jill', last_name: 'Smith' } }
-    let(:tuple_1) { attributes_1.merge(id: 1) }
-    let(:tuple_2) { attributes_2.merge(id: 2) }
-    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
-      configuration.register_relation(relation)
-      configuration.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.commands[: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

@@ -1,52 +0,0 @@
-RSpec.describe ROM::HTTP::Commands::Delete do
-  include_context 'setup'
-  let(:relation) do
-    Class.new(ROM::HTTP::Relation) do
-      schema(:users) do
-        attribute :id, ROM::Types::Int
-      end
-
-      def by_id(id)
-        with_params(id: id)
-      end
-    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
-    configuration.register_relation(relation)
-    configuration.register_command(command)
-
-    allow(request_handler).to receive(:call).and_return(response)
-    allow(response_handler).to receive(:call).and_return(tuples)
-  end
-
-  subject! { container.commands[: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

@@ -1,119 +0,0 @@
-RSpec.describe ROM::HTTP::Commands::Update do
-  include_context 'setup'
-  let(:relation) do
-    Class.new(ROM::HTTP::Relation) do
-      schema(:users) do
-        attribute :id, ROM::Types::Int
-        attribute :first_name, ROM::Types::String
-        attribute :last_name, ROM::Types::String
-      end
-
-      def by_id(id)
-        with_params(id: id)
-      end
-    end
-  end
-
-  context 'with single tuple' do
-    let(:response) { double }
-    let(:attributes) { { first_name: 'John', last_name: 'Jackson' } }
-    let(:tuple) { attributes.merge(id: 1) }
-    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
-      configuration.register_relation(relation)
-      configuration.register_command(command)
-
-      allow(request_handler).to receive(:call).and_return(response)
-      allow(response_handler).to receive(:call).and_return(tuple)
-    end
-
-    subject! { container.commands[: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(:attributes_1) { { first_name: 'John', last_name: 'Jackson' } }
-    let(:attributes_2) { { first_name: 'Jill', last_name: 'Smith' } }
-    let(:tuple_1) { attributes_1.merge(id: 1) }
-    let(:tuple_2) { attributes_2.merge(id: 2) }
-    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
-      configuration.register_relation(relation)
-      configuration.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.commands[: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

@@ -1,78 +0,0 @@
-require 'json'
-require 'rom-repository'
-
-RSpec.describe ROM::HTTP::Relation do
-  subject(:users) { container.relations[:users].by_id(id).filter(params) }
-
-  include_context 'setup'
-
-  let(:relation) do
-    Class.new(ROM::HTTP::Relation) do
-      schema(:users) do
-        attribute :id, ROM::Types::Int
-        attribute :name, ROM::Types::String
-      end
-
-      def by_id(id)
-        append_path(id.to_s)
-      end
-
-      def filter(params)
-        with_params(params)
-      end
-    end
-  end
-
-  let(:response) { tuples.to_json }
-  let(:tuples) { [{ id: 1337, name: 'John' }] }
-  let(:id) { 1337 }
-  let(:params) { { filters: { first_name: 'John' } } }
-
-  let(:dataset) do
-    ROM::HTTP::Dataset.new(
-      {
-        uri: uri,
-        headers: headers,
-        request_handler: request_handler,
-        response_handler: response_handler,
-        name: :users
-      },
-      path: "users/#{id}",
-      params: params
-    )
-  end
-
-  before do
-    configuration.register_relation(relation)
-
-    allow(request_handler).to receive(:call).and_return(response)
-    allow(response_handler).to receive(:call).and_return(tuples)
-  end
-
-  it 'returns relation tuples' do
-    expect(users.to_a).to eql(tuples)
-
-    expect(request_handler).to have_received(:call).with(dataset).once
-    expect(response_handler).to have_received(:call).with(response, dataset).once
-  end
-
-  context 'using a repo' do
-    let(:repo) do
-      Class.new(ROM::Repository) do
-        def self.to_s
-          'UserRepo'
-        end
-      end.new(container)
-    end
-
-    it 'returns structs' do
-      user = repo.users.by_id(1337).filter(params).first
-
-      expect(user.id).to be(1337)
-      expect(user.name).to eql('John')
-
-      expect(request_handler).to have_received(:call).with(dataset).once
-      expect(response_handler).to have_received(:call).with(response, dataset).once
-    end
-  end
-end

data/spec/shared/setup.rb

@@ -1,18 +0,0 @@
-RSpec.shared_context 'setup' do
-  let(:configuration) do
-    ROM::Configuration.new(
-      :http,
-      uri: uri,
-      request_handler: request_handler,
-      response_handler: response_handler,
-      headers: headers
-    )
-  end
-  let(:container) { ROM.container(configuration) }
-  let(:rom) { container }
-  let(:gateway) { container.gateways.fetch(:default) }
-  let(:uri) { 'http://localhost:3000' }
-  let(:request_handler) { double(Proc, freeze: self) }
-  let(:response_handler) { double(Proc, freeze: self) }
-  let(:headers) { { accept: 'application/json' } }
-end

data/spec/shared/users_and_tasks.rb

@@ -1,30 +0,0 @@
-RSpec.shared_context 'users and tasks' do
-  include_context 'setup'
-  let(:users_relation) do
-    Class.new(ROM::HTTP::Relation) do
-      schema(:users) do
-        attribute :id, ROM::Types::Int
-      end
-
-      def by_id(id)
-        with_params(id: id)
-      end
-    end
-  end
-  let(:tasks_relation) do
-    Class.new(ROM::HTTP::Relation) do
-      schema(:tasks) do
-        attribute :id, ROM::Types::Int
-      end
-
-      def by_id(id)
-        with_params(id: id)
-      end
-    end
-  end
-
-  before do
-    configuration.register_relation(users_relation)
-    configuration.register_relation(tasks_relation)
-  end
-end

data/spec/spec_helper.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-require 'bundler'
-Bundler.setup
-
-require 'rom-http'
-require 'rspec/its'
-require 'dry/configurable/test_interface'
-
-ROM::HTTP::Dataset.enable_test_interface
-
-begin
-require 'byebug'
-rescue LoadError; end
-
-root = Pathname(__FILE__).dirname
-
-Dir[root.join('support/**/*.rb').to_s].each { |file| require file }
-Dir[root.join('shared/**/*.rb').to_s].each { |file| require file }

data/spec/support/mutant.rb

@@ -1,10 +0,0 @@
-module Mutant
-  class Selector
-    # Expression based test selector
-    class Expression < self
-      def call(_subject)
-        integration.all_tests
-      end
-    end # Expression
-  end # Selector
-end # Mutant