rack-cargo 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 74705fb4f2b4e71ae109218d020b4a656ecee186
+  data.tar.gz: 53678530b07f570861049feed0169459d528a9ae
+SHA512:
+  metadata.gz: d39972558dd1a23a65c1f676ff0156861126ce4520a7532d34a0412356bfb75fbcb6788ce6d8520988887279a63ea9189beac0fdb5efce04f6094964a354b227
+  data.tar.gz: 5fb134a797e14a55506dcac06f0a8bf6782859100e23a5fb34e0bda3d5e9767b8b6105feb87f7a08f2a663a13fc64a3052cd005e4bf539bdc03ed1afe32f3a76

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,20 @@
+AllCops:
+  Exclude:
+    - test/**/*
+    - rack-cargo.gemspec
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+  SupportedStyles:
+    - double_quotes
+  # If `true`, strings which span multiple lines using `\` for continuation must
+  # use the same type of quotes on each line.
+  ConsistentQuotesInMultiline: true
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+  SupportedStyles:
+    - double_quotes
+
+Style/RescueModifier:
+  Enabled: false

data/.ruby-gemset

@@ -0,0 +1 @@
+rack-cargo

data/.ruby-version

@@ -0,0 +1 @@
+2.3.0

data/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+  - 2.4.0
+before_install: gem install bundler -v 1.15.3

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at murdho@murdho.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rack-cargo.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)\/?(.*)_test\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}#{m[2]}_test.rb" }
+  watch(%r{^test/test_helper\.rb$})      { "test" }
+
+  # with Minitest::Spec
+  # watch(%r{^spec/(.*)_spec\.rb$})
+  # watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+end
+
+notification :terminal_notifier if `uname` =~ /Darwin/

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Murdho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,173 @@
+# Rack::Cargo
+
+[![Build Status](https://travis-ci.org/murdho/rack-cargo.svg?branch=master)](https://travis-ci.org/murdho/rack-cargo)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/96d334fdbe7b4bed975c1e344523f926)](https://www.codacy.com/app/murdho/rack-cargo?utm_source=github.com&utm_medium=referral&utm_content=murdho/rack-cargo&utm_campaign=Badge_Grade)
+[![Codacy Badge](https://api.codacy.com/project/badge/Coverage/96d334fdbe7b4bed975c1e344523f926)](https://www.codacy.com/app/murdho/rack-cargo?utm_source=github.com&utm_medium=referral&utm_content=murdho/rack-cargo&utm_campaign=Badge_Coverage)
+
+Have you built nice RESTful APIs? I believe you have.
+
+Then you are also familiar with the situation, where API consumer needs to perform multiple actions at once. Maybe in the client application, multiple resources get created on one page. Creating multiple resources means making multiple HTTP requests.
+
+What if you could **batch the requests** together and send in one HTTP requests, wouldn't that be more efficient? I believe it would be! That's where **Rack::Cargo** comes in.
+
+Figuratively speaking, load your HTTP-request ship with the request cargo and put it on the way and enjoy your RESTful API! ☀️
+
+> ***You:** I want to know more about RESTful. Where should I look?*
+>
+> ***Me:** Cool! I recommend this awesome talk: [In Relentless Pursuit of REST by Derek Prior](https://youtu.be/HctYHe-YjnE)*
+
+## Installation
+
+Add this line to your Rack-based application's (Rails, Sinatra, etc.) Gemfile:
+
+```ruby
+gem 'rack-cargo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rack-cargo
+
+## Usage (TODO)
+
+### Configuration
+
+Initialize the middleware:
+
+```ruby
+Rack::Cargo.configure do |config|
+    config.batch_path = '/batch'
+end
+```
+
+Instruct `rack` to use the middleware:
+
+```ruby
+use Rack::Cargo::Middleware
+```
+
+### Referencing requests
+
+Requests in batch have access to the responses of executed (named) requests. This is useful, when creating resources and using the reference to it in the same batch.
+
+References can be used in `path` and `body` elements.
+
+Example shows both usages with `order.uuid` from the `order` response:
+
+```javascript
+// This is batch request payload:
+{
+    "requests": [
+        {
+            "name": "order",
+            "path": "/orders",
+            "method": "POST",
+            "body": {
+                "address": "Home, 12345"
+            }
+        },
+        {
+            "name": "order_item",
+            "path": "/orders/{{ order.uuid }}/items", // <-- here
+            "method": "POST",
+            "body": {
+                "title": "A Book"
+            }
+        },
+        {
+            "name": "payment",
+            "path": "/payments",
+            "method": "POST",
+            "body": {
+                "orders": [
+                    "{{ order.uuid }}" // <-- and here
+                ]
+            }
+        }
+    ]
+}
+
+// This is a possible response:
+[
+    {
+        "name": "order", // <-- "order" part of "order.uuid"
+        "status": 201,
+        "headers": {},
+        "body": {
+            "uuid": "bf52fdb5-d1c3-4c66-ba7d-bdf4cd83f265", // <-- "uuid" part of "order.uuid"
+            "address": "Home, 12345"
+        }
+    },
+    {
+        "name": "order_item",
+        "status": 201,
+        "headers": {},
+        "body": {
+            "uuid": "38bc4576-3b7e-40be-a1d6-ca795fe462c8",
+            "title": "A Book"
+        }
+    },
+    {
+        "name": "payment",
+        "status": 201,
+        "headers": {},
+        "body": {
+            "uuid": "c4f9f261-7822-4217-80a2-06cf92934bf9",
+            "orders": [
+                "bf52fdb5-d1c3-4c66-ba7d-bdf4cd83f265"
+            ]
+        }
+    }
+]
+```
+
+### Modifying batch processing pipeline
+
+Batch processing is composed of steps that perform some concrete action on the request and/or state of the processing.
+
+To insert processor in the pipeline, define the processor and inject it to the processors list:
+
+```ruby
+module MyFeeder
+  def self.call(request, state)
+    # calculate something
+    state.store(:data, "Useful data to MyEater")
+  end
+end
+ 
+module MyEater
+  def self.call(request, state)
+    data = state.fetch(:data)
+    # do something with the data
+  end
+end
+ 
+Rack::Cargo.configure do |config|
+  config.processors.insert(2, MyFeeder) # insert into third position
+  config.processors.insert(3, MyEater) # insert into fourth position
+end
+```
+
+Now your processors will be included in the pipeline.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rack-cargo. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Rack::Cargo project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rack-cargo/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "rack/cargo"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rack/cargo/batch_processor.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Rack
+  module Cargo
+    module BatchProcessor
+      ERROR_INVALID_BATCH = "Invalid batch request"
+
+      class << self
+        def process(app, env)
+          requests = RequestPayloadJSON.from_env(env)
+
+          if RequestValidator.valid?(requests)
+            results = process_requests(app, env, requests)
+            success(results)
+          else
+            failure([ERROR_INVALID_BATCH])
+          end
+        end
+
+        private
+
+        def process_requests(app, env, requests)
+          previous_responses = {}
+
+          requests.each do |request|
+            response = process_request(
+              app,
+              env,
+              request,
+              previous_responses
+            )
+            previous_responses[response.fetch("name")] = response
+          end
+
+          previous_responses.values
+        end
+
+        def process_request(app, env, request, previous_responses)
+          initial_state = {
+            app: app,
+            env: env,
+            previous_responses: previous_responses
+          }
+
+          result = processors.each_with_object(initial_state) do |proc, state|
+            proc.call(request, state)
+          end
+
+          result[:response]
+        end
+
+        def success(responses)
+          { success: true, responses: responses }
+        end
+
+        def failure(errors)
+          { success: false, errors: errors }
+        end
+
+        def processors
+          Rack::Cargo.config.processors
+        end
+      end
+    end
+  end
+end

data/lib/rack/cargo/batch_response.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rack
+  module Cargo
+    module BatchResponse
+      class << self
+        def from_result(result)
+          if result[:success]
+            respond_with(200, result[:responses])
+          else
+            respond_with(422, errors: result[:errors])
+          end
+        end
+
+        private
+
+        def respond_with(status, body)
+          response_headers = { "Content-Type" => "application/json" }
+          [status, response_headers, [body.to_json]]
+        end
+      end
+    end
+  end
+end

data/lib/rack/cargo/configuration.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rack
+  module Cargo
+    class Configuration
+      attr_accessor :batch_path
+      attr_accessor :processors
+
+      def initialize
+        self.batch_path = "/batch"
+        self.processors = [
+          ReferenceResolver,
+          RequestEnvBuilder,
+          RequestExecutor,
+          ResponseBuilder
+        ]
+      end
+    end
+  end
+end

data/lib/rack/cargo/core_ext/deep_dup.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# This file is copied from ActiveSupport source code.
+#
+# Original:
+# https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/object/deep_dup.rb
+
+require_relative "duplicable"
+
+class Object
+  # Returns a deep copy of object if it's duplicable. If it's
+  # not duplicable, returns +self+.
+  #
+  #   object = Object.new
+  #   dup    = object.deep_dup
+  #   dup.instance_variable_set(:@a, 1)
+  #
+  #   object.instance_variable_defined?(:@a) # => false
+  #   dup.instance_variable_defined?(:@a)    # => true
+  def deep_dup
+    duplicable? ? dup : self
+  end
+end
+
+class Array
+  # Returns a deep copy of array.
+  #
+  #   array = [1, [2, 3]]
+  #   dup   = array.deep_dup
+  #   dup[1][2] = 4
+  #
+  #   array[1][2] # => nil
+  #   dup[1][2]   # => 4
+  def deep_dup
+    map(&:deep_dup)
+  end
+end
+
+class Hash
+  # Returns a deep copy of hash.
+  #
+  #   hash = { a: { b: 'b' } }
+  #   dup  = hash.deep_dup
+  #   dup[:a][:c] = 'c'
+  #
+  #   hash[:a][:c] # => nil
+  #   dup[:a][:c]  # => "c"
+  def deep_dup
+    hash = dup
+    each_pair do |key, value|
+      if key.frozen? && ::String === key
+        hash[key] = value.deep_dup
+      else
+        hash.delete(key)
+        hash[key.deep_dup] = value.deep_dup
+      end
+    end
+    hash
+  end
+end

data/lib/rack/cargo/core_ext/duplicable.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+# This file is copied from ActiveSupport source code.
+#
+# Original:
+# https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/object/duplicable.rb
+
+#--
+# Most objects are cloneable, but not all. For example you can't dup methods:
+#
+#   method(:puts).dup # => TypeError: allocator undefined for Method
+#
+# Classes may signal their instances are not duplicable removing +dup+/+clone+
+# or raising exceptions from them. So, to dup an arbitrary object you normally
+# use an optimistic approach and are ready to catch an exception, say:
+#
+#   arbitrary_object.dup rescue object
+#
+# Rails dups objects in a few critical spots where they are not that arbitrary.
+# That rescue is very expensive (like 40 times slower than a predicate), and it
+# is often triggered.
+#
+# That's why we hardcode the following cases and check duplicable? instead of
+# using that rescue idiom.
+#++
+class Object
+  # Can you safely dup this object?
+  #
+  # False for method objects;
+  # true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass
+  begin
+    nil.dup
+  rescue TypeError
+    # +nil+ is not duplicable:
+    #
+    #   nil.duplicable? # => false
+    #   nil.dup         # => TypeError: can't dup NilClass
+    def duplicable?
+      false
+    end
+  end
+end
+
+class FalseClass
+  begin
+    false.dup
+  rescue TypeError
+    # +false+ is not duplicable:
+    #
+    #   false.duplicable? # => false
+    #   false.dup         # => TypeError: can't dup FalseClass
+    def duplicable?
+      false
+    end
+  end
+end
+
+class TrueClass
+  begin
+    true.dup
+  rescue TypeError
+    # +true+ is not duplicable:
+    #
+    #   true.duplicable? # => false
+    #   true.dup         # => TypeError: can't dup TrueClass
+    def duplicable?
+      false
+    end
+  end
+end
+
+class Symbol
+  begin
+    :symbol.dup # Ruby 2.4.x.
+    "symbol_from_string".to_sym.dup # Some symbols can't `dup` in Ruby 2.4.0.
+  rescue TypeError
+    # Symbols are not duplicable:
+    #
+    #   :my_symbol.duplicable? # => false
+    #   :my_symbol.dup         # => TypeError: can't dup Symbol
+    def duplicable?
+      false
+    end
+  end
+end
+
+class Numeric
+  begin
+    1.dup
+  rescue TypeError
+    # Numbers are not duplicable:
+    #
+    #  3.duplicable? # => false
+    #  3.dup         # => TypeError: can't dup Integer
+    def duplicable?
+      false
+    end
+  end
+end
+
+require "bigdecimal"
+class BigDecimal
+  # BigDecimals are duplicable:
+  #
+  #   BigDecimal.new("1.2").duplicable? # => true
+  #   BigDecimal.new("1.2").dup         # => #<BigDecimal:...,'0.12E1',18(18)>
+  def duplicable?
+    true
+  end
+end
+
+class Method
+  # Methods are not duplicable:
+  #
+  #  method(:puts).duplicable? # => false
+  #  method(:puts).dup         # => TypeError: allocator undefined for Method
+  def duplicable?
+    false
+  end
+end
+
+class Complex
+  begin
+    Complex(1).dup
+  rescue TypeError
+    # Complexes are not duplicable:
+    #
+    #   Complex(1).duplicable? # => false
+    #   Complex(1).dup         # => TypeError: can't copy Complex
+    def duplicable?
+      false
+    end
+  end
+end
+
+class Rational
+  begin
+    Rational(1).dup
+  rescue TypeError
+    # Rationals are not duplicable:
+    #
+    #   Rational(1).duplicable? # => false
+    #   Rational(1).dup         # => TypeError: can't copy Rational
+    def duplicable?
+      false
+    end
+  end
+end

data/lib/rack/cargo/middleware.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Rack
+  module Cargo
+    class Middleware
+      attr_accessor :app
+
+      def initialize(app)
+        self.app = app
+      end
+
+      def call(env)
+        if batch_request?(env[ENV_PATH])
+          result = BatchProcessor.process(app, env)
+          BatchResponse.from_result(result)
+        else
+          @app.call(env)
+        end
+      end
+
+      def batch_request?(path)
+        path == Rack::Cargo.config.batch_path
+      end
+    end
+  end
+end

data/lib/rack/cargo/reference_resolver.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Rack
+  module Cargo
+    module ReferenceResolver
+      REFERENCING_ENABLED = [REQUEST_PATH, REQUEST_BODY].freeze
+
+      PLACEHOLDER_START = "{{\s*"
+      PLACEHOLDER_END = "\s*}}"
+      PLACEHOLDER_PATTERN = /#{PLACEHOLDER_START}(.*?)#{PLACEHOLDER_END}/
+
+      class << self
+        def call(request, state)
+          REFERENCING_ENABLED.each do |attribute_key|
+            element, converted_to_json = get_json_element(request, attribute_key)
+            placeholders = find_placeholders(element)
+
+            element = replace_placeholders(element, placeholders, state)
+            element = JSON.parse(element) if converted_to_json
+
+            request.store(attribute_key, element)
+          end
+        end
+
+        private
+
+        def replace_placeholders(element, placeholders, state)
+          previous_responses = state.fetch(:previous_responses)
+
+          placeholders.each do |placeholder|
+            value_path = value_path_for(placeholder)
+            value = previous_responses.dig(*value_path)
+            next unless value
+
+            replacement_regex = replacement_regex_for(placeholder)
+            element = element.gsub(replacement_regex, value.to_s)
+          end
+
+          element
+        end
+
+        def value_path_for(placeholder)
+          placeholder.split(".").map(&:to_s).insert(1, REQUEST_BODY)
+        end
+
+        def replacement_regex_for(placeholder)
+          /#{PLACEHOLDER_START}#{placeholder}#{PLACEHOLDER_END}/
+        end
+
+        def find_placeholders(element)
+          element.scan(PLACEHOLDER_PATTERN).flatten
+        end
+
+        def get_json_element(request, attribute_key)
+          element_copy = request.fetch(attribute_key).dup
+
+          if element_copy.is_a?(String)
+            [element_copy, false]
+          else
+            [element_copy.to_json, true]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/cargo/request_env_builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rack/cargo/core_ext/deep_dup"
+
+module Rack
+  module Cargo
+    module RequestEnvBuilder
+      def self.call(request, state)
+        request_env = state.fetch(:env).deep_dup
+        request_env[ENV_PATH] = request[REQUEST_PATH]
+        request_env[ENV_METHOD] = request[REQUEST_METHOD]
+        request_env[ENV_INPUT] = StringIO.new(request[REQUEST_BODY].to_json)
+        state[:request_env] = request_env
+      end
+    end
+  end
+end

data/lib/rack/cargo/request_executor.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rack
+  module Cargo
+    module RequestExecutor
+      def self.call(_request, state)
+        app = state.fetch(:app)
+        request_env = state.fetch(:request_env)
+
+        status, headers, body = app.call(request_env)
+        body.close if body.respond_to?(:close)
+
+        state[:app_response] = {
+          status: status,
+          headers: headers,
+          body: body
+        }
+      end
+    end
+  end
+end

data/lib/rack/cargo/request_payload_json.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rack
+  module Cargo
+    module RequestPayloadJSON
+      def self.from_env(env)
+        io = env[ENV_INPUT]
+        return unless io
+
+        payload = io.read
+        return if payload.empty?
+
+        json_payload = JSON.parse(payload) rescue nil
+        return unless json_payload
+
+        json_payload[REQUESTS_KEY]
+      end
+    end
+  end
+end

data/lib/rack/cargo/request_validator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rack
+  module Cargo
+    module RequestValidator
+      REQUIRED_KEYS = [
+        REQUEST_PATH,
+        REQUEST_METHOD,
+        REQUEST_BODY
+      ].freeze
+
+      def self.valid?(requests)
+        return unless requests
+
+        requests.all? do |request|
+          REQUIRED_KEYS.all? { |key| request.key?(key) }
+        end
+      end
+    end
+  end
+end

data/lib/rack/cargo/response_builder.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Rack
+  module Cargo
+    module ResponseBuilder
+      class << self
+        def call(request, state)
+          app_response = state.fetch(:app_response)
+
+          name = request.fetch("name", autogenerated_name)
+
+          state[:response] = {
+            RESPONSE_NAME => name,
+            RESPONSE_STATUS => app_response.fetch(:status),
+            RESPONSE_HEADERS => app_response.fetch(:headers),
+            RESPONSE_BODY => JSON.parse(app_response.fetch(:body).join)
+          }
+        end
+
+        def autogenerated_name
+          "unnamed_#{SecureRandom.hex(6)}"
+        end
+      end
+    end
+  end
+end

data/lib/rack/cargo/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rack
+  module Cargo
+    VERSION = "0.9.0"
+  end
+end

data/lib/rack/cargo.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+
+require "rack/cargo/version"
+
+module Rack
+  module Cargo
+    REQUESTS_KEY = "requests"
+
+    ENV_PATH = "PATH_INFO"
+    ENV_INPUT = "rack.input"
+    ENV_METHOD = "REQUEST_METHOD"
+
+    REQUEST_NAME = "name"
+    REQUEST_PATH = "path"
+    REQUEST_METHOD = "method"
+    REQUEST_BODY = "body"
+
+    RESPONSE_NAME = "name"
+    RESPONSE_STATUS = "status"
+    RESPONSE_HEADERS = "headers"
+    RESPONSE_BODY = "body"
+
+    autoload :Middleware, "rack/cargo/middleware"
+    autoload :Configuration, "rack/cargo/configuration"
+
+    autoload :BatchProcessor, "rack/cargo/batch_processor"
+
+    autoload :RequestPayloadJSON, "rack/cargo/request_payload_json"
+    autoload :RequestValidator, "rack/cargo/request_validator"
+    autoload :ReferenceResolver, "rack/cargo/reference_resolver"
+    autoload :RequestEnvBuilder, "rack/cargo/request_env_builder"
+    autoload :RequestExecutor, "rack/cargo/request_executor"
+    autoload :ResponseBuilder, "rack/cargo/response_builder"
+
+    autoload :BatchResponse, "rack/cargo/batch_response"
+
+    class << self
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield(config)
+      end
+    end
+  end
+end

data/rack-cargo.gemspec

@@ -0,0 +1,42 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rack/cargo/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rack-cargo"
+  spec.version       = Rack::Cargo::VERSION
+  spec.authors       = ["Murdho"]
+  spec.email         = ["murdho@murdho.com"]
+
+  spec.summary       = "Batch requests for Rack apps."
+  spec.description   = <<~DESC
+    Enables creating batch requests to Rack apps.
+    Requests can reference each other.
+    Makes life easier for API consumers and builders.
+                       DESC
+  spec.homepage      = "https://github.com/murdho/rack-cargo"
+  spec.license       = "MIT"
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-reporters", "~> 1.1"
+  spec.add_development_dependency "guard", "~> 2.14"
+  spec.add_development_dependency "guard-minitest", "~> 2.4"
+  spec.add_development_dependency "terminal-notifier-guard", "~> 1.6"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "reek"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "codacy-coverage"
+end

metadata

@@ -0,0 +1,243 @@
+--- !ruby/object:Gem::Specification
+name: rack-cargo
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Murdho
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier-guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codacy-coverage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Enables creating batch requests to Rack apps.
+  Requests can reference each other.
+  Makes life easier for API consumers and builders.
+email:
+- murdho@murdho.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/rack/cargo.rb
+- lib/rack/cargo/batch_processor.rb
+- lib/rack/cargo/batch_response.rb
+- lib/rack/cargo/configuration.rb
+- lib/rack/cargo/core_ext/deep_dup.rb
+- lib/rack/cargo/core_ext/duplicable.rb
+- lib/rack/cargo/middleware.rb
+- lib/rack/cargo/reference_resolver.rb
+- lib/rack/cargo/request_env_builder.rb
+- lib/rack/cargo/request_executor.rb
+- lib/rack/cargo/request_payload_json.rb
+- lib/rack/cargo/request_validator.rb
+- lib/rack/cargo/response_builder.rb
+- lib/rack/cargo/version.rb
+- rack-cargo.gemspec
+homepage: https://github.com/murdho/rack-cargo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Batch requests for Rack apps.
+test_files: []