jellyfish 1.1.1 → 1.2.0

data/lib/jellyfish.rb

@@ -1,7 +1,6 @@
 
 module Jellyfish
   autoload :VERSION , 'jellyfish/version'
-  autoload :NewRelic, 'jellyfish/newrelic'
 
   autoload :NormalizedParams, 'jellyfish/normalized_params'
   autoload :NormalizedPath  , 'jellyfish/normalized_path'
@@ -159,13 +158,16 @@ module Jellyfish
     end
 
     %w[options get head post put delete patch].each do |method|
-      module_eval <<-RUBY
-        def #{method} route=//, meta={}, &block
-          raise TypeError.new("Route \#{route} should respond to :match") \
-            unless route.respond_to?(:match)
-          (routes['#{method}'] ||= []) << [route, block || lambda{|_|}, meta]
-        end
-      RUBY
+      define_method(method) do |route=//, meta={}, &block|
+        define(method, route, meta, &block)
+      end
+    end
+
+    def define(method, route=//, meta={}, &block)
+      raise TypeError.new("Route #{route} should respond to :match") \
+        unless route.respond_to?(:match)
+
+      (routes[method.to_s] ||= []) << [route, block || lambda{|_|}, meta]
     end
 
     def inherited sub

data/lib/jellyfish/builder.rb

@@ -28,8 +28,13 @@ module Jellyfish
       @warmup = lam || block
     end
 
-    def map path, to: nil, &block
-      (@map ||= {})[path] = [block, to]
+    def map path, to: nil, host: nil, &block
+      key = if host then "http://#{host}/#{path}" else path end
+      (@map ||= {})[key] = [block, to]
+    end
+
+    def listen host, &block
+      map('', host: host, &block)
     end
 
     def rewrite rules, &block
@@ -42,16 +47,16 @@ module Jellyfish
       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) }
-      rewrite = if to then Rewrite.new(app, to) else app end
-      @warmup.call(rewrite) if @warmup
-      rewrite
+      result = if to then Rewrite.new(app, to) else app end
+      @warmup.call(result) if @warmup
+      result
     end
 
     private
     def generate_map current_map, app
       mapped = if app then {'' => app} else {} end
       current_map.each do |path, (block, to)|
-        mapped[path.chomp('/')] = self.class.app(app, to, &block)
+        mapped[path] = self.class.app(app, to, &block)
       end
       URLMap.new(mapped)
     end

data/lib/jellyfish/test.rb

@@ -4,7 +4,7 @@ require 'muack'
 require 'jellyfish'
 require 'rack'
 
-Pork::Executor.__send__(:include, Muack::API)
+Pork::Suite.include(Muack::API)
 
 copy :jellyfish do
   module_eval(%w[options get head post put delete patch].map{ |method|
@@ -15,7 +15,7 @@ copy :jellyfish do
                   'REQUEST_METHOD' => '#{method}'.upcase,
                   'SCRIPT_NAME'    => ''                ,
                   'rack.input'     => input             ,
-                  'rack.url_scheme'=> 'https'           ,
+                  'rack.url_scheme'=> 'http'            ,
                   'SERVER_NAME'    => 'localhost'       ,
                   'SERVER_PORT'    => '8080'}.merge(env))
         end
@@ -23,3 +23,11 @@ copy :jellyfish do
     RUBY
   }.join("\n"))
 end
+
+copy :stringio do
+  def new_stringio
+    sock = StringIO.new
+    sock.set_encoding('ASCII-8BIT')
+    sock
+  end
+end

data/lib/jellyfish/urlmap.rb

@@ -1,26 +1,91 @@
 
 module Jellyfish
   class URLMap
-    def initialize mapped
-      string = mapped.keys.sort_by{ |k| -k.size }.
-        map{ |k| Regexp.escape(k).gsub('/', '/+') }.
+    def initialize mapped_not_chomped
+      mapped = transform_keys(mapped_not_chomped){ |k| k.sub(%r{/+\z}, '') }
+      keys = mapped.keys
+      @no_host = !keys.any?{ |k| match?(k, %r{\Ahttps?://}) }
+
+      string = keys.sort_by{ |k| -k.size }.
+        map{ |k| build_regexp(k) }.
         join('|')
 
       @mapped = mapped
-      @routes = Regexp.new("\\A(?:#{string})(?:/|\\z)", 'i', 'n')
+      @routes = %r{\A(?:#{string})(?:/|\z)}
     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))
+      if @no_host
+        if matched = @routes.match(path_info)
+          cut_path = matched.to_s.chomp('/')
+          script_name = key = cut_path.squeeze('/')
+        end
+      else
+        host = (env['HTTP_HOST'] || env['SERVER_NAME']).to_s.downcase
+        if matched = @routes.match("#{host}/#{path_info}")
+          cut_path = matched.to_s[host.size + 1..-1].chomp('/')
+          script_name = cut_path.squeeze('/')
+
+          key =
+            if matched[:host]
+              host_with_path =
+                if script_name.empty?
+                  host
+                else
+                  File.join(host, script_name)
+                end
+              "#{env['rack.url_scheme']}://#{host_with_path}"
+            else
+              script_name
+            end
+        end
+      end
+
+      if app = @mapped[key]
+        app.call(env.merge('PATH_INFO' => path_info[cut_path.size..-1],
+                           'SCRIPT_NAME' => env['SCRIPT_NAME'] + script_name))
       else
         [404, {}, []]
       end
     end
+
+    private
+
+    def build_regexp path
+      if @no_host
+        regexp_path(path)
+      elsif matched = path.match(%r{\Ahttps?://([^/]+)(/?.*)})
+        # We only need to know if we're matching against a host,
+        # therefore just an empty group is sufficient.
+        "(?<host>)#{matched[1]}/#{regexp_path(matched[2])}"
+      else
+        "[^/]*/#{regexp_path(path)}"
+      end
+    end
+
+    def regexp_path path
+      Regexp.escape(path).gsub('/', '/+')
+    end
+
+    def transform_keys hash, &block
+      if hash.respond_to?(:transform_keys)
+        hash.transform_keys(&block)
+      else
+        hash.inject({}) do |result, (key, value)|
+          result[yield(key)] = value
+          result
+        end
+      end
+    end
+
+    def match? string, regexp
+      if string.respond_to?(:match?)
+        string.match?(regexp)
+      else
+        string =~ regexp
+      end
+    end
   end
 end

data/lib/jellyfish/version.rb

@@ -1,4 +1,4 @@
 
 module Jellyfish
-  VERSION = '1.1.1'
+  VERSION = '1.2.0'
 end

data/task/README.md

@@ -4,16 +4,16 @@
 
 Provided tasks:
 
-    rake clean        # Remove ignored files
+    rake clean        # Trash ignored files
     rake gem:build    # Build gem
     rake gem:install  # Install gem
     rake gem:release  # Release gem
     rake gem:spec     # Generate gemspec
-    rake test         # Run tests in memory
+    rake test         # Run tests
 
 ## REQUIREMENTS:
 
-* Tested with MRI (official CRuby) 1.9.3, 2.0.0, Rubinius and JRuby.
+* Tested with MRI (official CRuby), Rubinius and JRuby.
 
 ## INSTALLATION:
 
@@ -23,13 +23,13 @@ And in Rakefile:
 
 ``` ruby
 begin
-  require "#{dir = File.dirname(__FILE__)}/task/gemgem"
+  require "#{__dir__}/task/gemgem"
 rescue LoadError
-  sh 'git submodule update --init'
+  sh 'git submodule update --init --recursive'
   exec Gem.ruby, '-S', $PROGRAM_NAME, *ARGV
 end
 
-Gemgem.init(dir) do |s|
+Gemgem.init(__dir__, :submodules => %w[your-dep]) do |s|
   s.name    = 'your-gem'
   s.version = '0.1.0'
 end
@@ -37,9 +37,9 @@ end
 
 ## LICENSE:
 
-Apache License 2.0
+Apache License 2.0 (Apache-2.0)
 
-Copyright (c) 2011-2013, Lin Jen-Shin (godfat)
+Copyright (c) 2011-2017, Lin Jen-Shin (godfat)
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/task/gemgem.rb

@@ -1,7 +1,7 @@
 
 module Gemgem
   class << self
-    attr_accessor :dir, :spec, :spec_create
+    attr_accessor :dir, :spec, :submodules, :spec_create
   end
 
   module_function
@@ -11,12 +11,14 @@ module Gemgem
   def pkg_dir    ; "#{dir}/pkg"                       ; end
   def escaped_dir; @escaped_dir ||= Regexp.escape(dir); end
 
-  def init dir, &block
+  def init dir, options={}, &block
     self.dir = dir
-    $LOAD_PATH.unshift("#{dir}/lib")
     ENV['RUBYLIB'] = "#{dir}/lib:#{ENV['RUBYLIB']}"
     ENV['PATH']    = "#{dir}/bin:#{ENV['PATH']}"
+    self.submodules  = options[:submodules] || []
     self.spec_create = block
+
+    $LOAD_PATH.unshift("#{dir}/lib", *submodules_libs)
   end
 
   def create
@@ -26,7 +28,7 @@ module Gemgem
 
       s.description = description.join
       s.summary     = description.first
-      s.license     = readme['LICENSE'].sub(/.+\n\n/, '').lines.first.strip
+      s.license     = license
 
       s.date        = Time.now.strftime('%Y-%m-%d')
       s.files       = gem_files
@@ -115,6 +117,7 @@ module Gemgem
       SimpleCov.start do
         add_filter('test/')
         add_filter('test.rb')
+        submodules_libs.each(&method(:add_filter))
       end
     end
 
@@ -159,11 +162,15 @@ module Gemgem
   end
 
   def strip_home_path path
-    path.sub(ENV['HOME'], '~')
+    path.sub(/\A#{Regexp.escape(ENV['HOME'])}\//, '~/')
   end
 
   def strip_cwd_path path
-    path.sub(Dir.pwd, '.')
+    path.sub(/\A#{Regexp.escape(Dir.pwd)}\//, '')
+  end
+
+  def submodules_libs
+    submodules.map{ |path| "#{dir}/#{path}/lib" }
   end
 
   def git *args
@@ -201,6 +208,11 @@ module Gemgem
     @description ||= (readme['DESCRIPTION']||'').sub(/.+\n\n/, '').lines.to_a
   end
 
+  def license
+    readme['LICENSE'].sub(/.+\n\n/, '').lines.first.
+      split(/[()]/).map(&:strip).reject(&:empty?).last
+  end
+
   def all_files
     @all_files ||= fold_files(glob).sort
   end
@@ -221,7 +233,8 @@ module Gemgem
 
   def gem_files
     @gem_files ||= all_files.reject{ |f|
-      f =~ ignored_pattern && !git_files.include?(f)
+      f =~ submodules_pattern ||
+        (f =~ ignored_pattern && !git_files.include?(f))
     }
   end
 
@@ -253,6 +266,15 @@ module Gemgem
                          end
   end
 
+  def submodules_pattern
+    @submodules_pattern ||= if submodules.empty?
+                              /^$/
+                            else
+                              Regexp.new(submodules.map{ |path|
+                                "^#{Regexp.escape(path)}/" }.join('|'))
+                            end
+  end
+
   def expand_patterns pathes
     # http://git-scm.com/docs/gitignore
     pathes.flat_map{ |path|

data/test/rack/test_builder.rb

@@ -3,7 +3,7 @@ require 'jellyfish/test'
 
 require 'rack/lint'
 require 'rack/mock'
-require 'rack/showexceptions'
+require 'rack/show_exceptions'
 require 'rack/urlmap'
 
 describe Jellyfish::Builder do

data/test/rack/test_urlmap.rb

@@ -14,7 +14,7 @@ describe Jellyfish::URLMap do
       }, [""]]
     }
     map = Rack::Lint.new(Jellyfish::URLMap.new({
-      '/bar' => app,
+      'http://foo.org/bar' => app,
       '/foo' => app,
       '/foo/bar' => app
     }))
@@ -67,10 +67,68 @@ describe Jellyfish::URLMap do
     res["X-PathInfo"].should.eq '/'
   end
 
+  would "dispatches hosts correctly" do
+    map = Rack::Lint.new(Jellyfish::URLMap.new("http://foo.org/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "foo.org",
+                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
+                              }, [""]]},
+                           "http://subdomain.foo.org/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "subdomain.foo.org",
+                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
+                              }, [""]]},
+                           "http://bar.org/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "bar.org",
+                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
+                              }, [""]]},
+                           "/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "default.org",
+                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
+                              }, [""]]}
+                           ))
+
+    res = Rack::MockRequest.new(map).get("/")
+    res.should.ok?
+    res["X-Position"].should.eq "default.org"
+
+    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "bar.org")
+    res.should.ok?
+    res["X-Position"].should.eq "bar.org"
+
+    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "foo.org")
+    res.should.ok?
+    res["X-Position"].should.eq "foo.org"
+
+    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "subdomain.foo.org", "SERVER_NAME" => "foo.org")
+    res.should.ok?
+    res["X-Position"].should.eq "subdomain.foo.org"
+
+    res = Rack::MockRequest.new(map).get("http://foo.org/")
+    res.should.ok?
+    res["X-Position"].should.eq "foo.org"
+
+    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "example.org")
+    res.should.ok?
+    res["X-Position"].should.eq "default.org"
+
+    res = Rack::MockRequest.new(map).get("/",
+                                         "HTTP_HOST" => "example.org:9292",
+                                         "SERVER_PORT" => "9292")
+    res.should.ok?
+    res["X-Position"].should.eq "default.org"
+  end
+
   would "be nestable" do
-    map = Rack::Lint.new(Rack::URLMap.new("/foo" =>
-      Rack::URLMap.new("/bar" =>
-        Rack::URLMap.new("/quux" =>  lambda { |env|
+    map = Rack::Lint.new(Jellyfish::URLMap.new("/foo" =>
+      Jellyfish::URLMap.new("/bar" =>
+        Jellyfish::URLMap.new("/quux" =>  lambda { |env|
                            [200,
                             { "Content-Type" => "text/plain",
                               "X-Position" => "/foo/bar/quux",
@@ -90,7 +148,7 @@ describe Jellyfish::URLMap do
   end
 
   would "route root apps correctly" do
-    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
+    map = Rack::Lint.new(Jellyfish::URLMap.new("/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
                                 "X-Position" => "root",
@@ -132,7 +190,7 @@ describe Jellyfish::URLMap do
   end
 
   would "not squeeze slashes" do
-    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
+    map = Rack::Lint.new(Jellyfish::URLMap.new("/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
                                 "X-Position" => "root",
@@ -156,7 +214,7 @@ describe Jellyfish::URLMap do
   end
 
   would "not be case sensitive with hosts" do
-    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
+    map = Rack::Lint.new(Jellyfish::URLMap.new("http://example.org/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
                                 "X-Position" => "root",
@@ -165,13 +223,13 @@ describe Jellyfish::URLMap do
                               }, [""]]}
                            ))
 
-    res = Rack::MockRequest.new(map).get("/")
+    res = Rack::MockRequest.new(map).get("http://example.org/")
     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 = Rack::MockRequest.new(map).get("http://EXAMPLE.ORG/")
     res.should.ok?
     res["X-Position"].should.eq "root"
     res["X-PathInfo"].should.eq "/"