lib/sinatra/respond_with.rb in sinatra-contrib-2.2.4 vs lib/sinatra/respond_with.rb in sinatra-contrib-3.0.0

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require 'sinatra/json'
 require 'sinatra/base'
 
 module Sinatra
   #
@@ -86,71 +88,79 @@
   #
   # Definition order does not matter.
   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
       end
 
       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
 
     module Helpers
       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
           end
           if object
             exts.each do |ext|
               halt json(object) if ext == :json
               next unless object.respond_to? method = "to_#{ext}"
+
               halt(*object.send(method))
             end
           end
           false
         end
@@ -174,24 +184,25 @@
           settings.template_engines[ext].each { |e| possible << [e, name] }
         end
 
         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
         [] # nil or false would not be cached
       end
     end
 
     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
 
     def mime_type(*)
@@ -204,21 +215,22 @@
       @respond_to ||= nil
 
       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
       end
     end
 
     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
 
     def compile!(verb, path, block, **options)
@@ -226,33 +238,31 @@
       super
     end
 
     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
     end
 
     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
     end
   end