midler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2237664840e88240019d59937eb343b6e109f7c
+  data.tar.gz: 8369600f8a0ae3b9b26890378e991842b2446138
+SHA512:
+  metadata.gz: bd98a7aa3a7465ae44468292a789002e6db8afee3c820d56ab5c29b02a26bb39f2311710b6c9072317fea4241a13eaf83802155e3b21784fa0cb5ee4c9d5c13b
+  data.tar.gz: d775a38ce73e3f5000a984f7b257591e6b1c045d8cfbcb90a5de93b2c9a7a4c8daacd7eacc8cb55b2a7b76e8b80a6bc6c4febc432148ccc2c5cf50a1bba9f430

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in midler.gemspec
+gemspec

data/README.md

@@ -0,0 +1,105 @@
+# Midler
+
+This is a fork of [Middleware](https://github.com/mitchellh/middleware) that allows multiple env arguments, and is fully backward compatible. Refer to the parent gem for additional documentation.
+
+![Recite: "boil, boil, toil and trouble..."](midler.jpg)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'midler'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install midler
+
+## Variadic Middleware Usage
+
+This is where this fork of the gem really shines. We can now pass variadic arguments in place of env. For example, we can now call the stack with a `request` and `response` for this express-style webserver example.
+
+```ruby
+class JsonResponse
+  def initialize(app)
+    @app   = app
+  end
+
+  def call(request, response)
+    Logger.info { "Received #{request[:body]} from request" }
+    response[:accept] = "application/json"
+    @app.call(request, response)
+  end
+end
+
+stack = Midler::Builder.new do
+  use JsonResponse
+  use Authenticate
+  use Authorized
+end
+
+# Run it!
+stack.call(request, response)
+```
+
+## Singular Env Usage
+
+Once you create a basic middleware, you can use the builder to
+have a nice DSL to build middleware stacks. Calling the middleware
+is simple, as well.
+
+```ruby
+# Basic middleware that just prints the inbound and
+# outbound steps.
+class Trace
+  def initialize(app, value)
+    @app   = app
+    @value = value
+  end
+
+  def call(env)
+    puts "--> #{@value}"
+    @app.call(env)
+    puts "<-- #{@value}"
+  end
+end
+
+# Build the actual middleware stack which runs a sequence
+# of slightly different versions of our middleware.
+stack = Midler::Builder.new do
+  use Trace, "A"
+  use Trace, "B"
+  use Trace, "C"
+end
+
+# Run it!
+stack.call(nil)
+```
+
+And the output:
+
+```
+--> A
+--> B
+--> C
+<-- C
+<-- B
+<-- A
+```
+
+## Development
+
+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` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/film42/midler/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+# RSpec test task
+RSpec::Core::RakeTask.new
+
+# Make sure the default is to run RSpec
+task :default => "spec"

data/lib/midler/builder.rb

@@ -0,0 +1,135 @@
+module Midler
+  # This provides a DSL for building up a stack of middlewares.
+  #
+  # This code is based heavily off of `Rack::Builder` and
+  # `ActionDispatch::MiddlewareStack` in Rack and Rails, respectively.
+  #
+  # # Usage
+  #
+  # Building a middleware stack is very easy:
+  #
+  #     app = Midler::Builder.new do
+  #       use A
+  #       use B
+  #     end
+  #
+  #     # Call the middleware
+  #     app.call(7)
+  #
+  class Builder
+    # Initializes the builder. An optional block can be passed which
+    # will be evaluated in the context of the instance.
+    #
+    # Example:
+    #
+    #     Builder.new do
+    #       use A
+    #       use B
+    #     end
+    #
+    # @param [Hash] opts Options hash
+    # @option opts [Class] :runner_class The class to wrap the middleware stack
+    #   in which knows how to run them.
+    # @yield [] Evaluated in this instance which allows you to use methods
+    #   like {#use} and such.
+    def initialize(opts=nil, &block)
+      opts ||= {}
+      @runner_class = opts[:runner_class] || Runner
+      instance_eval(&block) if block_given?
+    end
+
+    # Returns a mergeable version of the builder. If `use` is called with
+    # the return value of this method, then the stack will merge, instead
+    # of being treated as a separate single middleware.
+    def flatten
+      lambda do |*envs|
+        self.call(*envs)
+      end
+    end
+
+    # Adds a middleware class to the middleware stack. Any additional
+    # args and a block, if given, are saved and passed to the initializer
+    # of the middleware.
+    #
+    # @param [Class] middleware The middleware class
+    def use(middleware, *args, &block)
+      if middleware.kind_of?(Builder)
+        # Merge in the other builder's stack into our own
+        self.stack.concat(middleware.stack)
+      else
+        self.stack << [middleware, args, block]
+      end
+
+      self
+    end
+
+    # Inserts a middleware at the given index or directly before the
+    # given middleware object.
+    def insert(index, middleware, *args, &block)
+      index = self.index(index) unless index.is_a?(Integer)
+      stack.insert(index, [middleware, args, block])
+    end
+
+    alias_method :insert_before, :insert
+
+    # Inserts a middleware after the given index or middleware object.
+    def insert_after(index, middleware, *args, &block)
+      index = self.index(index) unless index.is_a?(Integer)
+      raise "no such middleware to insert after: #{index.inspect}" unless index
+      insert(index + 1, middleware, *args, &block)
+    end
+
+    # Replaces the given middlware object or index with the new
+    # middleware.
+    def replace(index, middleware, *args, &block)
+      if index.is_a?(Integer)
+        delete(index)
+        insert(index, middleware, *args, &block)
+      else
+        insert_before(index, middleware, *args, &block)
+        delete(index)
+      end
+    end
+
+    # Deletes the given middleware object or index
+    def delete(index)
+      index = self.index(index) unless index.is_a?(Integer)
+      stack.delete_at(index)
+    end
+
+    # Runs the builder stack with the given environments.
+    def call(*envs)
+      envs = [nil] if envs.empty?
+      to_app.call(*envs)
+    end
+
+    protected
+
+    # Returns the numeric index for the given middleware object.
+    #
+    # @param [Object] object The item to find the index for
+    # @return [Integer]
+    def index(object)
+      stack.each_with_index do |item, i|
+        return i if item[0] == object
+      end
+
+      nil
+    end
+
+    # Returns the current stack of middlewares. You probably won't
+    # need to use this directly, and it's recommended that you don't.
+    #
+    # @return [Array]
+    def stack
+      @stack ||= []
+    end
+
+    # Converts the builder stack to a runnable action sequence.
+    #
+    # @return [Object] A callable object
+    def to_app
+      @runner_class.new(stack.dup)
+    end
+  end
+end

data/lib/midler/runner.rb

@@ -0,0 +1,69 @@
+module Midler
+  # This is a basic runner for middleware stacks. This runner does
+  # the default expected behavior of running the middleware stacks
+  # in order, then reversing the order.
+  class Runner
+    # A middleware which does nothing
+    EMPTY_MIDDLEWARE = lambda { |*envs| }
+
+    # Build a new middleware runner with the given middleware
+    # stack.
+    #
+    # Note: This class usually doesn't need to be used directly.
+    # Instead, take a look at using the {Builder} class, which is
+    # a much friendlier way to build up a middleware stack.
+    #
+    # @param [Array] stack An array of the middleware to run.
+    def initialize(stack)
+      # We need to take the stack of middleware and initialize them
+      # all so they call the proper next middleware.
+      @kickoff = build_call_chain(stack)
+    end
+
+    # Run the middleware stack with the given state bag.
+    #
+    # @param [Object] env The state to pass into as the initial
+    #   environment data. This is usual a hash of some sort.
+    def call(*envs)
+      # We just call the kickoff middleware, which is responsible
+      # for properly calling the next middleware, and so on and so
+      # forth.
+      @kickoff.call(*envs)
+    end
+
+    protected
+
+    # This takes a stack of middlewares and initializes them in a way
+    # that each middleware properly calls the next middleware.
+    def build_call_chain(stack)
+      # We need to instantiate the middleware stack in reverse
+      # order so that each middleware can have a reference to
+      # the next middleware it has to call. The final middleware
+      # is always the empty middleware, which does nothing but return.
+      stack.reverse.inject(EMPTY_MIDDLEWARE) do |next_middleware, current_middleware|
+        # Unpack the actual item
+        klass, args, block = current_middleware
+
+        # Default the arguments to an empty array. Otherwise in Ruby 1.8
+        # a `nil` args will actually pass `nil` into the class. Not what
+        # we want!
+        args ||= []
+
+        if klass.is_a?(Class)
+          # If the klass actually is a class, then instantiate it with
+          # the app and any other arguments given.
+          klass.new(next_middleware, *args, &block)
+        elsif klass.respond_to?(:call)
+          # Make it a lambda which calls the item then forwards up
+          # the chain.
+          lambda do |*envs|
+            klass.call(*envs)
+            next_middleware.call(*envs)
+          end
+        else
+          raise "Invalid middleware, doesn't respond to `call`: #{action.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/midler/version.rb

@@ -0,0 +1,3 @@
+module Midler
+  VERSION = "0.1.0"
+end

data/lib/midler.rb

@@ -0,0 +1,3 @@
+require "midler/version"
+require "midler/builder"
+require "midler/runner"

data/midler.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'midler/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "midler"
+  spec.version       = Midler::VERSION
+  spec.authors       = ["Garrett Thornburg"]
+  spec.email         = ["garrett.thornburg@mx.com"]
+  spec.summary       = "A variadic fork of the middleware gem"
+  spec.description   = "A variadic fork of the middleware gem"
+  spec.homepage      = "https://github.com/film42/midler"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec-core", "~> 2.8.0"
+  spec.add_development_dependency "rspec-expectations", "~> 2.8.0"
+  spec.add_development_dependency "rspec-mocks", "~> 2.8.0"
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: midler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Garrett Thornburg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !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: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+description: A variadic fork of the middleware gem
+email:
+- garrett.thornburg@mx.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/midler.rb
+- lib/midler/builder.rb
+- lib/midler/runner.rb
+- lib/midler/version.rb
+- midler.gemspec
+- midler.jpg
+homepage: https://github.com/film42/midler
+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.4.3
+signing_key: 
+specification_version: 4
+summary: A variadic fork of the middleware gem
+test_files: []