praxis 2.0.pre.18 → 2.0.pre.19

data/lib/praxis/multipart/parser.rb

@@ -1,32 +1,33 @@
+# frozen_string_literal: true
+
 require 'rack/utils'
 
 # stolen from Rack::Multipart::Parser
 
 module Praxis
   class MultipartParser
-    EOL = "\r\n".freeze
-    MULTIPART_BOUNDARY = "AaB03x".freeze
-    MULTIPART = %r|\Amultipart/.*boundary=\"?([^\";,]+)\"?|n.freeze
-    TOKEN = /[^\s()<>,;:\\"\/\[\]?=]+/.freeze
+    EOL = "\r\n"
+    MULTIPART_BOUNDARY = 'AaB03x'
+    MULTIPART = %r{\Amultipart/.*boundary="?([^";,]+)"?}n.freeze
+    TOKEN = %r{[^\s()<>,;:\\"/\[\]?=]+}.freeze
     CONDISP = /Content-Disposition:\s*#{TOKEN}\s*/i.freeze
     DISPPARM = /;\s*(#{TOKEN})=("(?:\\"|[^"])*"|#{TOKEN})/.freeze
     RFC2183 = /^#{CONDISP}(#{DISPPARM})+$/i.freeze
     BROKEN_QUOTED = /^#{CONDISP}.*;\sfilename="(.*?)"(?:\s*$|\s*;\s*#{TOKEN}=)/i.freeze
     BROKEN_UNQUOTED = /^#{CONDISP}.*;\sfilename=(#{TOKEN})/i.freeze
     MULTIPART_CONTENT_TYPE = /Content-Type: (.*)#{EOL}/ni.freeze
-    MULTIPART_CONTENT_DISPOSITION = /Content-Disposition:.*\s+name="?([^\";]*)"?/ni.freeze
+    MULTIPART_CONTENT_DISPOSITION = /Content-Disposition:.*\s+name="?([^";]*)"?/ni.freeze
     MULTIPART_CONTENT_ID = /Content-ID:\s*([^#{EOL}]*)/ni.freeze
 
     HEADER_KV = /(?<k>[^:]+): (?<v>.*)/.freeze
     UNTIL_NEWLINE = /\A([^\n]*\n)/.freeze
     TERMINAL_CRLF = /\r\n$/.freeze
 
+    PARAMS_BUF_SIZE = 65_536 # Same as implicitly in rack 1.x
+    BUFSIZE = 16_384
 
-    PARAMS_BUF_SIZE = 65536 # Same as implicitly in rack 1.x
-    BUFSIZE = 16384
-
-    def self.parse(headers,body)
-      self.new(headers,body).parse
+    def self.parse(headers, body)
+      new(headers, body).parse
     end
 
     def initialize(headers, body)
@@ -36,7 +37,7 @@ module Praxis
         @io << chunk
       end
       @io.rewind
-      @parts = Array.new
+      @parts = []
     end
 
     def parse
@@ -46,19 +47,19 @@ module Praxis
 
       loop do
         head, filename, content_type, name, body =
-          get_current_head_and_filename_and_content_type_and_name_and_body
+          current_head_and_filename_and_content_type_and_name_and_body
 
         # Save the rest.
-        if i = @buf.index(rx)
+        if (i = @buf.index(rx))
           body << @buf.slice!(0, i)
-          @buf.slice!(0, @boundary_size+2)
+          @buf.slice!(0, @boundary_size + 2)
 
-          @content_length = -1  if $1 == "--"
+          @content_length = -1 if Regexp.last_match(1) == '--'
         end
 
         filename, data = get_data(filename, body, content_type, name, head)
 
-        parsed_headers = head.split(EOL).each_with_object(Hash.new) do |line, hash|
+        parsed_headers = head.split(EOL).each_with_object({}) do |line, hash|
           match = HEADER_KV.match(line)
           k = match[:k]
           v = match[:v]
@@ -70,7 +71,7 @@ module Praxis
         @parts << part
 
         # break if we're at the end of a buffer, but not if it is the end of a field
-        break if (@buf.empty? && $1 != EOL) || @content_length == -1
+        break if (@buf.empty? && Regexp.last_match(1) != EOL) || @content_length == -1
       end
 
       @io.rewind
@@ -79,6 +80,7 @@ module Praxis
     end
 
     private
+
     def setup_parse
       unless (match = MULTIPART.match @headers['Content-Type'])
         return false
@@ -86,13 +88,13 @@ module Praxis
 
       @boundary = "--#{match[1]}"
 
-      @buf = ""
+      @buf = String.new
 
       @params = new_params
 
       @boundary_size = @boundary.bytesize + EOL.size
 
-      if @content_length = @headers['Content-Length']
+      if (@content_length = @headers['Content-Length'])
         @content_length = @content_length.to_i
         @content_length -= @boundary_size
       end
@@ -119,36 +121,35 @@ module Praxis
     end
 
     def fast_forward_to_first_boundary
-      preamble = ''
+      preamble = String.new
       loop do
         content = @io.read(BUFSIZE)
-        raise EOFError, "bad content body" unless content
+        raise EOFError, 'bad content body' unless content
+
         @buf << content
 
         while @buf.gsub!(UNTIL_NEWLINE, '')
-          read_buffer = $1
-          if read_buffer == full_boundary
-            return preamble.gsub!(TERMINAL_CRLF,'')
-          else
-            preamble << read_buffer
-          end
+          read_buffer = Regexp.last_match(1)
+          return preamble.gsub!(TERMINAL_CRLF, '') if read_buffer == full_boundary
+
+          preamble << read_buffer
         end
 
-        raise EOFError, "bad content body" if Rack::Utils.bytesize(@buf) >= BUFSIZE
+        raise EOFError, 'bad content body' if Rack::Utils.bytesize(@buf) >= BUFSIZE
       end
     end
 
-    def get_current_head_and_filename_and_content_type_and_name_and_body
+    def current_head_and_filename_and_content_type_and_name_and_body
       head = nil
-      body = ''
+      body = String.new
       filename = content_type = name = nil
       content = nil
 
       until head && @buf =~ rx
-        if !head && i = @buf.index(EOL+EOL)
-          head = @buf.slice!(0, i+2) # First \r\n
+        if !head && (i = @buf.index(EOL + EOL))
+          head = @buf.slice!(0, i + 2) # First \r\n
 
-          @buf.slice!(0, 2)          # Second \r\n
+          @buf.slice!(0, 2) # Second \r\n
 
           content_type = head[MULTIPART_CONTENT_TYPE, 1]
           name = head[MULTIPART_CONTENT_DISPOSITION, 1] || head[MULTIPART_CONTENT_ID, 1]
@@ -157,7 +158,7 @@ module Praxis
           filename = get_filename(head)
 
           if filename
-            body = Tempfile.new("RackMultipart")
+            body = Tempfile.new('RackMultipart')
             body.binmode if body.respond_to?(:binmode)
           end
 
@@ -165,12 +166,10 @@ module Praxis
         end
 
         # Save the read body part.
-        if head && (@boundary_size+4 < @buf.size)
-          body << @buf.slice!(0, @buf.size - (@boundary_size+4))
-        end
+        body << @buf.slice!(0, @buf.size - (@boundary_size + 4)) if head && (@boundary_size + 4 < @buf.size)
 
         content = @io.read(@content_length && BUFSIZE >= @content_length ? @content_length : BUFSIZE)
-        raise EOFError, "bad content body"  if content.nil? || content.empty?
+        raise EOFError, 'bad content body' if content.nil? || content.empty?
 
         @buf << content
         @content_length -= content.size if @content_length
@@ -183,34 +182,30 @@ module Praxis
       filename = nil
       if head =~ RFC2183
         filename = Hash[head.scan(DISPPARM)]['filename']
-        filename = $1 if filename and filename =~ /^"(.*)"$/
+        filename = Regexp.last_match(1) if filename && filename =~ (/^"(.*)"$/)
       elsif head =~ BROKEN_QUOTED
-        filename = $1
+        filename = Regexp.last_match(1)
       elsif head =~ BROKEN_UNQUOTED
-        filename = $1
+        filename = Regexp.last_match(1)
       end
 
-      if filename && filename.scan(/%.?.?/).all? { |s| s =~ /%[0-9a-fA-F]{2}/ }
-        filename = Rack::Utils.unescape(filename)
-      end
-      if filename && filename !~ /\\[^\\"]/
-        filename = filename.gsub(/\\(.)/, '\1')
-      end
+      filename = Rack::Utils.unescape(filename) if filename&.scan(/%.?.?/)&.all? { |s| s =~ /%[0-9a-fA-F]{2}/ }
+      filename = filename.gsub(/\\(.)/, '\1') if filename && filename !~ /\\[^\\"]/
       filename
     end
 
-    def get_data(filename, body, content_type, name, head)
+    def get_data(filename, body, _content_type, _name, _head)
       # filename is blank which means no file has been selected
-      return nil if filename == ""
+      return nil if filename == ''
 
       # Take the basename of the upload's original filename.
       # This handles the full Windows paths given by Internet Explorer
       # (and perhaps other broken user agents) without affecting
       # those which give the lone filename.
-      filename = filename.split(/[\/\\]/).last if filename
+      filename = filename.split(%r{[/\\]}).last if filename
 
       # Rewind any IO bodies so the app can read them at its leisure
-      body.rewind if  body.is_a?(IO)
+      body.rewind if body.is_a?(IO)
 
       [filename, body]
     end

data/lib/praxis/multipart/part.rb

@@ -1,22 +1,16 @@
+# frozen_string_literal: true
+
 module Praxis
   class MultipartPart
     include Attributor::Type
 
-    attr_accessor :body
-    attr_accessor :headers
-    attr_accessor :filename
-    attr_accessor :name
-    attr_accessor :payload_attribute
-    attr_accessor :headers_attribute
-    attr_accessor :filename_attribute
-    attr_accessor :default_handler
+    attr_reader :name, :filename
+    attr_accessor :body, :headers, :payload_attribute, :headers_attribute, :filename_attribute, :default_handler
 
     def self.check_option!(name, definition)
       case name
       when :payload_attribute, :headers_attribute, :filename_attribute
-        unless definition.nil? || definition.kind_of?(Attributor::Attribute)
-          raise Attributor::AttributorException.new("Value for option #{name.inspect} must be an Attribute. Got #{definition.class.name}")
-        end
+        raise Attributor::AttributorException, "Value for option #{name.inspect} must be an Attribute. Got #{definition.class.name}" unless definition.nil? || definition.is_a?(Attributor::Attribute)
       else
         return :unknown
       end
@@ -32,32 +26,30 @@ module Praxis
       :object
     end
 
-    def self.example(context=nil, options:{})
+    def self.example(context = nil, options: {})
       if (payload_attribute = options[:payload_attribute])
         payload = payload_attribute.example(context + ['payload'])
       end
 
       headers = if (headers_attribute = options[:headers_attribute])
-        headers_attribute.example(context + ['headers'])
-      else
-        {}
-      end
+                  headers_attribute.example(context + ['headers'])
+                else
+                  {}
+                end
 
       name = options[:name]
 
       filename = if (filename_attribute = options[:filename_attribute])
-        filename_attribute.example(context + ['filename'])
-      else
-        nil
-      end
+                   filename_attribute.example(context + ['filename'])
+                 end
 
-      self.new(payload, headers, name: name, filename: filename,
-               payload_attribute: payload_attribute,
-               headers_attribute: headers_attribute,
-               filename_attribute: filename_attribute)
+      new(payload, headers, name: name, filename: filename,
+                            payload_attribute: payload_attribute,
+                            headers_attribute: headers_attribute,
+                            filename_attribute: filename_attribute)
     end
-    
-    def self.describe(shallow=true, example: nil, options:{})
+
+    def self.describe(shallow = true, example: nil, options: {})
       hash = super(shallow, example: example)
 
       if (payload_attribute = options[:payload_attribute])
@@ -76,63 +68,49 @@ module Praxis
       hash
     end
 
-    def initialize(body, headers={}, name: nil, filename: nil, payload_attribute: nil, headers_attribute: nil, filename_attribute: nil)
-      @name = name
+    def initialize(body, headers = {}, **args)
+      @name = args[:name]
       @body = body
       @headers = headers
       @default_handler = Praxis::Application.instance.handlers['json']
 
-      if content_type.nil?
-        self.content_type = 'text/plain'
-      end
+      self.content_type = 'text/plain' if content_type.nil?
 
-      @filename = filename
+      @filename = args[:filename]
 
-      @payload_attribute = payload_attribute
-      @headers_attribute = headers_attribute
-      @filename_attribute = filename_attribute
+      @payload_attribute = args[:payload_attribute]
+      @headers_attribute = args[:headers_attribute]
+      @filename_attribute = args[:filename_attribute]
 
       reset_content_disposition
     end
 
-    alias_method :payload, :body
-    alias_method :payload=, :body=
+    alias payload body
+    alias payload= body=
 
     def attribute=(attribute)
-      unless self.kind_of?(attribute.type)
-        raise ArgumentError, "invalid attribute type #{attribute.type}"
-      end
+      raise ArgumentError, "invalid attribute type #{attribute.type}" unless is_a?(attribute.type)
 
-      if attribute.options.key? :payload_attribute
-        @payload_attribute = attribute.options[:payload_attribute]
-      end
+      @payload_attribute = attribute.options[:payload_attribute] if attribute.options.key? :payload_attribute
 
-      if attribute.options.key? :headers_attribute
-        @headers_attribute = attribute.options[:headers_attribute]
-      end
-
-      if attribute.options.key? :filename_attribute
-        @filename_attribute = attribute.options[:filename_attribute]
-      end
+      @headers_attribute = attribute.options[:headers_attribute] if attribute.options.key? :headers_attribute
 
+      @filename_attribute = attribute.options[:filename_attribute] if attribute.options.key? :filename_attribute
     end
 
-    def load_payload(context=Attributor::DEFAULT_ROOT_CONTEXT)
-      if self.payload_attribute
-        value = if self.payload.kind_of?(String)
-          handler.parse(self.payload)
-        else
-          self.payload
-        end
+    def load_payload(_context = Attributor::DEFAULT_ROOT_CONTEXT)
+      return unless payload_attribute
 
-        self.payload = self.payload_attribute.load(value)
-      end
+      value = if payload.is_a?(String)
+                handler.parse(payload)
+              else
+                payload
+              end
+      self.payload = payload_attribute.load(value)
     end
 
-    def load_headers(context=Attributor::DEFAULT_ROOT_CONTEXT)
-      if self.headers_attribute
-        self.headers = self.headers_attribute.load(self.headers)
-      end
+    def load_headers(_context = Attributor::DEFAULT_ROOT_CONTEXT)
+      self.headers = headers_attribute.load(headers) if headers_attribute
     end
 
     # Determine the content type of this response.
@@ -166,42 +144,39 @@ module Praxis
       end
     end
 
-    def validate_headers(context=Attributor::DEFAULT_ROOT_CONTEXT)
-      return [] unless self.headers_attribute
+    def validate_headers(context = Attributor::DEFAULT_ROOT_CONTEXT)
+      return [] unless headers_attribute
 
-      self.headers_attribute.validate(headers, context + ['headers'])
+      headers_attribute.validate(headers, context + ['headers'])
     end
 
-    def validate_payload(context=Attributor::DEFAULT_ROOT_CONTEXT)
-      return [] unless self.payload_attribute
+    def validate_payload(context = Attributor::DEFAULT_ROOT_CONTEXT)
+      return [] unless payload_attribute
 
-      self.payload_attribute.validate(payload, context + ['payload'])
+      payload_attribute.validate(payload, context + ['payload'])
     end
 
-    def validate_filename(context=Attributor::DEFAULT_ROOT_CONTEXT)
-      return [] unless self.filename_attribute
+    def validate_filename(context = Attributor::DEFAULT_ROOT_CONTEXT)
+      return [] unless filename_attribute
 
-      self.filename_attribute.validate(filename, context + ['filename'])
+      filename_attribute.validate(filename, context + ['filename'])
     end
 
-    def validate(context=Attributor::DEFAULT_ROOT_CONTEXT)
+    def validate(context = Attributor::DEFAULT_ROOT_CONTEXT)
       errors = validate_headers(context)
-      errors.push *validate_payload(context)
-      errors.push *validate_filename(context)
+      errors.push(*validate_payload(context))
+      errors.push(*validate_filename(context))
     end
 
     def reset_content_disposition
-      self.headers['Content-Disposition'] = begin
+      headers['Content-Disposition'] = begin
         disposition = "form-data; name=#{name}"
-        if filename
-          disposition += "; filename=#{filename}"
-        end
+        disposition += "; filename=#{filename}" if filename
 
         disposition
       end
     end
 
-
     def name=(name)
       @name = name
       reset_content_disposition
@@ -221,25 +196,23 @@ module Praxis
 
     # Determine an appropriate default content_type for this part given
     # the preferred handler_name, if possible.
-    # 
+    #
     # Considers any pre-defined set of values on the content_type attributge
     # of the headers.
     def derive_content_type(handler_name)
-      possible_values = if self.content_type.match 'text/plain'
-        _, content_type_attribute = self.headers_attribute && self.headers_attribute.attributes.find { |k,v| k.to_s =~ /^content[-_]{1}type$/i }
-        if content_type_attribute && content_type_attribute.options.key?(:values)
-          content_type_attribute.options[:values]
-        else
-          []
-        end
-      else
-        [self.content_type]
-      end
+      possible_values = if content_type.match 'text/plain'
+                          _, content_type_attribute = headers_attribute&.attributes&.find { |k, _v| k.to_s =~ /^content[-_]{1}type$/i }
+                          if content_type_attribute&.options&.key?(:values)
+                            content_type_attribute.options[:values]
+                          else
+                            []
+                          end
+                        else
+                          [content_type]
+                        end
 
       # generic default encoding is the best we can do
-      if possible_values.empty?
-        return MediaTypeIdentifier.load("application/#{handler_name}")
-      end
+      return MediaTypeIdentifier.load("application/#{handler_name}") if possible_values.empty?
 
       # if any defined value match the preferred handler_name, return it
       possible_values.each do |ct|
@@ -253,38 +226,33 @@ module Praxis
       # and return that one if it already corresponds to a registered handler
       # otherwise, add the encoding
       if Praxis::Application.instance.handlers.include?(pick.handler_name)
-        return pick
+        pick
       else
-        return pick + handler_name
+        pick + handler_name
       end
-
     end
 
     def dump(default_format: nil, **opts)
-      original_content_type = self.content_type
+      original_content_type = content_type
 
-      body = self.payload_attribute.dump(self.payload, **opts)
+      body = payload_attribute.dump(payload, **opts)
 
       body_string = case body
-      when Hash, Array
-        if default_format
-          self.content_type = derive_content_type(default_format)
-        end
+                    when Hash, Array
+                      self.content_type = derive_content_type(default_format) if default_format
 
-        self.handler.generate(body)
-      else
-        body
-      end
+                      handler.generate(body)
+                    else
+                      body
+                    end
 
-      header_string = self.headers.collect do |name, value|
+      header_string = headers.collect do |name, value|
         "#{name}: #{value}"
       end.join("\r\n")
 
-
       "#{header_string}\r\n\r\n#{body_string}"
     ensure
       self.content_type = original_content_type
     end
-
   end
 end

data/lib/praxis/notifications.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'active_support/notifications'
 
 require 'singleton'
 
 module Praxis
-
   module Notifications
     include Praxis::PluginConcern
 
@@ -13,7 +14,6 @@ module Praxis
       def config_key
         :notifications # 'praxis.notifications'
       end
-
     end
 
     def self.publish(name, *args)
@@ -35,7 +35,5 @@ module Praxis
     def self.unsubscribe(subscriber_or_name)
       ActiveSupport::Notifications.unsubscribe(subscriber_or_name)
     end
-
-
   end
 end

data/lib/praxis/plugin.rb

@@ -1,44 +1,37 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   # one instance is created per use.
   class Plugin
-
-    attr_accessor :application
-    attr_accessor :block
-    attr_accessor :config
-    attr_accessor :config_attribute
+    attr_accessor :application, :block, :config, :config_attribute
 
     def options
       @options ||= {}
     end
 
-    def config_key
-    end
+    def config_key; end
 
-    def prepare_config!(node)
-    end
+    def prepare_config!(node); end
 
     def load_config!
-      return unless options.has_key?(:config_file)
+      return unless options.key?(:config_file)
       return {} unless (application.root + options[:config_file]).exist?
 
       YAML.load_file(application.root + options[:config_file])
     end
 
-    def setup!
-    end
+    def setup!; end
 
     def register_doc_browser_plugin(path)
       application.doc_browser_plugin_paths << File.expand_path(path)
     end
 
-    def after(stage,&block)
-      application.bootloader.after(stage,&block)
+    def after(stage, &block)
+      application.bootloader.after(stage, &block)
     end
 
-    def before(stage,&block)
-      application.bootloader.before(stage,&block)
+    def before(stage, &block)
+      application.bootloader.before(stage, &block)
     end
-
   end
 end

data/lib/praxis/plugin_concern.rb

@@ -1,5 +1,6 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   module PluginConcern
     extend ::ActiveSupport::Concern
 
@@ -8,35 +9,31 @@ module Praxis
     end
 
     module ClassMethods
-      PLUGIN_CLASSES = [
-        :Request,
-        :Controller,
-        :EndpointDefinition,
-        :ActionDefinition,
-        :Response,
-        :ApiGeneralInfo
-      ]
+      PLUGIN_CLASSES = %i[
+        Request
+        Controller
+        EndpointDefinition
+        ActionDefinition
+        Response
+        ApiGeneralInfo
+      ].freeze
 
       def setup!
         return if @setup
 
         PLUGIN_CLASSES.each do |name|
-          if self.constants.include?(name)
-            inject!(name)
-          end
+          inject!(name) if constants.include?(name)
         end
 
         @setup = true
       end
 
       def inject!(name)
-        plugin = self.const_get(name)
+        plugin = const_get(name)
         praxis = Praxis.const_get(name)
 
         praxis.include(plugin)
       end
-
     end
   end
-
 end