sinatra 1.4.8 → 2.1.0

data/lib/sinatra/indifferent_hash.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+$stderr.puts <<EOF if !Hash.method_defined?(:slice) && !$LOAD_PATH.grep(%r{gems/activesupport}).empty? && ENV['SINATRA_ACTIVESUPPORT_WARNING'] != 'false'
+WARNING: If you plan to load any of ActiveSupport's core extensions to Hash, be
+sure to do so *before* loading Sinatra::Application or Sinatra::Base. If not,
+you may disregard this warning.
+
+Set SINATRA_ACTIVESUPPORT_WARNING=false in the environment to hide this warning.
+EOF
+
+module Sinatra
+  # A poor man's ActiveSupport::HashWithIndifferentAccess, with all the Rails-y
+  # stuff removed.
+  #
+  # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are
+  # considered to be the same.
+  #
+  #   rgb = Sinatra::IndifferentHash.new
+  #
+  #   rgb[:black]    =  '#000000' # symbol assignment
+  #   rgb[:black]  # => '#000000' # symbol retrieval
+  #   rgb['black'] # => '#000000' # string retrieval
+  #
+  #   rgb['white']   =  '#FFFFFF' # string assignment
+  #   rgb[:white]  # => '#FFFFFF' # symbol retrieval
+  #   rgb['white'] # => '#FFFFFF' # string retrieval
+  #
+  # Internally, symbols are mapped to strings when used as keys in the entire
+  # writing interface (calling e.g. <tt>[]=</tt>, <tt>merge</tt>). This mapping
+  # belongs to the public interface. For example, given:
+  #
+  #   hash = Sinatra::IndifferentHash.new(:a=>1)
+  #
+  # You are guaranteed that the key is returned as a string:
+  #
+  #   hash.keys # => ["a"]
+  #
+  # Technically other types of keys are accepted:
+  #
+  #   hash = Sinatra::IndifferentHash.new(:a=>1)
+  #   hash[0] = 0
+  #   hash # => { "a"=>1, 0=>0 }
+  #
+  # But this class is intended for use cases where strings or symbols are the
+  # expected keys and it is convenient to understand both as the same. For
+  # example the +params+ hash in Sinatra.
+  class IndifferentHash < Hash
+    def self.[](*args)
+      new.merge!(Hash[*args])
+    end
+
+    def initialize(*args)
+      args.map!(&method(:convert_value))
+
+      super(*args)
+    end
+
+    def default(*args)
+      args.map!(&method(:convert_key))
+
+      super(*args)
+    end
+
+    def default=(value)
+      super(convert_value(value))
+    end
+
+    def assoc(key)
+      super(convert_key(key))
+    end
+
+    def rassoc(value)
+      super(convert_value(value))
+    end
+
+    def fetch(key, *args)
+      args.map!(&method(:convert_value))
+
+      super(convert_key(key), *args)
+    end
+
+    def [](key)
+      super(convert_key(key))
+    end
+
+    def []=(key, value)
+      super(convert_key(key), convert_value(value))
+    end
+
+    alias_method :store, :[]=
+
+    def key(value)
+      super(convert_value(value))
+    end
+
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :has_key?, :key?
+    alias_method :include?, :key?
+    alias_method :member?, :key?
+
+    def value?(value)
+      super(convert_value(value))
+    end
+
+    alias_method :has_value?, :value?
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def dig(key, *other_keys)
+      super(convert_key(key), *other_keys)
+    end if method_defined?(:dig) # Added in Ruby 2.3
+
+    def fetch_values(*keys)
+      keys.map!(&method(:convert_key))
+
+      super(*keys)
+    end if method_defined?(:fetch_values) # Added in Ruby 2.3
+
+    def slice(*keys)
+      keys.map!(&method(:convert_key))
+
+      self.class[super(*keys)]
+    end if method_defined?(:slice) # Added in Ruby 2.5
+
+    def values_at(*keys)
+      keys.map!(&method(:convert_key))
+
+      super(*keys)
+    end
+
+    def merge!(*other_hashes)
+      other_hashes.each do |other_hash|
+        if other_hash.is_a?(self.class)
+          super(other_hash)
+        else
+          other_hash.each_pair do |key, value|
+            key = convert_key(key)
+            value = yield(key, self[key], value) if block_given? && key?(key)
+            self[key] = convert_value(value)
+          end
+        end
+      end
+
+      self
+    end
+
+    alias_method :update, :merge!
+
+    def merge(*other_hashes, &block)
+      dup.merge!(*other_hashes, &block)
+    end
+
+    def replace(other_hash)
+      super(other_hash.is_a?(self.class) ? other_hash : self.class[other_hash])
+    end
+
+    if method_defined?(:transform_values!) # Added in Ruby 2.4
+      def transform_values(&block)
+        dup.transform_values!(&block)
+      end
+
+      def transform_values!
+        super
+        super(&method(:convert_value))
+      end
+    end
+
+    if method_defined?(:transform_keys!) # Added in Ruby 2.5
+      def transform_keys(&block)
+        dup.transform_keys!(&block)
+      end
+
+      def transform_keys!
+        super
+        super(&method(:convert_key))
+      end
+    end
+
+    private
+
+    def convert_key(key)
+      key.is_a?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      case value
+      when Hash
+        value.is_a?(self.class) ? value : self.class[value]
+      when Array
+        value.map(&method(:convert_value))
+      else
+        value
+      end
+    end
+  end
+end

data/lib/sinatra/main.rb

@@ -1,6 +1,30 @@
-require 'sinatra/base'
-
 module Sinatra
+  ParamsConfig = {}
+
+  if ARGV.any?
+    require 'optparse'
+    parser = OptionParser.new { |op|
+      op.on('-p port',   'set the port (default is 4567)')               { |val| ParamsConfig[:port] = Integer(val) }
+      op.on('-s server', 'specify rack server/handler')                  { |val| ParamsConfig[:server] = val }
+      op.on('-q',        'turn on quiet mode (default is off)')          {       ParamsConfig[:quiet] = true }
+      op.on('-x',        'turn on the mutex lock (default is off)')      {       ParamsConfig[:lock] = true }
+      op.on('-e env',    'set the environment (default is development)') do |val|
+        ENV['RACK_ENV'] = val
+        ParamsConfig[:environment] = val.to_sym
+      end
+      op.on('-o addr', "set the host (default is (env == 'development' ? 'localhost' : '0.0.0.0'))") do |val|
+        ParamsConfig[:bind] = val
+      end
+    }
+    begin
+      parser.parse!(ARGV.dup)
+    rescue => evar
+      ParamsConfig[:optparse_error] = evar
+    end
+  end
+
+  require 'sinatra/base'
+
   class Application < Base
 
     # we assume that the first file that requires 'sinatra' is the
@@ -11,17 +35,13 @@ module Sinatra
     set :run, Proc.new { File.expand_path($0) == File.expand_path(app_file) }
 
     if run? && ARGV.any?
-      require 'optparse'
-      OptionParser.new { |op|
-        op.on('-p port',   'set the port (default is 4567)')                { |val| set :port, Integer(val) }
-        op.on('-o addr',   "set the host (default is #{bind})")             { |val| set :bind, val }
-        op.on('-e env',    'set the environment (default is development)')  { |val| set :environment, val.to_sym }
-        op.on('-s server', 'specify rack server/handler (default is thin)') { |val| set :server, val }
-        op.on('-x',        'turn on the mutex lock (default is off)')       {       set :lock, true }
-      }.parse!(ARGV.dup)
+      error = ParamsConfig.delete(:optparse_error)
+      raise error if error
+      ParamsConfig.each { |k, v| set k, v }
     end
   end
 
+  remove_const(:ParamsConfig)
   at_exit { Application.run! if $!.nil? && Application.run? }
 end
 

data/lib/sinatra/show_exceptions.rb

@@ -1,8 +1,6 @@
-begin
-  require 'rack/show_exceptions'
-rescue LoadError
-  require 'rack/showexceptions'
-end
+# frozen_string_literal: true
+
+require 'rack/show_exceptions'
 
 module Sinatra
   # Sinatra::ShowExceptions catches all exceptions raised from the app it
@@ -17,8 +15,7 @@ module Sinatra
     def @@eats_errors.puts(*) end
 
     def initialize(app)
-      @app      = app
-      @template = ERB.new(TEMPLATE)
+      @app = app
     end
 
     def call(env)
@@ -28,47 +25,51 @@ module Sinatra
 
       if prefers_plain_text?(env)
         content_type = "text/plain"
-        exception = dump_exception(e)
+        body = dump_exception(e)
       else
         content_type = "text/html"
-        exception = pretty(env, e)
+        body = pretty(env, e)
       end
 
       env["rack.errors"] = errors
 
-      # Post 893a2c50 in rack/rack, the #pretty method above, implemented in
-      # Rack::ShowExceptions, returns a String instead of an array.
-      body = Array(exception)
-
       [
         500,
         {
           "Content-Type" => content_type,
-          "Content-Length" => Rack::Utils.bytesize(body.join).to_s
+          "Content-Length" => body.bytesize.to_s
         },
-        body
+        [body]
       ]
     end
 
+    def template
+      TEMPLATE
+    end
+
     private
 
+    def bad_request?(e)
+      Sinatra::BadRequest === e
+    end
+
     def prefers_plain_text?(env)
       !(Request.new(env).preferred_type("text/plain","text/html") == "text/html") &&
-      [/curl/].index{|item| item =~ env["HTTP_USER_AGENT"]}
+      [/curl/].index { |item| item =~ env["HTTP_USER_AGENT"] }
     end
 
     def frame_class(frame)
-      if frame.filename =~ /lib\/sinatra.*\.rb/
+      if frame.filename =~ %r{lib/sinatra.*\.rb}
         "framework"
       elsif (defined?(Gem) && frame.filename.include?(Gem.dir)) ||
-            frame.filename =~ /\/bin\/(\w+)$/
+            frame.filename =~ %r{/bin/(\w+)\z}
         "system"
       else
         "app"
       end
     end
 
-TEMPLATE = <<-HTML # :nodoc:
+TEMPLATE = ERB.new <<-HTML # :nodoc:
 <!DOCTYPE html>
 <html>
 <head>
@@ -213,8 +214,10 @@ TEMPLATE = <<-HTML # :nodoc:
       <p><a href="#" id="expando"
             onclick="toggleBacktrace(); return false">(expand)</a></p>
       <p id="nav"><strong>JUMP TO:</strong>
-         <a href="#get-info">GET</a>
-         <a href="#post-info">POST</a>
+         <% unless bad_request?(exception) %>
+            <a href="#get-info">GET</a>
+            <a href="#post-info">POST</a>
+         <% end %>
          <a href="#cookie-info">COOKIES</a>
          <a href="#env-info">ENV</a>
       </p>
@@ -267,47 +270,49 @@ TEMPLATE = <<-HTML # :nodoc:
       </ul>
     </div> <!-- /BACKTRACE -->
 
-    <div id="get">
-      <h3 id="get-info">GET</h3>
-      <% if req.GET and not req.GET.empty? %>
-        <table class="req">
-          <tr>
-            <th>Variable</th>
-            <th>Value</th>
-          </tr>
-           <% req.GET.sort_by { |k, v| k.to_s }.each { |key, val| %>
-          <tr>
-            <td><%=h key %></td>
-            <td class="code"><div><%=h val.inspect %></div></td>
-          </tr>
-          <% } %>
-        </table>
-      <% else %>
-        <p class="no-data">No GET data.</p>
-      <% end %>
-      <div class="clear"></div>
-    </div> <!-- /GET -->
-
-    <div id="post">
-      <h3 id="post-info">POST</h3>
-      <% if req.POST and not req.POST.empty? %>
-        <table class="req">
-          <tr>
-            <th>Variable</th>
-            <th>Value</th>
-          </tr>
-          <% req.POST.sort_by { |k, v| k.to_s }.each { |key, val| %>
-          <tr>
-            <td><%=h key %></td>
-            <td class="code"><div><%=h val.inspect %></div></td>
-          </tr>
-          <% } %>
-        </table>
-      <% else %>
-        <p class="no-data">No POST data.</p>
-      <% end %>
-      <div class="clear"></div>
-    </div> <!-- /POST -->
+    <% unless bad_request?(exception) %>
+      <div id="get">
+        <h3 id="get-info">GET</h3>
+        <% if req.GET and not req.GET.empty? %>
+          <table class="req">
+            <tr>
+              <th>Variable</th>
+              <th>Value</th>
+            </tr>
+             <% req.GET.sort_by { |k, v| k.to_s }.each { |key, val| %>
+            <tr>
+              <td><%=h key %></td>
+              <td class="code"><div><%=h val.inspect %></div></td>
+            </tr>
+            <% } %>
+          </table>
+        <% else %>
+          <p class="no-data">No GET data.</p>
+        <% end %>
+        <div class="clear"></div>
+      </div> <!-- /GET -->
+
+      <div id="post">
+        <h3 id="post-info">POST</h3>
+        <% if req.POST and not req.POST.empty? %>
+          <table class="req">
+            <tr>
+              <th>Variable</th>
+              <th>Value</th>
+            </tr>
+            <% req.POST.sort_by { |k, v| k.to_s }.each { |key, val| %>
+            <tr>
+              <td><%=h key %></td>
+              <td class="code"><div><%=h val.inspect %></div></td>
+            </tr>
+            <% } %>
+          </table>
+        <% else %>
+          <p class="no-data">No POST data.</p>
+        <% end %>
+        <div class="clear"></div>
+      </div> <!-- /POST -->
+    <% end %>
 
     <div id="cookies">
       <h3 id="cookie-info">COOKIES</h3>

data/lib/sinatra/version.rb

@@ -1,3 +1,3 @@
 module Sinatra
-  VERSION = '1.4.8'
+  VERSION = '2.1.0'
 end

data/sinatra.gemspec

@@ -1,19 +1,55 @@
-$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
-require 'sinatra/version'
+version = File.read(File.expand_path("../VERSION", __FILE__)).strip
 
-Gem::Specification.new 'sinatra', Sinatra::VERSION do |s|
+Gem::Specification.new 'sinatra', version do |s|
   s.description       = "Sinatra is a DSL for quickly creating web applications in Ruby with minimal effort."
   s.summary           = "Classy web-development dressed in a DSL"
   s.authors           = ["Blake Mizerany", "Ryan Tomayko", "Simon Rozet", "Konstantin Haase"]
   s.email             = "sinatrarb@googlegroups.com"
-  s.homepage          = "http://www.sinatrarb.com/"
+  s.homepage          = "http://sinatrarb.com/"
   s.license           = 'MIT'
-  s.files             = `git ls-files`.split("\n") - %w[.gitignore .travis.yml]
+  s.files             = Dir['README*.md', 'lib/**/*', 'examples/*'] + [
+    ".yardopts",
+    "AUTHORS.md",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "Gemfile",
+    "LICENSE",
+    "MAINTENANCE.md",
+    "Rakefile",
+    "SECURITY.md",
+    "sinatra.gemspec",
+    "VERSION"]
   s.test_files        = s.files.select { |p| p =~ /^test\/.*_test.rb/ }
   s.extra_rdoc_files  = s.files.select { |p| p =~ /^README/ } << 'LICENSE'
   s.rdoc_options      = %w[--line-numbers --inline-source --title Sinatra --main README.rdoc --encoding=UTF-8]
 
-  s.add_dependency 'rack', '~> 1.5'
-  s.add_dependency 'tilt', '>= 1.3', '< 3'
-  s.add_dependency 'rack-protection', '~> 1.4'
+  if s.respond_to?(:metadata)
+    s.metadata = {
+      'source_code_uri'   => 'https://github.com/sinatra/sinatra',
+      'changelog_uri'     => 'https://github.com/sinatra/sinatra/blob/master/CHANGELOG.md',
+      'homepage_uri'      => 'http://sinatrarb.com/',
+      'bug_tracker_uri'   => 'https://github.com/sinatra/sinatra/issues',
+      'mailing_list_uri'  => 'http://groups.google.com/group/sinatrarb',
+      'documentation_uri' => 'https://www.rubydoc.info/gems/sinatra'
+    }
+  else
+    msg = "RubyGems 2.0 or newer is required to protect against public "\
+          "gem pushes. You can update your rubygems version by running:\n\n"\
+          "gem install rubygems-update\n"\
+          "update_rubygems\n"\
+          "gem update --system"
+    raise <<-EOF
+RubyGems 2.0 or newer is required to protect against public gem pushes. You can update your rubygems version by running:
+  gem install rubygems-update
+  update_rubygems:
+  gem update --system
+EOF
+  end
+
+  s.required_ruby_version = '>= 2.3.0'
+
+  s.add_dependency 'rack', '~> 2.2'
+  s.add_dependency 'tilt', '~> 2.0'
+  s.add_dependency 'rack-protection', version
+  s.add_dependency 'mustermann', '~> 1.0'
 end