sinatra-contrib 2.2.1 → 3.0.0

data/lib/sinatra/link_header.rb

@@ -1,7 +1,6 @@
 require 'sinatra/base'
 
 module Sinatra
-
   # = Sinatra::LinkHeader
   #
   # <tt>Sinatra::LinkHeader</tt> adds a set of helper methods to generate link
@@ -86,8 +85,8 @@ module Sinatra
       opts[:rel]    = urls.shift unless urls.first.respond_to? :to_str
       options       = opts.map { |k, v| " #{k}=#{v.to_s.inspect}" }
       html_pattern  = "<link href=\"%s\"#{options.join} />"
-      http_pattern  = ["<%s>", *options].join ";"
-      link          = (response["Link"] ||= "")
+      http_pattern  = ['<%s>', *options].join ';'
+      link          = (response['Link'] ||= '')
 
       urls.map do |url|
         link << ",\n" unless link.empty?
@@ -116,14 +115,15 @@ module Sinatra
     #   %body= yield
     def link_headers
       yield if block_given?
-      return "" unless response.include? "Link"
-      response["Link"].split(",\n").map do |line|
+      return '' unless response.include? 'Link'
+
+      response['Link'].split(",\n").map do |line|
         url, *opts = line.split(';').map(&:strip)
-        "<link href=\"#{url[1..-2]}\" #{opts.join " "} />"
+        "<link href=\"#{url[1..-2]}\" #{opts.join ' '} />"
       end.join "\n"
     end
 
-    def self.registered(base)
+    def self.registered(_base)
       puts "WARNING: #{self} is a helpers module, not an extension."
     end
   end

data/lib/sinatra/multi_route.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sinatra/base'
 
 module Sinatra

data/lib/sinatra/namespace.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'sinatra/base'
 require 'mustermann'
 
 module Sinatra
-
   # = Sinatra::Namespace
   #
   # <tt>Sinatra::Namespace</tt> is an extension that adds namespaces to an
@@ -187,13 +188,16 @@ module Sinatra
   module Namespace
     def self.new(base, pattern, conditions = {}, &block)
       Module.new do
-        #quelch uninitialized variable warnings, since these get used by compile method.
-        @pattern, @conditions = nil, nil
+        # quelch uninitialized variable warnings, since these get used by compile method.
+        @pattern = nil
+        @conditions = nil
         extend NamespacedMethods
         include InstanceMethods
-        @base, @extensions, @errors = base, [], {}
+        @base = base
+        @extensions = []
+        @errors = {}
         @pattern, @conditions = compile(pattern, conditions)
-        @templates            = Hash.new { |h,k| @base.templates[k] }
+        @templates            = Hash.new { |_h, k| @base.templates[k] }
         namespace = self
         before { extend(@namespace = namespace) }
         class_eval(&block)
@@ -224,14 +228,14 @@ module Sinatra
       include SharedMethods
       attr_reader :base, :templates
 
-      ALLOWED_ENGINES = [
-        :erb, :erubi, :erubis, :haml, :hamlit, :builder, :nokogiri, :sass, :scss,
-        :less, :liquid, :markdown, :textile, :rdoc, :asciidoc, :radius, :markaby,
-        :rabl, :slim, :creole, :mediawiki, :coffee, :stylus, :yajl, :wlang
+      ALLOWED_ENGINES = %i[
+        erb erubi haml hamlit builder nokogiri
+        liquid markdown rdoc asciidoc markaby
+        rabl slim yajl
       ]
 
       def self.prefixed(*names)
-        names.each { |n| define_method(n) { |*a, &b| prefixed(n, *a, &b) }}
+        names.each { |n| define_method(n) { |*a, &b| prefixed(n, *a, &b) } }
       end
 
       prefixed :before, :after, :delete, :get, :head, :options, :patch, :post, :put
@@ -267,7 +271,7 @@ module Sinatra
       end
 
       def error(*codes, &block)
-        args  = Sinatra::Base.send(:compile!, "ERROR", /.*/, block)
+        args  = Sinatra::Base.send(:compile!, 'ERROR', /.*/, block)
         codes = codes.map { |c| Array(c) }.flatten
         codes << Exception if codes.empty?
         codes << Sinatra::NotFound if codes.include?(404)
@@ -280,12 +284,14 @@ module Sinatra
 
       def respond_to(*args)
         return @conditions[:provides] || base.respond_to if args.empty?
+
         @conditions[:provides] = args
       end
 
       def set(key, value = self, &block)
-        return key.each { |k,v| set(k, v) } if key.respond_to?(:each) and block.nil? and value == self
+        return key.each { |k, v| set(k, v) } if key.respond_to?(:each) && block.nil? && (value == self)
         raise ArgumentError, "may not set #{key}" unless ([:views] + ALLOWED_ENGINES).include?(key)
+
         block ||= proc { value }
         singleton_class.send(:define_method, key, &block)
       end
@@ -299,11 +305,13 @@ module Sinatra
       end
 
       def template(name, &block)
-        filename, line = caller_locations.first
-        templates[name] = [block, filename, line.to_i]
+        first_location = caller_locations.first
+        filename = first_location.path
+        line = first_location.lineno
+        templates[name] = [block, filename, line]
       end
 
-      def layout(name=:layout, &block)
+      def layout(name = :layout, &block)
         template name, &block
       end
 
@@ -322,21 +330,22 @@ module Sinatra
           conditions = conditions.merge pattern.to_hash
           pattern = nil
         end
-        base_pattern, base_conditions = @pattern, @conditions
+        base_pattern = @pattern
+        base_conditions = @conditions
         pattern ||= default_pattern
-        [ prefixed_path(base_pattern, pattern),
-          (base_conditions || {}).merge(conditions) ]
+        [prefixed_path(base_pattern, pattern),
+         (base_conditions || {}).merge(conditions)]
       end
 
       def prefixed_path(a, b)
-        return a || b || /.*/ unless a and b
+        return a || b || /.*/ unless a && b
         return Mustermann.new(b) if a == /.*/
 
         Mustermann.new(a) + Mustermann.new(b)
       end
 
       def prefixed(method, pattern = nil, conditions = {}, &block)
-        default = %r{(?:/.*)?} if method == :before or method == :after
+        default = %r{(?:/.*)?} if (method == :before) || (method == :after)
         pattern, conditions = compile pattern, conditions, default
         result = base.send(method, pattern, **conditions, &block)
         invoke_hook :route_added, method.to_s.upcase, pattern, block

data/lib/sinatra/quiet_logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sinatra
   # = Sinatra::QuietLogger
   #
@@ -32,10 +34,14 @@ module Sinatra
   #     end
   #
   module QuietLogger
-
     def self.registered(app)
-      quiet_logger_prefixes = app.settings.quiet_logger_prefixes.join('|') rescue ''
+      quiet_logger_prefixes = begin
+        app.settings.quiet_logger_prefixes.join('|')
+      rescue StandardError
+        ''
+      end
       return warn('You need to specify the paths you wish to exclude from logging via `set :quiet_logger_prefixes, %w(images css fonts)`') if quiet_logger_prefixes.empty?
+
       const_set('QUIET_LOGGER_REGEX', %r(\A/{0,2}(?:#{quiet_logger_prefixes})))
       ::Rack::CommonLogger.prepend(
         ::Module.new do
@@ -45,6 +51,5 @@ module Sinatra
         end
       )
     end
-
   end
 end

data/lib/sinatra/reloader.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 require 'sinatra/base'
 
 module Sinatra
-
   # = Sinatra::Reloader
   #
+  # <b>DEPRECATED:<b> Please consider using an alternative like
+  # <tt>rerun</tt> or <tt>rack-unreloader</tt> instead.
+  #
   # Extension to reload modified files.  Useful during development,
   # since it will automatically require files defining routes, filters,
   # error handlers and inline templates, with every incoming request,
@@ -94,11 +98,9 @@ module Sinatra
   #     end
   #
   module Reloader
-
     # Watches a file so it can tell when it has been updated, and what
     # elements does it contain.
     class Watcher
-
       # Represents an element of a Sinatra application that may need to
       # be reloaded.  An element could be:
       # * a route
@@ -172,7 +174,8 @@ module Sinatra
       # Creates a new +Watcher+ instance for the file located at +path+.
       def initialize(path)
         @ignore = nil
-        @path, @elements = path, []
+        @path = path
+        @elements = []
         update
       end
 
@@ -215,7 +218,7 @@ module Sinatra
     # Allow a block to be executed after any file being reloaded
     @@after_reload = []
     def after_reload(&block)
-      @@after_reload  << block
+      @@after_reload << block
     end
 
     # When the extension is registered it extends the Sinatra application
@@ -242,14 +245,27 @@ module Sinatra
     # Reloads the modified files, adding, updating and removing the
     # needed elements.
     def self.perform(klass)
+      reloaded_paths = []
       Watcher::List.for(klass).updated.each do |watcher|
         klass.set(:inline_templates, watcher.path) if watcher.inline_templates?
         watcher.elements.each { |element| klass.deactivate(element) }
+        # Deletes all old elements.
+        watcher.elements.delete_if { true }
         $LOADED_FEATURES.delete(watcher.path)
         require watcher.path
         watcher.update
+        reloaded_paths << watcher.path
+      end
+      return if reloaded_paths.empty?
+
+      @@after_reload.each do |block|
+        block.arity.zero? ? block.call : block.call(reloaded_paths)
+      end
+      # Prevents after_reload from increasing each time it's reloaded.
+      @@after_reload.delete_if do |blk|
+        path, = blk.source_location
+        path && reloaded_paths.include?(path)
       end
-      @@after_reload.each(&:call)
     end
 
     # Contains the methods defined in Sinatra::Base that are overridden.
@@ -274,7 +290,7 @@ module Sinatra
           block.source_location.first : caller_files[1]
         signature = super
         watch_element(
-          source_location, :route, { :verb => verb, :signature => signature }
+          source_location, :route, { verb: verb, signature: signature }
         )
         signature
       end
@@ -283,9 +299,8 @@ module Sinatra
       # tells the +Watcher::List+ for the Sinatra application to watch the
       # inline templates in +file+ or the file who made the call to this
       # method.
-      def inline_templates=(file=nil)
-        file = (file.nil? || file == true) ?
-          (caller_files[1] || File.expand_path($0)) : file
+      def inline_templates=(file = nil)
+        file = (caller_files[1] || File.expand_path($0)) if file.nil? || file == true
         watch_element(file, :inline_templates)
         super
       end
@@ -317,7 +332,7 @@ module Sinatra
         path = caller_files[1] || File.expand_path($0)
         result = super
         codes.each do |c|
-          watch_element(path, :error, :code => c, :handler => @errors[c])
+          watch_element(path, :error, code: c, handler: @errors[c])
         end
         result
       end
@@ -346,17 +361,17 @@ module Sinatra
       # Removes the +element+ from the Sinatra application.
       def deactivate(element)
         case element.type
-        when :route then
+        when :route
           verb      = element.representation[:verb]
           signature = element.representation[:signature]
           (routes[verb] ||= []).delete(signature)
-        when :middleware then
+        when :middleware
           @middleware.delete(element.representation)
-        when :before_filter then
+        when :before_filter
           filters[:before].delete(element.representation)
-        when :after_filter then
+        when :after_filter
           filters[:after].delete(element.representation)
-        when :error then
+        when :error
           code    = element.representation[:code]
           handler = element.representation[:handler]
           @errors.delete(code) if @errors[code] == handler
@@ -375,7 +390,7 @@ module Sinatra
         Dir[*glob].each { |path| Watcher::List.for(self).ignore(path) }
       end
 
-    private
+      private
 
       # attr_reader :register_path warn on -w (private attribute)
       def register_path; @register_path ||= nil; end
@@ -403,7 +418,7 @@ module Sinatra
       # watch it in the file where the extension has been registered.
       # This prevents the duplication of the elements added by the
       # extension in its +registered+ method with every reload.
-      def watch_element(path, type, representation=nil)
+      def watch_element(path, type, representation = nil)
         list = Watcher::List.for(self)
         element = Watcher::Element.new(type, representation)
         list.watch(path, element)

data/lib/sinatra/required_params.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sinatra/base'
 
 module Sinatra
@@ -60,7 +62,7 @@ module Sinatra
         elsif key.is_a?(Array)
           _required_params(p, *key)
         else
-          halt 400 unless p && p.respond_to?(:has_key?) && p.has_key?(key.to_s)
+          halt 400 unless p.respond_to?(:key?) && p&.key?(key.to_s)
         end
       end
       true

data/lib/sinatra/respond_with.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sinatra/json'
 require 'sinatra/base'
 
@@ -88,14 +90,17 @@ module Sinatra
   module RespondWith
     class Format
       def initialize(app)
-        @app, @map, @generic, @default = app, {}, {}, nil
+        @app = app
+        @map = {}
+        @generic = {}
+        @default = nil
       end
 
       def on(type, &block)
         @app.settings.mime_types(type).each do |mime|
           case mime
           when '*/*'            then @default     = block
-          when /^([^\/]+)\/\*$/ then @generic[$1] = block
+          when %r{^([^/]+)/\*$} then @generic[$1] = block
           else                       @map[mime]   = block
           end
         end
@@ -103,23 +108,24 @@ module Sinatra
 
       def finish
         yield self if block_given?
-        mime_type = @app.content_type             ||
-          @app.request.preferred_type(@map.keys)  ||
-          @app.request.preferred_type             ||
-          'text/html'
+        mime_type = @app.content_type ||
+                    @app.request.preferred_type(@map.keys)  ||
+                    @app.request.preferred_type             ||
+                    'text/html'
         type = mime_type.split(/\s*;\s*/, 2).first
-        handlers = [@map[type], @generic[type[/^[^\/]+/]], @default].compact
+        handlers = [@map[type], @generic[type[%r{^[^/]+}]], @default].compact
         handlers.each do |block|
-          if result = block.call(type)
+          if (result = block.call(type))
             @app.content_type mime_type
             @app.halt result
           end
         end
-        @app.halt 500, "Unknown template engine"
+        @app.halt 500, 'Unknown template engine'
       end
 
       def method_missing(method, *args, &block)
-        return super if args.any? or block.nil? or not @app.mime_type(method)
+        return super if args.any? || block.nil? || !@app.mime_type(method)
+
         on(method, &block)
       end
     end
@@ -128,19 +134,22 @@ module Sinatra
       include Sinatra::JSON
 
       def respond_with(template, object = nil, &block)
-        object, template = template, nil unless Symbol === template
+        unless Symbol === template
+          object = template
+          template = nil
+        end
         format = Format.new(self)
-        format.on "*/*" do |type|
+        format.on '*/*' do |type|
           exts = settings.ext_map[type]
           exts << :xml if type.end_with? '+xml'
           if template
             args = template_cache.fetch(type, template) { template_for(template, exts) }
             if args.any?
-              locals = { :object => object }
+              locals = { object: object }
               locals.merge! object.to_hash if object.respond_to? :to_hash
 
               renderer = args.first
-              options = args[1..-1] + [{:locals => locals}]
+              options = args[1..] + [{ locals: locals }]
 
               halt send(renderer, *options)
             end
@@ -149,6 +158,7 @@ module Sinatra
             exts.each do |ext|
               halt json(object) if ext == :json
               next unless object.respond_to? method = "to_#{ext}"
+
               halt(*object.send(method))
             end
           end
@@ -176,10 +186,11 @@ module Sinatra
 
         possible.each do |engine, template|
           klass = Tilt.default_mapping.template_map[engine.to_s] ||
-            Tilt.lazy_map[engine.to_s].fetch(0, [])[0]
+                  Tilt.lazy_map[engine.to_s].fetch(0, [])[0]
 
           find_template(settings.views, template, klass) do |file|
             next unless File.exist? file
+
             return settings.rendering_method(engine) << template.to_sym
           end
         end
@@ -189,7 +200,7 @@ module Sinatra
 
     def remap_extensions
       ext_map.clear
-      Rack::Mime::MIME_TYPES.each { |e,t| ext_map[t] << e[1..-1].to_sym }
+      Rack::Mime::MIME_TYPES.each { |e, t| ext_map[t] << e[1..].to_sym }
       ext_map['text/javascript'] << 'js'
       ext_map['text/xml'] << 'xml'
     end
@@ -206,7 +217,7 @@ module Sinatra
       if formats.any?
         @respond_to ||= []
         @respond_to.concat formats
-      elsif @respond_to.nil? and superclass.respond_to? :respond_to
+      elsif @respond_to.nil? && superclass.respond_to?(:respond_to)
         superclass.respond_to
       else
         @respond_to
@@ -216,7 +227,8 @@ module Sinatra
     def rendering_method(engine)
       return [engine] if Sinatra::Templates.method_defined? engine
       return [:mab] if engine.to_sym == :markaby
-      [:render, :engine]
+
+      %i[render engine]
     end
 
     private
@@ -228,8 +240,8 @@ module Sinatra
 
     def self.jrubyify(engs)
       not_supported = [:markdown]
-      engs.keys.each do |key|
-        engs[key].collect! { |eng| (eng == :yajl) ? :json_pure : eng }
+      engs.each_key do |key|
+        engs[key].collect! { |eng| eng == :yajl ? :json_pure : eng }
         engs[key].delete_if { |eng| not_supported.include?(eng) }
       end
       engs
@@ -237,21 +249,19 @@ module Sinatra
 
     def self.engines
       engines = {
-        :css  => [:less,  :sass, :scss],
-        :xml  => [:builder, :nokogiri],
-        :js   => [:coffee],
-        :html => [:erb, :erubi, :erubis, :haml, :hamlit, :slim, :liquid, :radius,
-          :mab, :markdown, :textile, :rdoc],
-        :all =>  (Sinatra::Templates.instance_methods.map(&:to_sym) +
-          [:mab] - [:find_template, :markaby]),
-        :json => [:yajl],
+        xml: %i[builder nokogiri],
+        html: %i[erb erubi haml hamlit slim liquid
+                 mab markdown rdoc],
+        all: (Sinatra::Templates.instance_methods.map(&:to_sym) +
+          [:mab] - %i[find_template markaby]),
+        json: [:yajl]
       }
       engines.default = []
-      (defined? JRUBY_VERSION) ? jrubyify(engines) : engines
+      defined?(JRUBY_VERSION) ? jrubyify(engines) : engines
     end
 
     def self.registered(base)
-      base.set :ext_map, Hash.new { |h,k| h[k] = [] }
+      base.set :ext_map, Hash.new { |h, k| h[k] = [] }
       base.set :template_engines, engines
       base.remap_extensions
       base.helpers Helpers

data/lib/sinatra/runner.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'open-uri'
 require 'net/http'
 require 'timeout'
@@ -28,7 +30,7 @@ module Sinatra
   #
   #   class Runner < Sinatra::Runner
   #     def app_file
-  #       File.expand_path("../server.rb", __FILE__)
+  #       File.expand_path("server.rb", __dir__)
   #     end
   #   end
   #
@@ -49,7 +51,7 @@ module Sinatra
   # For an example, check https://github.com/apotonick/roar/blob/master/test/integration/runner.rb
   class Runner
     def app_file
-      File.expand_path("../server.rb", __FILE__)
+      File.expand_path('server.rb', __dir__)
     end
 
     def run
@@ -60,7 +62,8 @@ module Sinatra
 
     def kill
       return unless pipe
-      Process.kill("KILL", pipe.pid)
+
+      Process.kill('KILL', pipe.pid)
     rescue NotImplementedError
       system "kill -9 #{pipe.pid}"
     rescue Errno::ESRCH
@@ -70,7 +73,7 @@ module Sinatra
       Timeout.timeout(1) { get_url("#{protocol}://127.0.0.1:#{port}#{url}") }
     end
 
-    def get_stream(url = "/stream", &block)
+    def get_stream(url = '/stream', &block)
       Net::HTTP.start '127.0.0.1', port do |http|
         request = Net::HTTP::Get.new url
         http.request request do |response|
@@ -89,29 +92,32 @@ module Sinatra
     end
 
     def log
-      @log ||= ""
-      loop { @log <<  pipe.read_nonblock(1) }
+      @log ||= ''
+      loop { @log << pipe.read_nonblock(1) }
     rescue Exception
       @log
     end
 
-  private
+    private
+
     attr_accessor :pipe
 
     def start
       IO.popen(command)
     end
 
-    def command # to be overwritten
+    # to be overwritten
+    def command
       "bundle exec ruby #{app_file} -p #{port} -e production"
     end
 
-    def ping(timeout=30)
+    def ping(timeout = 30)
       loop do
         return if alive?
+
         if Time.now - @started > timeout
-          $stderr.puts command, log
-          fail "timeout"
+          warn command, log
+          raise 'timeout'
         else
           sleep 0.1
         end
@@ -121,26 +127,29 @@ module Sinatra
     def alive?
       3.times { get(ping_path) }
       true
-    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, EOFError, SystemCallError, OpenURI::HTTPError, Timeout::Error
+    rescue EOFError, SystemCallError, OpenURI::HTTPError, Timeout::Error
       false
     end
 
-    def ping_path # to be overwritten
+    # to be overwritten
+    def ping_path
       '/ping'
     end
 
-    def port # to be overwritten
+    # to be overwritten
+    def port
       4567
     end
 
     def protocol
-      "http"
+      'http'
     end
 
     def get_url(url)
       uri = URI.parse(url)
 
-      return uri.read unless protocol == "https"
+      return uri.read unless protocol == 'https'
+
       get_https_url(uri)
     end