scorched 1.0.0.pre3 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: df1c61cb8ccb03b0bae14dda80b50f22e00530be
-  data.tar.gz: 8782b7f14fcf6986d200dcb2964f30604c78be1b
+SHA256:
+  metadata.gz: 867ade7529bcd2c1aef6c5ae9ec3898078f1aedc65e190d29fd03781f7fbaabb
+  data.tar.gz: 7275bd4b007d91441a06cd2a90e58fac6e49ea598fa146964fb074cc03af2f37
 SHA512:
-  metadata.gz: b4ccefaee00f1c66b57736510051d81a6381b840b8daee5f4cb0b69f17591b13a43c29568f8cebba6b7ba179d85ca4e6bf578c3d049486b7d8f727c543b7d942
-  data.tar.gz: '05990c3fa144a24f72557a6379aeab375a86827b7c196f5aeaa7b1dbb79f44f9d7d6c19023131443c058baab3e9cbd51593f4469246c739dda27f59eb236b0df'
+  metadata.gz: 0a0b3feb7e16e82571277ec4c97f8555b268013cbb8172e464a3d30fd4639e66c3ff817b9f165e5f4a2b4ef7b1470d28aaad4568dda1bad4cb56c390bf4a9cce
+  data.tar.gz: 9dbfa1171f29c6037c173ece4f584a828c073671896c2f6b40dcc49dd37269ac5ad096909ec4d77bfdb88b212c0d4278c39206d370a30fc37aa9a836c77a73dc

data/CHANGES.md

@@ -1,8 +1,16 @@
 Changelog
 =========
 
-_Note that Scorched is yet to reach a v1.0 release. This means breaking changes may still be made. If upgrading the version of Scorched for your project, review this changelog carefully._
-
+### v1.0.2
+* Now requiring CGI instead of URI library as per v1.0.1 deprecation fixes.
+### v1.0.1
+* Fixed Ruby 2.7 deprecations
+### v1.0.0
+* Updated all dependencies. Ready for 1.0.0 release.
+### v1.0.0.pre5
+* Log level now defaults to :warn for every environment except development, which defaults to :debug
+### v1.0.0.pre4
+* Added `dispatched` condition which performs a similar role to the recently removed `handled` condition.
 ### v1.0.0.pre3
 * APP_ENV now preferred over RACK_ENV for setting the environment.
 ### v1.0.0.pre2

data/lib/scorched/controller.rb

@@ -18,7 +18,7 @@ module Scorched
     config << {
       :auto_pass => false, # Automatically _pass_ request back to outer controller if no route matches.
       :cache_templates => true,
-      :logger => Logger.new(STDOUT),
+      :logger => nil,
       :show_exceptions => false,
       :show_http_error_pages => false, # If true, shows the default Scorched HTTP error page.
       :static_dir => false, # The directory Scorched should serve static files from. Set to false if web server or anything else is serving static files.
@@ -35,6 +35,7 @@ module Scorched
     }
 
     if ENV['APP_ENV'] == 'development'
+      config[:logger] = Logger.new(STDOUT)
       config[:show_exceptions] = true
       config[:static_dir] = 'public'
       config[:cache_templates] = false
@@ -51,6 +52,9 @@ module Scorched
       content_type: proc { |content_types|
         [*content_types].include? env['CONTENT_TYPE']
       },
+      dispatched: proc { |bool|
+        !!@_dispatched == bool
+      },
       encoding: proc { |encodings|
         [*encodings].any? { |encoding| env['rack-accept.request'].encoding? encoding }
       },
@@ -152,7 +156,7 @@ module Scorched
         else
           controller = klass
         end
-        self << {pattern: pattern, target: controller}.merge(mapping)
+        self.map **{pattern: pattern, target: controller}.merge(mapping)
         controller
       end
 
@@ -176,7 +180,7 @@ module Scorched
           response
         end
         [*pattern].compact.each do |pattern|
-          self << {pattern: compile(pattern, true), priority: priority, conditions: conds, target: target}
+          self.map pattern: compile(pattern, true), priority: priority, conditions: conds, target: target
         end
         target
       end
@@ -462,7 +466,7 @@ module Scorched
       if value.empty?
         request.cookies[name]
       else
-        value = Hash === value[0] ? value[0] : {value: value}
+        value = (Hash === value[0]) ? value[0] : {value: value[0]}
         if value[:value].nil?
           response.delete_cookie(name, value)
         else

data/lib/scorched/request.rb

@@ -1,4 +1,4 @@
-require 'uri'
+require 'cgi'
 
 module Scorched
   class Request < Rack::Request
@@ -33,7 +33,7 @@ module Scorched
     # The unescaped URL, excluding the escaped forward-slash and percent. The resulting string will always be safe
     # to unescape again in situations where the forward-slash or percent are expected and valid characters. 
     def unescaped_path
-      path_info.split(/(%25|%2F)/i).each_slice(2).map { |v, m| URI.unescape(v) << (m || '') }.join('')
+      path_info.split(/(%25|%2F)/i).each_slice(2).map { |v, m| CGI.unescape(v) << (m || '') }.join('')
     end
     
   private

data/lib/scorched/version.rb

@@ -1,3 +1,3 @@
 module Scorched
-  VERSION = '1.0.0.pre3'
+  VERSION = '1.0.2'
 end

data/scorched.gemspec

@@ -10,7 +10,6 @@ Gem::Specification.new 'scorched', Scorched::VERSION do |s|
   s.license           = 'MIT'
   s.files             = Dir.glob(`git ls-files`.split("\n") - %w[.gitignore])
   s.test_files        = Dir.glob('spec/**/*_spec.rb')
-  s.has_rdoc          = 'yard'
 
   s.required_ruby_version = '>= 2.0.0'
 
@@ -18,7 +17,7 @@ Gem::Specification.new 'scorched', Scorched::VERSION do |s|
   s.add_dependency 'rack-accept', '~> 0.4' # Used for Accept-Charset, Accept-Encoding and Accept-Language headers.
   s.add_dependency 'scorched-accept', '~> 0.1' # Used for Accept header.
   s.add_dependency 'tilt', '~> 2.0'
-  s.add_development_dependency 'rack-test', '~> 0.6'
-  s.add_development_dependency 'rspec', '~> 3.4'
-  s.add_development_dependency 'rake', '~> 10.4'
+  s.add_development_dependency 'rack-test', '>= 1.0'
+  s.add_development_dependency 'rspec', '>= 3.4'
+  s.add_development_dependency 'rake', '>= 10.4'
 end

data/spec/controller_spec.rb

@@ -24,13 +24,13 @@ module Scorched
       end
 
       it "handles a root rack call correctly" do
-        app << {pattern: '/$', target: generic_handler}
+        app.map pattern: '/$', target: generic_handler
         response = rt.get '/'
         response.status.should == 200
       end
 
       it "does not maintain state between requests" do
-        app << {pattern: '/state', target: proc { |env| [200, {}, [@state = 1 + @state.to_i]] }}
+        app.map pattern: '/state', target: proc { |env| [200, {}, [@state = 1 + @state.to_i]] }
         response = rt.get '/state'
         response.body.should == '1'
         response = rt.get '/state'
@@ -39,54 +39,54 @@ module Scorched
 
       it "raises exception when invalid mapping hash given" do
         expect {
-          app << {pattern: '/'}
+          app.map(pattern: '/')
         }.to raise_error(ArgumentError)
         expect {
-          app << {target: generic_handler}
+          app.map(target: generic_handler)
         }.to raise_error(ArgumentError)
       end
     end
 
     describe "URL matching" do
       it 'always matches from the beginning of the URL' do
-        app << {pattern: 'about', target: generic_handler}
+        app.map pattern: 'about', target: generic_handler
         response = rt.get '/about'
         response.status.should == 404
       end
 
       it "matches eagerly by default" do
         req = nil
-        app << {pattern: '/*', target: proc do |env|
+        app.map pattern: '/*', target: proc { |env|
           req = request; [200, {}, ['ok']]
-        end}
+        }
         response = rt.get '/about'
         req.captures.should == ['about']
       end
 
       it "can be forced to match end of URL" do
-        app << {pattern: '/about$', target: generic_handler}
+        app.map pattern: '/about$', target: generic_handler
         response = rt.get '/about/us'
         response.status.should == 404
-        app << {pattern: '/about', target: generic_handler}
+        app.map pattern: '/about', target: generic_handler
         response = rt.get '/about/us'
         response.status.should == 200
       end
 
       it "unescapes all characters except for the forward-slash and percent sign" do
-        app << {pattern: '/a (quite) big fish', target: generic_handler}
+        app.map pattern: '/a (quite) big fish', target: generic_handler
         rt.get('/a%20%28quite%29%20big%20fish').status.should == 200
-        app << {pattern: '/article/100%25 big%2Fsmall', target: generic_handler}
+        app.map pattern: '/article/100%25 big%2Fsmall', target: generic_handler
         rt.get('/article/100%25%20big%2Fsmall').status.should == 200
-        app << {pattern: '/*$', target: generic_handler}
+        app.map pattern: '/*$', target: generic_handler
         rt.get('/page%2Fabout').status.should == 200
         rt.get('/page/about').status.should == 404
       end
 
       it "unmatched path doesn't always begin with a forward slash" do
         gh = generic_handler
-        app << {pattern: '/ab', target: Class.new(Scorched::Controller) do
+        app.map pattern: '/ab', target: Class.new(Scorched::Controller) {
           map(pattern: 'out', target: gh)
-        end}
+        }
         resp = rt.get('/about')
         resp.status.should == 200
         resp.body.should == "ok"
@@ -94,119 +94,119 @@ module Scorched
 
       it "unmatched path begins with forward slash if last match was up to or included a forward slash" do
         gh = generic_handler
-        app << {pattern: '/about/', target: Class.new(Scorched::Controller) do
+        app.map pattern: '/about/', target: Class.new(Scorched::Controller) {
           map(pattern: '/us', target: gh)
-        end}
-        app << {pattern: '/contact', target: Class.new(Scorched::Controller) do
+        }
+        app.map pattern: '/contact', target: Class.new(Scorched::Controller) {
           map(pattern: '/us', target: gh)
-        end}
+        }
         rt.get('/about/us').body.should == "ok"
         rt.get('/contact/us').body.should == "ok"
       end
 
       it "can match anonymous wildcards" do
         req = nil
-        app << {pattern: '/anon/*/**', target: proc do |env|
+        app.map pattern: '/anon/*/**', target: proc { |env|
           req = request; [200, {}, ['ok']]
-        end}
+        }
         response = rt.get '/anon/jeff/has/crabs'
         req.captures.should == ['jeff', 'has/crabs']
       end
 
       it "can match named wildcards (ignoring anonymous captures)" do
         req = nil
-        app << {pattern: '/anon/:name/*/::infliction', target: proc do |env|
+        app.map pattern: '/anon/:name/*/::infliction', target: proc { |env|
           req = request; [200, {}, ['ok']]
-        end}
+        }
         response = rt.get '/anon/jeff/smith/has/crabs'
         req.captures.should == {name: 'jeff', infliction: 'has/crabs'}
       end
 
       example "wildcards match one or more characters" do
-        app << {pattern: '/*', target: proc { |env| [200, {}, ['ok']] }}
+        app.map pattern: '/*', target: proc { |env| [200, {}, ['ok']] }
         rt.get('/').status.should == 404
         rt.get('/dog').status.should == 200
         app.mappings.clear
-        app << {pattern: '/**', target: proc { |env| [200, {}, ['ok']] }}
+        app.map pattern: '/**', target: proc { |env| [200, {}, ['ok']] }
         rt.get('/').status.should == 404
         rt.get('/dog/cat').status.should == 200
         app.mappings.clear
-        app << {pattern: '/:page', target: proc { |env| [200, {}, ['ok']] }}
+        app.map pattern: '/:page', target: proc { |env| [200, {}, ['ok']] }
         rt.get('/').status.should == 404
         rt.get('/dog').status.should == 200
         app.mappings.clear
-        app << {pattern: '/::page', target: proc { |env| [200, {}, ['ok']] }}
+        app.map pattern: '/::page', target: proc { |env| [200, {}, ['ok']] }
         rt.get('/').status.should == 404
         rt.get('/dog/cat').status.should == 200
       end
 
       example "wildcards can optionally match zero or more characters" do
-        app << {pattern: '/*?', target: proc { |env| [200, {}, ['ok']] }}
+        app.map pattern: '/*?', target: proc { |env| [200, {}, ['ok']] }
         rt.get('/').status.should == 200
         rt.get('/dog').status.should == 200
         app.mappings.clear
-        app << {pattern: '/**?', target: proc { |env| [200, {}, ['ok']] }}
+        app.map pattern: '/**?', target: proc { |env| [200, {}, ['ok']] }
         rt.get('/').status.should == 200
         rt.get('/dog/cat').status.should == 200
         app.mappings.clear
-        app << {pattern: '/:page?', target: proc { |env| [200, {}, ['ok']] }}
+        app.map pattern: '/:page?', target: proc { |env| [200, {}, ['ok']] }
         rt.get('/').status.should == 200
         rt.get('/dog').status.should == 200
         app.mappings.clear
-        app << {pattern: '/::page?', target: proc { |env| [200, {}, ['ok']] }}
+        app.map pattern: '/::page?', target: proc { |env| [200, {}, ['ok']] }
         rt.get('/').status.should == 200
         rt.get('/dog/cat').status.should == 200
       end
 
       it "can match regex and preserve anonymous captures" do
         req = nil
-        app << {pattern: %r{/anon/([^/]+)/(.+)}, target: proc do |env|
+        app.map pattern: %r{/anon/([^/]+)/(.+)}, target: proc { |env|
           req = request; [200, {}, ['ok']]
-        end}
+        }
         response = rt.get '/anon/jeff/has/crabs'
         req.captures.should == ['jeff', 'has/crabs']
       end
 
       it "can match regex and preserve named captures (ignoring anonymous captures)" do
         req = nil
-        app << {pattern: %r{/anon/(?<name>[^/]+)/([^/]+)/(?<infliction>.+)}, target: proc do |env|
+        app.map pattern: %r{/anon/(?<name>[^/]+)/([^/]+)/(?<infliction>.+)}, target: proc { |env|
           req = request; [200, {}, ['ok']]
-        end}
+        }
         response = rt.get '/anon/jeff/smith/has/crabs'
         req.captures.should == {name: 'jeff', infliction: 'has/crabs'}
       end
 
       it "can use symbol matchers" do
-        app << {pattern: '/:numeric', target: proc { |env| [200, {}, ['ok']] }}
+        app.map pattern: '/:numeric', target: proc { |env| [200, {}, ['ok']] }
         rt.get('/45').status.should == 200
         rt.get('/dog45').status.should == 404
         req = nil
-        app << {pattern: '/:alpha_numeric', target: proc { |env| req = request; [200, {}, ['ok']] }}
+        app.map pattern: '/:alpha_numeric', target: proc { |env| req = request; [200, {}, ['ok']] }
         rt.get('/dog45').status.should == 200
         req.captures[:alpha_numeric].should == 'dog45'
         rt.get('/_dog45').status.should == 404
       end
 
       it "can coerce symbol-matched values" do
-        app << {pattern: '/:numeric', target: proc { |env| [200, {}, [request.captures[:numeric].class.name]] }}
+        app.map pattern: '/:numeric', target: proc { |env| [200, {}, [request.captures[:numeric].class.name]] }
         rt.get('/45').body.should == 'Integer'
       end
 
       it "matches routes based on priority, otherwise giving precedence to those defined first" do
         order = []
-        app << {pattern: '/', priority: -1, target: proc { |env| order << 'four'; [200, {}, ['ok']] }}
-        app << {pattern: '/', target: proc { |env| order << 'two'; throw :pass }}
-        app << {pattern: '/', target: proc { |env| order << 'three'; throw :pass }}
-        app << {pattern: '/', priority: 2, target: proc { |env| order << 'one'; throw :pass }}
+        app.map pattern: '/', priority: -1, target: proc { |env| order << 'four'; [200, {}, ['ok']] }
+        app.map pattern: '/', target: proc { |env| order << 'two'; throw :pass }
+        app.map pattern: '/', target: proc { |env| order << 'three'; throw :pass }
+        app.map pattern: '/', priority: 2, target: proc { |env| order << 'one'; throw :pass }
         rt.get('/').body.should == 'ok'
         order.should == %w{one two three four}
       end
 
       it "finds the best match for the media type whilst respecting priority and definition order" do
-        app << {pattern: '/', target: proc { |env| [200, {}, ['anything']] }}
-        app << {pattern: '/', conditions: {media_type: 'application/json'}, target: proc { |env| [200, {}, ['application/json']] }}
-        app << {pattern: '/', conditions: {media_type: 'text/html'}, target: proc { |env| [200, {}, ['text/html']] }}
-        app << {pattern: '/', priority: 1, target: proc { |env| [200, {}, ['anything_high_priority']] }}
+        app.map pattern: '/', target: proc { |env| [200, {}, ['anything']] }
+        app.map pattern: '/', conditions: {media_type: 'application/json'}, target: proc { |env| [200, {}, ['application/json']] }
+        app.map pattern: '/', conditions: {media_type: 'text/html'}, target: proc { |env| [200, {}, ['text/html']] }
+        app.map pattern: '/', priority: 1, target: proc { |env| [200, {}, ['anything_high_priority']] }
         rt.get('/', {}, 'HTTP_ACCEPT' => 'application/json, */*;q=0.5').body.should == 'anything_high_priority'
         app.mappings.pop
         rt.get('/', {}, 'HTTP_ACCEPT' => 'application/json;q=0.5, text/html').body.should == 'text/html'
@@ -224,14 +224,14 @@ module Scorched
       end
 
       it "executes route only if all conditions return true" do
-        app << {pattern: '/$', conditions: {method: 'POST'}, target: generic_handler}
+        app.map pattern: '/$', conditions: {method: 'POST'}, target: generic_handler
         response = rt.get "/"
         response.status.should be_between(400, 499)
         response = rt.post "/"
         response.status.should == 200
 
         app.conditions[:has_name] = proc { |name| request.GET['name'] }
-        app << {pattern: '/about', conditions: {method: ['GET', 'POST'], has_name: 'Ronald'}, target: generic_handler}
+        app.map pattern: '/about', conditions: {method: ['GET', 'POST'], has_name: 'Ronald'}, target: generic_handler
         response = rt.get "/about"
         response.status.should be_between(400, 499)
         response = rt.get "/about", name: 'Ronald'
@@ -239,21 +239,21 @@ module Scorched
       end
 
       it "raises exception when condition doesn't exist or is invalid" do
-        app << {pattern: '/', conditions: {surprise_christmas_turkey: true}, target: generic_handler}
+        app.map pattern: '/', conditions: {surprise_christmas_turkey: true}, target: generic_handler
         expect {
           rt.get "/"
         }.to raise_error(Scorched::Error)
       end
 
       it "falls through to next route when conditions are not met" do
-        app << {pattern: '/', conditions: {method: 'POST'}, target: proc { |env| [200, {}, ['post']] }}
-        app << {pattern: '/', conditions: {method: 'GET'}, target: proc { |env| [200, {}, ['get']] }}
+        app.map pattern: '/', conditions: {method: 'POST'}, target: proc { |env| [200, {}, ['post']] }
+        app.map pattern: '/', conditions: {method: 'GET'}, target: proc { |env| [200, {}, ['get']] }
         rt.get("/").body.should == 'get'
         rt.post("/").body.should == 'post'
       end
 
       it "inverts the conditions if it's referenced with a trailing exclamation mark" do
-        app << {pattern: '/', conditions: {method!: 'GET'}, target: proc { |env| [200, {}, ['ok']] }}
+        app.map pattern: '/', conditions: {method!: 'GET'}, target: proc { |env| [200, {}, ['ok']] }
         rt.get("/").status.should == 405
         rt.post("/").status.should == 200
       end
@@ -272,7 +272,7 @@ module Scorched
         wrapped_block = app.route(&block)
         app.mappings.length.should == 0
         block.should_not == wrapped_block
-        app << {pattern: '/*', target: wrapped_block}
+        app.map pattern: '/*', target: wrapped_block
         rt.get('/turkey').body.should == 'turkey'
       end
 
@@ -319,9 +319,9 @@ module Scorched
 
     describe "sub-controllers" do
       it "should ignore the already matched portions of the path" do
-        app << {pattern: '/article', target: Class.new(Scorched::Controller) do
+        app.map pattern: '/article', target: Class.new(Scorched::Controller) {
           get('/*') { |title| title }
-        end}
+        }
         rt.get('/article/hello-world').body.should == 'hello-world'
       end
 
@@ -916,7 +916,7 @@ module Scorched
             get('/hello') { 'hello' }
             after { response.status = 600 }
           end
-          app << {pattern: '/', target: sub}
+          app.map pattern: '/', target: sub
           app.get('/') { 'ok' }
           rt.get('/').body.should == 'ok'
           rt.get('/').status.should == 200
@@ -1096,7 +1096,7 @@ module Scorched
           render(:'main.erb').should == "3 for me"
         end
         app.get('/full_path') do
-          render(:'views/main.erb', {layout: :'views/layout.erb', dir: nil}).should == "(3 for me)"
+          render(:'views/main.erb', **{layout: :'views/layout.erb', dir: nil}).should == "(3 for me)"
         end
         app.render_defaults[:dir] = 'views'
         rt.get('/')

data/spec/helper.rb

@@ -44,4 +44,7 @@ RSpec.configure do |c|
   c.alias_example_to :they
   # c.backtrace_clean_patterns = []
   c.include GlobalConfig
+  c.expect_with :rspec do |expectations|
+    expectations.syntax = [:should, :expect]
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scorched
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre3
+  version: 1.0.2
 platform: ruby
 authors:
 - Tom Wardrop
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-04 00:00:00.000000000 Z
+date: 2021-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -70,42 +70,42 @@ dependencies:
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.4'
 description: A light-weight Sinatra-inspired web framework for web sites and applications
@@ -186,12 +186,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Light-weight, DRY as a desert, web framework for Ruby