jellyfish 1.0.2 → 1.1.0

data/test/rack/test_urlmap.rb

@@ -0,0 +1,180 @@
+
+require 'jellyfish/test'
+require 'jellyfish/urlmap'
+
+require 'rack/mock'
+
+describe Jellyfish::URLMap do
+  would "dispatches paths correctly" do
+    app = lambda { |env|
+      [200, {
+        'X-ScriptName' => env['SCRIPT_NAME'],
+        'X-PathInfo' => env['PATH_INFO'],
+        'Content-Type' => 'text/plain'
+      }, [""]]
+    }
+    map = Rack::Lint.new(Jellyfish::URLMap.new({
+      '/bar' => app,
+      '/foo' => app,
+      '/foo/bar' => app
+    }))
+
+    res = Rack::MockRequest.new(map).get("/")
+    res.should.not_found?
+
+    res = Rack::MockRequest.new(map).get("/qux")
+    res.should.not_found?
+
+    res = Rack::MockRequest.new(map).get("/foo")
+    res.should.ok?
+    res["X-ScriptName"].should.eq "/foo"
+    res["X-PathInfo"].should.eq ""
+
+    res = Rack::MockRequest.new(map).get("/foo/")
+    res.should.ok?
+    res["X-ScriptName"].should.eq "/foo"
+    res["X-PathInfo"].should.eq "/"
+
+    res = Rack::MockRequest.new(map).get("/foo/bar")
+    res.should.ok?
+    res["X-ScriptName"].should.eq "/foo/bar"
+    res["X-PathInfo"].should.eq ""
+
+    res = Rack::MockRequest.new(map).get("/foo/bar/")
+    res.should.ok?
+    res["X-ScriptName"].should.eq "/foo/bar"
+    res["X-PathInfo"].should.eq "/"
+
+    res = Rack::MockRequest.new(map).get("/foo///bar//quux")
+    res.status.should.eq 200
+    res.should.ok?
+    res["X-ScriptName"].should.eq "/foo/bar"
+    res["X-PathInfo"].should.eq "//quux"
+
+    res = Rack::MockRequest.new(map).get("/foo/quux", "SCRIPT_NAME" => "/bleh")
+    res.should.ok?
+    res["X-ScriptName"].should.eq "/bleh/foo"
+    res["X-PathInfo"].should.eq "/quux"
+
+    res = Rack::MockRequest.new(map).get("/bar", 'HTTP_HOST' => 'foo.org')
+    res.should.ok?
+    res["X-ScriptName"].should.eq "/bar"
+    res["X-PathInfo"].should.empty?
+
+    res = Rack::MockRequest.new(map).get("/bar/", 'HTTP_HOST' => 'foo.org')
+    res.should.ok?
+    res["X-ScriptName"].should.eq "/bar"
+    res["X-PathInfo"].should.eq '/'
+  end
+
+  would "be nestable" do
+    map = Rack::Lint.new(Rack::URLMap.new("/foo" =>
+      Rack::URLMap.new("/bar" =>
+        Rack::URLMap.new("/quux" =>  lambda { |env|
+                           [200,
+                            { "Content-Type" => "text/plain",
+                              "X-Position" => "/foo/bar/quux",
+                              "X-PathInfo" => env["PATH_INFO"],
+                              "X-ScriptName" => env["SCRIPT_NAME"],
+                            }, [""]]}
+                         ))))
+
+    res = Rack::MockRequest.new(map).get("/foo/bar")
+    res.should.not_found?
+
+    res = Rack::MockRequest.new(map).get("/foo/bar/quux")
+    res.should.ok?
+    res["X-Position"].should.eq "/foo/bar/quux"
+    res["X-PathInfo"].should.eq ""
+    res["X-ScriptName"].should.eq "/foo/bar/quux"
+  end
+
+  would "route root apps correctly" do
+    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "root",
+                                "X-PathInfo" => env["PATH_INFO"],
+                                "X-ScriptName" => env["SCRIPT_NAME"]
+                              }, [""]]},
+                           "/foo" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "foo",
+                                "X-PathInfo" => env["PATH_INFO"],
+                                "X-ScriptName" => env["SCRIPT_NAME"]
+                              }, [""]]}
+                           ))
+
+    res = Rack::MockRequest.new(map).get("/foo/bar")
+    res.should.ok?
+    res["X-Position"].should.eq "foo"
+    res["X-PathInfo"].should.eq "/bar"
+    res["X-ScriptName"].should.eq "/foo"
+
+    res = Rack::MockRequest.new(map).get("/foo")
+    res.should.ok?
+    res["X-Position"].should.eq "foo"
+    res["X-PathInfo"].should.eq ""
+    res["X-ScriptName"].should.eq "/foo"
+
+    res = Rack::MockRequest.new(map).get("/bar")
+    res.should.ok?
+    res["X-Position"].should.eq "root"
+    res["X-PathInfo"].should.eq "/bar"
+    res["X-ScriptName"].should.eq ""
+
+    res = Rack::MockRequest.new(map).get("")
+    res.should.ok?
+    res["X-Position"].should.eq "root"
+    res["X-PathInfo"].should.eq "/"
+    res["X-ScriptName"].should.eq ""
+  end
+
+  would "not squeeze slashes" do
+    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "root",
+                                "X-PathInfo" => env["PATH_INFO"],
+                                "X-ScriptName" => env["SCRIPT_NAME"]
+                              }, [""]]},
+                           "/foo" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "foo",
+                                "X-PathInfo" => env["PATH_INFO"],
+                                "X-ScriptName" => env["SCRIPT_NAME"]
+                              }, [""]]}
+                           ))
+
+    res = Rack::MockRequest.new(map).get("/http://example.org/bar")
+    res.should.ok?
+    res["X-Position"].should.eq "root"
+    res["X-PathInfo"].should.eq "/http://example.org/bar"
+    res["X-ScriptName"].should.eq ""
+  end
+
+  would "not be case sensitive with hosts" do
+    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "root",
+                                "X-PathInfo" => env["PATH_INFO"],
+                                "X-ScriptName" => env["SCRIPT_NAME"]
+                              }, [""]]}
+                           ))
+
+    res = Rack::MockRequest.new(map).get("/")
+    res.should.ok?
+    res["X-Position"].should.eq "root"
+    res["X-PathInfo"].should.eq "/"
+    res["X-ScriptName"].should.eq ""
+
+    res = Rack::MockRequest.new(map).get("/")
+    res.should.ok?
+    res["X-Position"].should.eq "root"
+    res["X-PathInfo"].should.eq "/"
+    res["X-ScriptName"].should.eq ""
+  end
+end

data/test/sinatra/test_base.rb

@@ -98,7 +98,7 @@ describe 'Sinatra base_test.rb' do
       status                   .should.eq 210
       headers['X-Downstream']  .should.eq 'true'
       headers['Content-Length'].should.eq '28'
-      body                     .should.eq ['Hello after explicit forward']
+      body.to_a                .should.eq ['Hello after explicit forward']
     end
   end
 end

data/test/sinatra/test_routing.rb

@@ -292,66 +292,6 @@ describe 'Sinatra routing_test.rb' do
       should.raise(TypeError)
   end
 
-  would 'return response immediately on next or halt' do
-    app = Class.new{
-      include Jellyfish
-      controller_include Jellyfish::MultiActions
-
-      get '/next' do
-        body 'Hello World'
-        next
-      end
-
-      get '/halt' do
-        body 'Hello World'
-        halt
-        'Boo-hoo World'
-      end
-    }.new
-
-    %w[/next /halt].each do |path|
-      status, _, body = get(path, app)
-      status.should.eq 200
-      body  .should.eq ['Hello World']
-    end
-  end
-
-  would 'halt with a response tuple' do
-    app = Class.new{
-      include Jellyfish
-      controller_include Jellyfish::MultiActions
-
-      get '/' do
-        halt [295, {'Content-Type' => 'text/plain'}, ['Hello World']]
-      end
-    }.new
-
-    status, headers, body = get('/', app)
-    status                 .should.eq 295
-    headers['Content-Type'].should.eq 'text/plain'
-    body                   .should.eq ['Hello World']
-  end
-
-  would 'transition to the next matching route on next' do
-    app = Class.new{
-      include Jellyfish
-      controller_include Jellyfish::MultiActions, Jellyfish::NormalizedParams
-      get %r{^/(?<foo>\w+)} do
-        params['foo'].should.eq 'bar'
-        next
-      end
-
-      get do
-        params.should.not.include?('foo')
-        'Hello World'
-      end
-    }.new
-
-    status, _, body = get('/bar', app)
-    status.should.eq 200
-    body  .should.eq ['Hello World']
-  end
-
   would 'match routes defined in superclasses' do
     sup = Class.new{
       include Jellyfish

data/test/test_from_readme.rb

@@ -20,27 +20,38 @@ describe 'from README.md' do
     next if title =~ /NewRelic/i
 
     would "pass from README.md #%02d #{title}" % index do
-      method_path, expect = test.strip.split("\n", 2)
-      method, path        = method_path.split(' ')
-      uri                 = URI.parse(path)
-      pinfo, query        = uri.path, uri.query
-
-      sock = nil
-      status, headers, body = File.open(File::NULL) do |input|
-        Rack::Builder.app{ eval(code) }.call(
-          'REQUEST_METHOD' => method, 'PATH_INFO'  => pinfo,
-          'QUERY_STRING'   => query , 'SCRIPT_NAME'=> ''   ,
-          'rack.input'     => input ,
-          'rack.hijack'    => lambda{
-            sock = StringIO.new
-            # or TypeError: no implicit conversion of StringIO into IO
-            mock(IO).select([sock]){ [[sock], [], []] }
-            sock
-          })
-      end
+      app = Rack::Builder.app{ eval(code) }
+
+      test.split("\n\n").each do |t|
+        method_path, expect = t.strip.split("\n", 2)
+        method, path        = method_path.split(' ')
+        uri                 = URI.parse(path)
+        pinfo, query        = uri.path, uri.query
+
+        sock = nil
+        status, headers, body = File.open(File::NULL) do |input|
+          app.call(
+            'HTTP_VERSION'   => 'HTTP/1.1',
+            'REQUEST_METHOD' => method, 'PATH_INFO'  => pinfo,
+            'QUERY_STRING'   => query , 'SCRIPT_NAME'=> ''   ,
+            'rack.input'     => input ,
+            'rack.hijack'    => lambda{
+              sock = StringIO.new
+              # or TypeError: no implicit conversion of StringIO into IO
+              mock(IO).select([sock]){ [[sock], [], []] }
+              sock
+            })
+        end
 
-      body.extend(Enumerable)
-      [status, headers, body.to_a].should.eq eval(expect, binding, __FILE__)
+        if hijack = headers.delete('rack.hijack')
+          sock = StringIO.new
+          hijack.call(sock)
+          body = sock.string.each_line("\n\n")
+        end
+
+        body.extend(Enumerable)
+        [status, headers, body.to_a].should.eq eval(expect, binding, __FILE__)
+      end
     end
   end
 end

metadata

@@ -1,18 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: jellyfish
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-09 00:00:00.000000000 Z
+date: 2015-09-25 00:00:00.000000000 Z
 dependencies: []
 description: |-
   Pico web framework for building API-centric web applications.
-  For Rack applications or Rack middlewares. Around 250 lines of code.
+  For Rack applications or Rack middleware. Around 250 lines of code.
+
+  Check [jellyfish-contrib][] for extra extensions.
+
+  [jellyfish-contrib]: https://github.com/godfat/jellyfish-contrib
 email:
 - godfat (XD) godfat.org
 executables: []
@@ -28,42 +32,36 @@ files:
 - README.md
 - Rakefile
 - TODO.md
+- bench/bench_builder.rb
 - config.ru
 - jellyfish.gemspec
 - jellyfish.png
 - lib/jellyfish.rb
+- lib/jellyfish/builder.rb
 - lib/jellyfish/chunked_body.rb
 - lib/jellyfish/json.rb
-- lib/jellyfish/multi_actions.rb
 - lib/jellyfish/newrelic.rb
 - lib/jellyfish/normalized_params.rb
 - lib/jellyfish/normalized_path.rb
 - lib/jellyfish/public/302.html
 - lib/jellyfish/public/404.html
 - lib/jellyfish/public/500.html
-- lib/jellyfish/sinatra.rb
-- lib/jellyfish/swagger.rb
 - lib/jellyfish/test.rb
+- lib/jellyfish/urlmap.rb
 - lib/jellyfish/version.rb
 - lib/jellyfish/websocket.rb
-- public/css/screen.css
-- public/index.html
-- public/js/shred.bundle.js
-- public/js/shred/content.js
-- public/js/swagger-ui.js
-- public/js/swagger.js
 - task/README.md
 - task/gemgem.rb
+- test/rack/test_builder.rb
+- test/rack/test_urlmap.rb
 - test/sinatra/test_base.rb
 - test/sinatra/test_chunked_body.rb
 - test/sinatra/test_error.rb
-- test/sinatra/test_multi_actions.rb
 - test/sinatra/test_routing.rb
 - test/test_from_readme.rb
 - test/test_inheritance.rb
 - test/test_log.rb
 - test/test_misc.rb
-- test/test_swagger.rb
 - test/test_threads.rb
 - test/test_websocket.rb
 homepage: https://github.com/godfat/jellyfish
@@ -86,20 +84,20 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Pico web framework for building API-centric web applications.
 test_files:
+- test/rack/test_builder.rb
+- test/rack/test_urlmap.rb
 - test/sinatra/test_base.rb
 - test/sinatra/test_chunked_body.rb
 - test/sinatra/test_error.rb
-- test/sinatra/test_multi_actions.rb
 - test/sinatra/test_routing.rb
 - test/test_from_readme.rb
 - test/test_inheritance.rb
 - test/test_log.rb
 - test/test_misc.rb
-- test/test_swagger.rb
 - test/test_threads.rb
 - test/test_websocket.rb

data/lib/jellyfish/multi_actions.rb

@@ -1,31 +0,0 @@
-
-require 'jellyfish'
-
-
-
-module Jellyfish
-  module MultiActions
-    def call env
-      @env = env
-      dispatch.inject(nil){ |_, route_block| block_call(*route_block) }
-    end
-
-    def dispatch
-      acts = actions.map{ |(route, block)|
-        case route
-        when String
-          [route, block] if route == path_info
-        else#Regexp, using else allows you to use custom matcher
-          match = route.match(path_info)
-          [match, block] if match
-        end
-      }.compact
-
-      if acts.empty?
-        action_missing
-      else
-        acts
-      end
-    end
-  end
-end

data/lib/jellyfish/sinatra.rb

@@ -1,13 +0,0 @@
-
-require 'jellyfish'
-require 'jellyfish/multi_actions'
-require 'jellyfish/normalized_params'
-require 'jellyfish/normalized_path'
-
-module Jellyfish
-  module Sinatra
-    include MultiActions
-    include NormalizedParams
-    include NormalizedPath
-  end
-end