stacko 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b62a1d92c1a77f285fe53695f11d533580c7044b
+  data.tar.gz: 974017ed573402b6cfed18e058f230a14a284d40
+SHA512:
+  metadata.gz: c35b59995fe7decf5e81e2e41aa52eb347e42487c10445ad18a22fdc707fc98741afeeca0bcbb1adff104a48de8b4598f0e5d20efb92c8bde3543d43f6b5ff58
+  data.tar.gz: 2b72e21c8a1791d4ca7a45017e857229a042a10ad2f47cf9c7654039521a7ea23eda5c165ef82da27a42113c4252027cde5a2cd42047ca274a44dbe7d546e010

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest, :all_on_start => false do
+  # with Minitest::Spec
+  watch(%r{^spec/(.*)_spec\.rb})
+  watch(%r{^lib/(.+)\.rb})         { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^spec/spec_helper\.rb}) { 'spec' }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Erik Lott
+
+MIT License
+
+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,29 @@
+# Stacko
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'stacko'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stacko
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/stacko/application.rb

@@ -0,0 +1,38 @@
+module Stacko
+  class Application
+    def self.builder
+      @builder ||= Builder.new
+    end
+
+    def self.map(method_name, &block)
+      builder.map(method_name, &block)
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{method_name}(*args)                  # def get_user(*args)
+          execute(:#{method_name}, *args)          #   execute(:get_user, *args)
+        end                                        # end
+      EOT
+    end
+
+    def self.run(app)
+      builder.run(app)
+    end
+
+    def self.use(middleware, *args, &block)
+      builder.use(middleware, *args, &block)
+    end
+
+    def call(*args)
+      execute(:call, *args)
+    end
+
+    private
+
+    def execute(method_name, *args)
+      env = {}
+      env['METHOD_NAME'] = method_name
+      env['ARGUMENTS'] = *args
+  
+      self.class.builder.call(env)
+    end
+  end
+end

data/lib/stacko/builder.rb

@@ -0,0 +1,47 @@
+module Stacko
+  class Builder
+    def initialize(default_app = nil, &block)
+      @run = default_app
+      @use = []
+      @map = nil
+      instance_eval(&block) if block_given?
+    end
+
+    def use(middleware, *args, &block)
+      if @map
+        mapping = @map
+        @map = nil
+        @use << proc { |app| generate_map(app, mapping) }
+      end
+      @use << proc { |app| middleware.new(app, *args, &block) }
+    end
+
+    def run(app)
+      @run = app
+    end
+
+    def map(method_name, &block)
+      @map ||= {}
+      @map[method_name] = block
+    end
+
+    def to_app
+      app = @map ? generate_map(@run, @map) : @run
+      fail "missing run or map statement" unless app
+      app = @use.reverse.inject(app) { |a,e| e[a] }
+      app
+    end
+
+    def call(env)
+      to_app.call(env)
+    end
+
+    private
+
+    def generate_map(default_app, mapping)
+      mapped = default_app ? {:call => default_app} : {}
+      mapping.each { |r,b| mapped[r] = self.class.new(default_app, &b) }
+      MethodMap.new(mapped)
+    end
+  end
+end

data/lib/stacko/exceptions.rb

@@ -0,0 +1,4 @@
+module Stacko
+  class StackoError < StandardError; end
+  class NoMethodError < StackoError; end
+end

data/lib/stacko/method_map.rb

@@ -0,0 +1,13 @@
+module Stacko
+  class MethodMap
+    def initialize(map = {})
+      @map = map
+    end
+
+    def call(env)
+      meth = env['METHOD_NAME']
+      raise(::Stacko::NoMethodError) unless @map.key?(meth)
+      @map[meth].call(env)
+    end
+  end
+end

data/lib/stacko/request.rb

@@ -0,0 +1,17 @@
+module Stacko
+  class Request
+    def initialize(env)
+      @env = env
+    end
+
+    def method_name
+      @env['METHOD_NAME']
+    end
+
+    def arguments
+      @env['ARGUMENTS']
+    end
+  end
+end
+
+

data/lib/stacko/version.rb

@@ -0,0 +1,3 @@
+module Stacko
+  VERSION = "0.0.1"
+end

data/lib/stacko.rb

@@ -0,0 +1,10 @@
+module Stacko
+end
+
+require 'stacko/request'
+require 'stacko/version'
+require 'stacko/request'
+require 'stacko/application'
+require 'stacko/builder'
+require 'stacko/exceptions'
+require 'stacko/method_map'

data/spec/application_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Stacko::Application do
+  def new_application
+    klass = Class.new(Stacko::Application) do
+      use BeaverMiddleware
+
+      map(:method_name_1) do
+        use DogMiddleware
+        run lambda { |env| env['ARGUMENTS'].push(:meth1); env['ARGUMENTS'] }
+      end
+
+      map(:method_name_2) do
+        use HorseMiddleware
+        run lambda { |env| env['ARGUMENTS'].push(:meth2); env['ARGUMENTS'] }
+      end
+
+      run lambda { |env| env['ARGUMENTS'].push(:defaultapp); env['ARGUMENTS'] }
+    end
+    klass.new
+  end
+
+  it 'defined methods for each mapping' do
+    app = new_application
+    app.respond_to?(:method_name_1)
+    app.respond_to?(:method_name_2)
+  end
+
+  it 'responds to call' do
+    app = new_application
+    app.respond_to?(:call)
+  end
+
+  it 'correctly chains apps' do
+    app = new_application
+    app.call.must_equal([:beaver_middleware, :defaultapp])
+    app.method_name_1.must_equal([:beaver_middleware, :dog_middleware, :meth1])
+    app.method_name_2.must_equal([:beaver_middleware, :horse_middleware, :meth2])
+  end
+end

data/spec/builder_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Stacko::Builder do
+  it 'has implicit #to_app' do
+    app = builder do
+      run lambda { |env| {:blah => 'blah'} }
+    end
+
+    app.call({}).must_equal({:blah=>"blah"})
+  end
+
+  it 'has explicit #to_app' do
+    app = builder do
+      run lambda { |env| {:blah => 'blah'} }
+    end
+
+    app.to_app.call({}).must_equal({:blah=>"blah"})
+  end
+
+  it 'chains app by default' do
+    app = builder do
+      use DogMiddleware
+      run lambda { |env| env['ARGUMENTS'].push(:app); env['ARGUMENTS'] }
+    end
+
+    e = new_env(:blah, [])
+    app.call(e).must_equal([:dog_middleware, :app])
+  end
+
+  it 'supports method mapping' do
+    app = builder do
+      map(:method_name_1) do
+        run lambda { |env| 'method_name_1_was_called' }
+      end
+
+      map(:method_name_2) do
+        run lambda { |env| 'method_name_2_was_called' }
+      end
+    end
+
+    env = new_env(:method_name_1)
+    app.call(env).must_equal('method_name_1_was_called')
+
+    env = new_env(:method_name_2)
+    app.call(env).must_equal('method_name_2_was_called')
+  end
+
+  it 'responds to call when mappings exist' do
+    app = builder do
+      map(:method_name_1) do
+        run lambda { |env| 'method_name_1_was_called' }
+      end
+
+      run lambda { |env| 'default app called' }
+    end
+
+    env = new_env(:call)
+    app.call(env).must_equal('default app called')
+  end
+
+  it 'correctly chains app in mappings' do
+    app = builder do
+      use BeaverMiddleware
+
+      map(:method_name_1) do
+        use DogMiddleware
+        run lambda { |env| env['ARGUMENTS'].push(:meth1); env['ARGUMENTS'] }
+      end
+
+      map(:method_name_2) do
+        use HorseMiddleware
+        run lambda { |env| env['ARGUMENTS'].push(:meth2); env['ARGUMENTS'] }
+      end
+
+      run lambda { |env| env['ARGUMENTS'].push(:defaultapp); env['ARGUMENTS'] }
+    end
+
+    e = new_env(:call, [])
+    app.call(e).must_equal([:beaver_middleware, :defaultapp])
+
+    e = new_env(:method_name_1, [])
+    app.call(e).must_equal([:beaver_middleware, :dog_middleware, :meth1])
+
+    e = new_env(:method_name_2, [])
+    app.call(e).must_equal([:beaver_middleware, :horse_middleware, :meth2])
+  end
+
+  it 'fails if run is missing' do
+    app = builder do
+      # no run statement
+    end
+    proc { app.call({}) } .must_raise(RuntimeError)
+  end
+
+  def builder(&block)
+    Stacko::Builder.new(&block)
+  end
+
+  def new_env(method_name, arguments=nil)
+    {
+      'METHOD_NAME' => method_name,
+      'ARGUMENTS' => arguments
+    }
+  end
+end

data/spec/method_map_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Stacko::MethodMap do
+  it 'dispatches map correctly' do
+    map = Stacko::MethodMap.new(
+      :method_1 => Proc.new{ |env| 'method_1 called' },
+      :method_2 => Proc.new{ |env| 'method_2 called' }
+    )
+    
+    env = new_env(:method_1)
+    map.call(env).must_equal('method_1 called')
+
+    env = new_env(:method_2)
+    map.call(env).must_equal('method_2 called')
+  end
+
+  it 'complains when map not found' do
+    map = Stacko::MethodMap.new(
+      :method_1 => Proc.new{ |env| 'method_1 called' }
+    )
+    
+    env = new_env(:non_existant_method)
+    proc { map.call(env) }.must_raise(Stacko::NoMethodError)
+  end
+
+  def new_env(method_name)
+    {'METHOD_NAME' => method_name}
+  end
+end

data/spec/request_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Stacko::Request do
+  def request
+    Stacko::Request.new(
+      'METHOD_NAME' => :login,
+      'ARGUMENTS' => {:blah => 'blah'}
+    )
+  end
+
+  it 'returns arguments' do
+    request.arguments.must_equal({:blah => 'blah'})
+  end
+
+  it 'returns method name' do
+    request.method_name.must_equal(:login)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'minitest/autorun'
+require 'mocha/setup'
+require 'stacko'
+
+def context *args, &block
+  describe *args, &block
+end
+
+class DogMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    env['ARGUMENTS'].push(:dog_middleware)
+    @app.call(env)
+  end
+end
+
+class HorseMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    env['ARGUMENTS'].push(:horse_middleware)
+    @app.call(env)
+  end
+end
+
+class BeaverMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    env['ARGUMENTS'].push(:beaver_middleware)
+    @app.call(env)
+  end
+end

data/stacko.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stacko/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "stacko"
+  spec.version       = Stacko::VERSION
+  spec.authors       = ["Erik Lott"]
+  spec.email         = ["erik.lott@kodio.com"]
+  spec.description   = %q{Stackable message interface for ruby}
+  spec.summary       = %q{Stackable message interface for ruby}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "mocha", "~> 0.14.0"
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: stacko
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Erik Lott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+description: Stackable message interface for ruby
+email:
+- erik.lott@kodio.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/stacko.rb
+- lib/stacko/application.rb
+- lib/stacko/builder.rb
+- lib/stacko/exceptions.rb
+- lib/stacko/method_map.rb
+- lib/stacko/request.rb
+- lib/stacko/version.rb
+- spec/application_spec.rb
+- spec/builder_spec.rb
+- spec/method_map_spec.rb
+- spec/request_spec.rb
+- spec/spec_helper.rb
+- stacko.gemspec
+homepage: ''
+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.0.7
+signing_key: 
+specification_version: 4
+summary: Stackable message interface for ruby
+test_files:
+- spec/application_spec.rb
+- spec/builder_spec.rb
+- spec/method_map_spec.rb
+- spec/request_spec.rb
+- spec/spec_helper.rb