jellyfish 1.0.2 → 1.1.0

data/config.ru

@@ -17,20 +17,6 @@ class Jelly
     end
   }
 
-  def self.info
-    {:title       => 'Jellyfish Swagger UI',
-     :description =>
-       'This is a simple example for using Jellyfish and' \
-       ' Swagger UI altogether. You could also try the'   \
-       ' <a href="http://swagger.wordnik.com/">official Swagger UI app</a>,' \
-       ' and fill it with the swagger URL.'
-     }
-  end
-
-  def self.swagger_apiVersion
-    '1.0.0'
-  end
-
   handle Jellyfish::NotFound do |e|
     status 404
     body   %Q|{"error":{"name":"NotFound"}}\n|
@@ -46,30 +32,15 @@ class Jelly
     body render('error' => {'name' => name, 'message' => message})
   end
 
-  get '/users',
-    :summary => 'List users',
-    :notes   => 'Note that we do not really have users.' do
+  get '/users' do
     render [:name => 'jellyfish']
   end
 
-  post '/users',
-    :summary => 'Create a user',
-    :notes   => 'Here we demonstrate how to write the swagger doc.',
-    :parameters => {:name => {:type => :string, :required => true,
-                              :description => 'The name of the user'},
-                    :sane => {:type => :boolean,
-                              :description => 'If the user is sane'},
-                    :type => {:type => :string,
-                              :description => 'What kind of user',
-                              :enum => %w[good neutral evil]}},
-    :responseMessages => [{:code => 400, :message => 'Invalid name'}] do
+  post '/users' do
     render :message => "jellyfish #{request.params['name']} created."
   end
 
-  put %r{\A/users/(?<id>\d+)},
-    :summary => 'Update a user',
-    :parameters => {:id => {:type => :integer,
-                            :description => 'The id of the user'}} do |match|
+  put %r{\A/users/(?<id>\d+)} do |match|
     render :message => "jellyfish ##{match[:id]} updated."
   end
 
@@ -77,8 +48,7 @@ class Jelly
     render :message => "jellyfish ##{match[:id]} deleted."
   end
 
-  get %r{\A/posts/(?<year>\d+)-(?<month>\d+)/(?<name>\w+)},
-    :summary => 'Get a post' do |match|
+  get %r{\A/posts/(?<year>\d+)-(?<month>\d+)/(?<name>\w+)} do |match|
     render Hash[match.names.zip(match.captures)]
   end
 
@@ -87,16 +57,12 @@ class Jelly
   end
 end
 
-App = Rack::Builder.app do
+App = Jellyfish::Builder.app do
   use Rack::CommonLogger
   use Rack::Chunked
   use Rack::ContentLength
   use Rack::Deflater
 
-  map '/swagger' do
-    run Jellyfish::Swagger.new('', Jelly)
-  end
-
   run Rack::Cascade.new([Rack::File.new('public/index.html'),
                          Rack::File.new('public'),
                          Jelly.new])

data/jellyfish.gemspec

@@ -1,15 +1,15 @@
 # -*- encoding: utf-8 -*-
-# stub: jellyfish 1.0.2 ruby lib
+# stub: jellyfish 1.1.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "jellyfish"
-  s.version = "1.0.2"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Lin Jen-Shin (godfat)"]
-  s.date = "2014-12-09"
-  s.description = "Pico web framework for building API-centric web applications.\nFor Rack applications or Rack middlewares. Around 250 lines of code."
+  s.date = "2015-09-25"
+  s.description = "Pico web framework for building API-centric web applications.\nFor Rack applications or Rack middleware. Around 250 lines of code.\n\nCheck [jellyfish-contrib][] for extra extensions.\n\n[jellyfish-contrib]: https://github.com/godfat/jellyfish-contrib"
   s.email = ["godfat (XD) godfat.org"]
   s.files = [
   ".gitignore",
@@ -21,59 +21,53 @@ Gem::Specification.new do |s|
   "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"]
   s.homepage = "https://github.com/godfat/jellyfish"
   s.licenses = ["Apache License 2.0"]
-  s.rubygems_version = "2.4.5"
+  s.rubygems_version = "2.4.8"
   s.summary = "Pico web framework for building API-centric web applications."
   s.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"]
 end

data/lib/jellyfish.rb

@@ -1,14 +1,12 @@
 
 module Jellyfish
   autoload :VERSION , 'jellyfish/version'
-  autoload :Sinatra , 'jellyfish/sinatra'
-  autoload :Swagger , 'jellyfish/swagger'
   autoload :NewRelic, 'jellyfish/newrelic'
 
-  autoload :MultiActions    , 'jellyfish/multi_actions'
   autoload :NormalizedParams, 'jellyfish/normalized_params'
   autoload :NormalizedPath  , 'jellyfish/normalized_path'
 
+  autoload :Builder    , 'jellyfish/builder'
   autoload :ChunkedBody, 'jellyfish/chunked_body'
   autoload :WebSocket  , 'jellyfish/websocket'
 

data/lib/jellyfish/builder.rb

@@ -0,0 +1,52 @@
+
+require 'jellyfish/urlmap'
+
+module Jellyfish
+  class Builder
+    def self.app app=nil, &block
+      new(app, &block).to_app
+    end
+
+    def initialize app=nil, &block
+      @use, @map, @run, @warmup = [], nil, app, nil
+      instance_eval(&block) if block_given?
+    end
+
+    def use middleware, *args, &block
+      if @map
+        current_map, @map = @map, nil
+        @use.unshift(lambda{ |app| generate_map(current_map, app) })
+      end
+      @use.unshift(lambda{ |app| middleware.new(app, *args, &block) })
+    end
+
+    def run app
+      @run = app
+    end
+
+    def warmup lam=nil, &block
+      @warmup = lam || block
+    end
+
+    def map path, &block
+      (@map ||= {})[path] = block
+    end
+
+    def to_app
+      run = if @map then generate_map(@map, @run) else @run end
+      fail 'missing run or map statement' unless run
+      app = @use.inject(run){ |a, m| m.call(a) }
+      @warmup.call(app) if @warmup
+      app
+    end
+
+    private
+    def generate_map current_map, app
+      mapped = if app then {'' => app} else {} end
+      current_map.each do |path, block|
+        mapped[path.chomp('/')] = self.class.app(app, &block)
+      end
+      URLMap.new(mapped)
+    end
+  end
+end

data/lib/jellyfish/test.rb

@@ -9,15 +9,15 @@ Pork::Executor.__send__(:include, Muack::API)
 copy :jellyfish do
   module_eval(%w[options get head post put delete patch].map{ |method|
     <<-RUBY
-      def #{method} path='/', app=app, env={}
+      def #{method} path='/', a=app, env={}
         File.open(File::NULL) do |input|
-          app.call({'PATH_INFO'      => path              ,
-                    'REQUEST_METHOD' => '#{method}'.upcase,
-                    'SCRIPT_NAME'    => ''                ,
-                    'rack.input'     => input             ,
-                    'rack.url_scheme'=> 'https'           ,
-                    'SERVER_NAME'    => 'localhost'       ,
-                    'SERVER_PORT'    => '8080'}.merge(env))
+          a.call({'PATH_INFO'      => path              ,
+                  'REQUEST_METHOD' => '#{method}'.upcase,
+                  'SCRIPT_NAME'    => ''                ,
+                  'rack.input'     => input             ,
+                  'rack.url_scheme'=> 'https'           ,
+                  'SERVER_NAME'    => 'localhost'       ,
+                  'SERVER_PORT'    => '8080'}.merge(env))
         end
       end
     RUBY

data/lib/jellyfish/urlmap.rb

@@ -0,0 +1,26 @@
+
+module Jellyfish
+  class URLMap
+    def initialize mapped
+      string = mapped.keys.sort_by{ |k| -k.size }.
+        map{ |k| Regexp.escape(k).gsub('/', '/+') }.
+        join('|')
+
+      @mapped = mapped
+      @routes = Regexp.new("\\A(?:#{string})(?:/|\\z)", 'i', 'n')
+    end
+
+    def call env
+      path_info = env['PATH_INFO']
+      matched   = @routes.match(path_info).to_s.chomp('/')
+      squeezed  = matched.squeeze('/')
+
+      if app = @mapped[squeezed]
+        app.call(env.merge('PATH_INFO' => path_info[matched.size..-1],
+                           'SCRIPT_NAME' => env['SCRIPT_NAME'] + squeezed))
+      else
+        [404, {}, []]
+      end
+    end
+  end
+end

data/lib/jellyfish/version.rb

@@ -1,4 +1,4 @@
 
 module Jellyfish
-  VERSION = '1.0.2'
+  VERSION = '1.1.0'
 end

data/task/gemgem.rb

@@ -79,6 +79,11 @@ module Gemgem
   end
 
   def gem_check
+    unless git('status', '--porcelain').empty?
+      puts("\e[35mWorking copy is not clean.\e[0m")
+      exit(3)
+    end
+
     ver = spec.version.to_s
 
     if ENV['VERSION'].nil?
@@ -100,8 +105,12 @@ module Gemgem
     if ENV['COV'] || ENV['CI']
       require 'simplecov'
       if ENV['CI']
-        require 'coveralls'
-        SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+        begin
+          require 'coveralls'
+          SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+        rescue LoadError => e
+          puts "Cannot load coveralls, skip: #{e}"
+        end
       end
       SimpleCov.start do
         add_filter('test/')

data/test/rack/test_builder.rb

@@ -0,0 +1,154 @@
+
+require 'jellyfish/test'
+
+require 'rack/lint'
+require 'rack/mock'
+require 'rack/showexceptions'
+require 'rack/urlmap'
+
+describe Jellyfish::Builder do
+  class NothingMiddleware
+    def initialize(app)
+      @app = app
+    end
+    def call(env)
+      @@env = env
+      response = @app.call(env)
+      response
+    end
+    def self.env
+      @@env
+    end
+  end
+
+  def builder_to_app(&block)
+    Rack::Lint.new Jellyfish::Builder.app(&block)
+  end
+
+  would "supports mapping" do
+    app = builder_to_app do
+      map '/' do |outer_env|
+        run lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, ['root']] }
+      end
+      map '/sub' do
+        run lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, ['sub']] }
+      end
+    end
+    Rack::MockRequest.new(app).get("/").body.to_s.should.eq 'root'
+    Rack::MockRequest.new(app).get("/sub").body.to_s.should.eq 'sub'
+  end
+
+  would "chains apps by default" do
+    app = builder_to_app do
+      use Rack::ShowExceptions
+      run lambda { |env| raise "bzzzt" }
+    end
+
+    Rack::MockRequest.new(app).get("/").should.server_error?
+    Rack::MockRequest.new(app).get("/").should.server_error?
+    Rack::MockRequest.new(app).get("/").should.server_error?
+  end
+
+  would "supports blocks on use" do
+    app = builder_to_app do
+      use Rack::ShowExceptions
+      use Rack::Auth::Basic do |username, password|
+        'secret' == password
+      end
+
+      run lambda { |env| [200, {"Content-Type" => "text/plain"}, ['Hi Boss']] }
+    end
+
+    response = Rack::MockRequest.new(app).get("/")
+    response.should.client_error?
+    response.status.should.eq 401
+
+    # with auth...
+    response = Rack::MockRequest.new(app).get("/",
+        'HTTP_AUTHORIZATION' => 'Basic ' + ["joe:secret"].pack("m*"))
+    response.status.should.eq 200
+    response.body.to_s.should.eq 'Hi Boss'
+  end
+
+  would "has explicit #to_app" do
+    app = builder_to_app do
+      use Rack::ShowExceptions
+      run lambda { |env| raise "bzzzt" }
+    end
+
+    Rack::MockRequest.new(app).get("/").should.server_error?
+    Rack::MockRequest.new(app).get("/").should.server_error?
+    Rack::MockRequest.new(app).get("/").should.server_error?
+  end
+
+  would "can mix map and run for endpoints" do
+    app = builder_to_app do
+      map '/sub' do
+        run lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, ['sub']] }
+      end
+      run lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, ['root']] }
+    end
+
+    Rack::MockRequest.new(app).get("/").body.to_s.should.eq 'root'
+    Rack::MockRequest.new(app).get("/sub").body.to_s.should.eq 'sub'
+  end
+
+  would "accepts middleware-only map blocks" do
+    app = builder_to_app do
+      map('/foo') { use Rack::ShowExceptions }
+      run lambda { |env| raise "bzzzt" }
+    end
+
+    proc { Rack::MockRequest.new(app).get("/") }.should.raise(RuntimeError)
+    Rack::MockRequest.new(app).get("/foo").should.server_error?
+  end
+
+  would "yields the generated app to a block for warmup" do
+    warmed_up_app = nil
+
+    app = Rack::Builder.new do
+      warmup { |a| warmed_up_app = a }
+      run lambda { |env| [200, {}, []] }
+    end.to_app
+
+    warmed_up_app.should.eq app
+  end
+
+  would "initialize apps once" do
+    app = builder_to_app do
+      class AppClass
+        def initialize
+          @called = 0
+        end
+        def call(env)
+          raise "bzzzt"  if @called > 0
+        @called += 1
+          [200, {'Content-Type' => 'text/plain'}, ['OK']]
+        end
+      end
+
+      use Rack::ShowExceptions
+      run AppClass.new
+    end
+
+    Rack::MockRequest.new(app).get("/").status.should.eq 200
+    Rack::MockRequest.new(app).get("/").should.server_error?
+  end
+
+  would "allows use after run" do
+    app = builder_to_app do
+      run lambda { |env| raise "bzzzt" }
+      use Rack::ShowExceptions
+    end
+
+    Rack::MockRequest.new(app).get("/").should.server_error?
+    Rack::MockRequest.new(app).get("/").should.server_error?
+    Rack::MockRequest.new(app).get("/").should.server_error?
+  end
+
+  would 'complains about a missing run' do
+    proc do
+      Rack::Lint.new Rack::Builder.app { use Rack::ShowExceptions }
+    end.should.raise(RuntimeError)
+  end
+end