jellyfish 0.9.2 → 1.0.0

data/jellyfish.gemspec

@@ -1,13 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: jellyfish 0.9.2 ruby lib
+# stub: jellyfish 1.0.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "jellyfish"
-  s.version = "0.9.2"
+  s.version = "1.0.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 = "2013-09-26"
+  s.date = "2014-03-17"
   s.description = "Pico web framework for building API-centric web applications.\nFor Rack applications or Rack middlewares. Around 250 lines of code."
   s.email = ["godfat (XD) godfat.org"]
   s.files = [
@@ -20,10 +21,12 @@ Gem::Specification.new do |s|
   "README.md",
   "Rakefile",
   "TODO.md",
+  "config.ru",
   "jellyfish.gemspec",
   "jellyfish.png",
   "lib/jellyfish.rb",
   "lib/jellyfish/chunked_body.rb",
+  "lib/jellyfish/json.rb",
   "lib/jellyfish/multi_actions.rb",
   "lib/jellyfish/newrelic.rb",
   "lib/jellyfish/normalized_params.rb",
@@ -32,9 +35,16 @@ Gem::Specification.new do |s|
   "lib/jellyfish/public/404.html",
   "lib/jellyfish/public/500.html",
   "lib/jellyfish/sinatra.rb",
+  "lib/jellyfish/swagger.rb",
   "lib/jellyfish/test.rb",
   "lib/jellyfish/version.rb",
-  "task/.gitignore",
+  "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/sinatra/test_base.rb",
   "test/sinatra/test_chunked_body.rb",
@@ -43,11 +53,13 @@ Gem::Specification.new do |s|
   "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"]
   s.homepage = "https://github.com/godfat/jellyfish"
   s.licenses = ["Apache License 2.0"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "2.1.5"
+  s.rubygems_version = "2.2.2"
   s.summary = "Pico web framework for building API-centric web applications."
   s.test_files = [
   "test/sinatra/test_base.rb",
@@ -57,23 +69,8 @@ Gem::Specification.new do |s|
   "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"]
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rack>, [">= 0"])
-      s.add_development_dependency(%q<bacon>, [">= 0"])
-      s.add_development_dependency(%q<muack>, [">= 0"])
-    else
-      s.add_dependency(%q<rack>, [">= 0"])
-      s.add_dependency(%q<bacon>, [">= 0"])
-      s.add_dependency(%q<muack>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rack>, [">= 0"])
-    s.add_dependency(%q<bacon>, [">= 0"])
-    s.add_dependency(%q<muack>, [">= 0"])
-  end
 end

data/lib/jellyfish.rb

@@ -2,6 +2,7 @@
 module Jellyfish
   autoload :VERSION , 'jellyfish/version'
   autoload :Sinatra , 'jellyfish/sinatra'
+  autoload :Swagger , 'jellyfish/swagger'
   autoload :NewRelic, 'jellyfish/newrelic'
 
   autoload :MultiActions    , 'jellyfish/multi_actions'
@@ -10,8 +11,8 @@ module Jellyfish
 
   autoload :ChunkedBody, 'jellyfish/chunked_body'
 
+  Cascade  = Object.new
   GetValue = Object.new
-  Identity = lambda{|_|_}
 
   class Response < RuntimeError
     def headers
@@ -49,16 +50,18 @@ module Jellyfish
 
     def block_call argument, block
       val = instance_exec(argument, &block)
-      [status || 200, headers || {}, body || with_each(val || '')]
+      [status || 200, headers || {}, body || rack_body(val || '')]
     rescue LocalJumpError
-      jellyfish.log("Use `next' if you're trying to `return' or" \
-                    " `break' from the block.", env['rack.errors'])
+      log("Use `next' if you're trying to `return' or `break' from a block.")
       raise
     end
 
+    def log     message; jellyfish.log(    message, env['rack.errors']); end
+    def log_error error; jellyfish.log_error(error, env['rack.errors']); end
     def request   ; @request ||= Rack::Request.new(env); end
     def halt *args; throw(:halt, *args)                ; end
-    def forward   ;  halt(Jellyfish::NotFound.new)     ; end
+    def cascade   ;  halt(Jellyfish::Cascade)          ; end
+    def not_found ;  halt(Jellyfish::NotFound.new)     ; end
     def found  url;  halt(Jellyfish::   Found.new(url)); end
     alias_method :redirect, :found
 
@@ -83,7 +86,7 @@ module Jellyfish
       elsif value.nil?
         @body = value
       else
-        @body = with_each(value)
+        @body = rack_body(value)
       end
     end
 
@@ -97,7 +100,7 @@ module Jellyfish
 
     private
     def actions
-      routes[request_method.downcase] || halt(Jellyfish::NotFound.new)
+      routes[request_method.downcase] || action_missing
     end
 
     def dispatch
@@ -109,11 +112,15 @@ module Jellyfish
           match = route.match(path_info)
           break match, block if match
         end
-      } || halt(Jellyfish::NotFound.new)
+      } || action_missing
     end
 
-    def with_each value
-      if value.respond_to?(:each) then value else [value] end
+    def action_missing
+      if jellyfish.app then cascade else not_found end
+    end
+
+    def rack_body v
+      if v.respond_to?(:each) || v.respond_to?(:to_path) then v else [v] end
     end
   end
 
@@ -151,10 +158,10 @@ module Jellyfish
 
     %w[options get head post put delete patch].each do |method|
       module_eval <<-RUBY
-        def #{method} route=//, &block
+        def #{method} route=//, meta={}, &block
           raise TypeError.new("Route \#{route} should respond to :match") \
             unless route.respond_to?(:match)
-          (routes['#{method}'] ||= []) << [route, block]
+          (routes['#{method}'] ||= []) << [route, block || lambda{|_|}, meta]
         end
       RUBY
     end
@@ -176,12 +183,12 @@ module Jellyfish
   def call env
     ctrl = self.class.controller.new(self.class.routes, self)
     case res = catch(:halt){ ctrl.call(env) }
-    when NotFound
-      app && forward(ctrl, env) || handle(ctrl, res)
+    when Cascade
+      cascade(ctrl, env)
     when Response
       handle(ctrl, res, env['rack.errors'])
-    else
-      res || ctrl.block_call(nil, Identity)
+    else     # make sure we return rack triple
+      res || ctrl.block_call(nil, lambda{|_|_})
     end
   rescue => e
     handle(ctrl, e, env['rack.errors'])
@@ -198,7 +205,7 @@ module Jellyfish
   end
 
   private
-  def forward ctrl, env
+  def cascade ctrl, env
     app.call(env)
   rescue => e
     handle(ctrl, e, env['rack.errors'])

data/lib/jellyfish/json.rb

@@ -0,0 +1,64 @@
+
+module Jellyfish; end
+module Jellyfish::Json
+  module MultiJson
+    def self.extended mod
+      mod.const_set(:ParseError, ::MultiJson::DecodeError)
+    end
+    def encode hash
+      ::MultiJson.dump(hash)
+    end
+    def decode json
+      ::MultiJson.load(json)
+    end
+  end
+
+  module YajlRuby
+    def self.extended mod
+      mod.const_set(:ParseError, Yajl::ParseError)
+    end
+    def encode hash
+      Yajl::Encoder.encode(hash)
+    end
+    def decode json
+      Yajl::Parser.parse(json)
+    end
+  end
+
+  module Json
+    def self.extended mod
+      mod.const_set(:ParseError, JSON::ParserError)
+    end
+    def encode hash
+      JSON.dump(hash)
+    end
+    def decode json
+      JSON.parse(json)
+    end
+  end
+
+  def self.select_json! mod, picked=false
+    if    Object.const_defined?(:MultiJson)
+      mod.send(:extend, MultiJson)
+    elsif Object.const_defined?(:Yajl)
+      mod.send(:extend, YajlRuby)
+    elsif Object.const_defined?(:JSON)
+      mod.send(:extend, Json)
+    elsif picked
+      raise LoadError.new(
+        'No JSON library found. Tried: multi_json, yajl-ruby, json.')
+    else
+      # pick a json gem if available
+      %w[multi_json yajl json].each{ |json|
+        begin
+          require json
+          break
+        rescue LoadError
+        end
+      }
+      select_json!(mod, true)
+    end
+  end
+
+  select_json!(self)
+end

data/lib/jellyfish/multi_actions.rb

@@ -22,7 +22,7 @@ module Jellyfish
       }.compact
 
       if acts.empty?
-        halt(Jellyfish::NotFound.new)
+        action_missing
       else
         acts
       end

data/lib/jellyfish/swagger.rb

@@ -0,0 +1,166 @@
+
+require 'jellyfish/json'
+
+module Jellyfish
+  class Swagger
+    include Jellyfish
+    controller_include Jellyfish::NormalizedPath, Module.new{
+      def dispatch
+        headers_merge 'Content-Type' => 'application/json; charset=utf-8'
+        super
+      end
+    }
+
+    get '/' do
+      [Jellyfish::Json.encode(
+        :swaggerVersion => '1.2'                       ,
+        :info           => jellyfish.swagger_info      ,
+        :apiVersion     => jellyfish.swagger_apiVersion,
+        :apis           => jellyfish.swagger_apis      )]
+    end
+
+    get %r{\A/(?<name>.+)\Z} do |match|
+      basePath =
+      "#{request.scheme}://#{request.host_with_port}#{jellyfish.path_prefix}"
+      name     = "/#{match[:name]}"
+      apis     = jellyfish.jellyfish_apis[name].map{ |path, operations|
+        {:path => path, :operations => operations}
+      }
+
+      [Jellyfish::Json.encode(
+        :swaggerVersion => '1.2'                       ,
+        :basePath       => basePath                    ,
+        :resourcePath   => name                        ,
+        :apiVersion     => jellyfish.swagger_apiVersion,
+        :apis           => apis                        )]
+    end
+
+    # The application should define the API description.
+    def swagger_info
+      if app.respond_to?(:info)
+        app.info
+      else
+        {}
+      end
+    end
+
+    # The application should define the API version.
+    def swagger_apiVersion
+      if app.respond_to?(:swagger_apiVersion)
+        app.swagger_apiVersion
+      else
+        '0.1.0'
+      end
+    end
+
+    def swagger_apis
+      @swagger_apis ||= jellyfish_apis.keys.map do |name|
+        {:path => name}
+      end
+    end
+
+    attr_reader :jellys, :path_prefix
+    def initialize path_prefix='', *apps
+      super(apps.first)
+      @jellys      = apps
+      @path_prefix = path_prefix
+    end
+
+    def jellyfish_apis
+      @jellyfish_apis ||= jellys.flat_map{ |j|
+        j.routes.flat_map{ |meth, routes|
+          routes.map{ |(path, _, meta)|
+            meta.merge(operation(meth, path, meta))
+          }
+        }
+      }.group_by{ |api| api[:path] }.
+        inject(Hash.new{[]}){ |r, (path, operations)|
+          r[path] = operations.group_by{ |op| op[:nickname] }
+          r
+        }
+    end
+
+    private
+    def operation meth, path, meta
+      if path.respond_to?(:source)
+        nick = nickname(path)
+        {:path       => swagger_path(nick)          ,
+         :method     => meth.to_s.upcase            ,
+         :nickname   => nick                        ,
+         :summary    => meta[:summary]              ,
+         :notes      => notes(meta)                 ,
+         :parameters => path_parameters(path, meta) }
+      else
+        {:path       => swagger_path(path)          ,
+         :method     => meth.to_s.upcase            ,
+         :nickname   => path                        ,
+         :summary    => meta[:summary]              ,
+         :notes      => notes(meta)                 ,
+         :parameters => query_parameters(meta)      }
+      end
+    end
+
+    def swagger_path nickname
+      nickname[%r{^/[^/]*}]
+    end
+
+    def nickname path
+      if path.respond_to?(:source)
+        path.source.gsub(param_pattern, '{\1}').gsub(/\\\w+|[\^\$]/, '')
+      else
+        path.to_s
+      end
+    end
+
+    def notes meta
+      if meta[:notes]
+        "#{meta[:summary]}<br>#{meta[:notes]}"
+      else
+        meta[:summary]
+      end
+    end
+
+    def path_parameters path, meta
+      Hash[path.source.scan(param_pattern)].map{ |name, pattern|
+        path_param(name, pattern, meta)
+      }
+    end
+
+    def query_parameters meta
+      if meta[:parameters]
+        meta[:parameters].map{ |(name, param)|
+          param.merge(:name      => name.to_s,
+                      :type      => param[:type] || 'string',
+                      :required  => !!param[:required],
+                      :paramType => param[:paramType] || 'query')
+        }
+      else
+        []
+      end
+    end
+
+    def path_param name, pattern, meta
+      param = (meta[:parameters] || {})[name.to_sym] || {}
+      param.merge(:name      => name                               ,
+                  :type      => param[:type] || param_type(pattern),
+                  :required  => true                               ,
+                  :paramType => 'path'                             )
+    end
+
+    def param_type pattern
+      if pattern.start_with?('\\d')
+        if pattern.include?('.')
+          'number'
+        else
+          'integer'
+        end
+      else
+        'string'
+      end
+    end
+
+    def param_pattern
+      /\(\?<(\w+)>([^\)]+)\)/
+    end
+  end
+end

data/lib/jellyfish/test.rb

@@ -13,7 +13,10 @@ shared :jellyfish do
           app.call({'PATH_INFO'      => path              ,
                     'REQUEST_METHOD' => '#{method}'.upcase,
                     'SCRIPT_NAME'    => ''                ,
-                    'rack.input'     => input             }.merge(env))
+                    'rack.input'     => input             ,
+                    'rack.url_scheme'=> 'https'           ,
+                    'SERVER_NAME'    => 'localhost'       ,
+                    'SERVER_PORT'    => '8080'}.merge(env))
         end
       end
     RUBY