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

data/lib/praxis/action_definition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # A RESTful action allows you to define the following:
 # - a payload structure
 # - a params structure
@@ -9,13 +11,7 @@
 
 module Praxis
   class ActionDefinition
-
-    attr_reader :name
-    attr_reader :endpoint_definition
-    attr_reader :api_definition
-    attr_reader :route
-    attr_reader :responses
-    attr_reader :traits
+    attr_reader :name, :endpoint_definition, :api_definition, :route, :responses, :traits
 
     # opaque hash of user-defined medata, used to decorate the definition,
     # and also available in the generated JSON documents
@@ -28,21 +24,19 @@ module Praxis
     @doc_decorations = []
 
     def self.decorate_docs(&callback)
-      self.doc_decorations << callback
+      doc_decorations << callback
     end
 
-    def initialize(name, endpoint_definition, **opts, &block)
+    def initialize(name, endpoint_definition, **_opts, &block)
       @name = name
       @endpoint_definition = endpoint_definition
-      @responses = Hash.new
-      @metadata = Hash.new
+      @responses = {}
+      @metadata = {}
       @route = nil
       @traits = []
 
-      if (media_type = endpoint_definition.media_type)
-        if media_type.kind_of?(Class) && media_type < Praxis::Types::MediaTypeCommon
-          @reference_media_type = media_type
-        end
+      if (media_type = endpoint_definition.media_type) && (media_type.is_a?(Class) && media_type < Praxis::Types::MediaTypeCommon)
+        @reference_media_type = media_type
       end
 
       version = endpoint_definition.version
@@ -59,13 +53,11 @@ module Praxis
 
       endpoint_definition.action_defaults.apply!(self)
 
-      self.instance_eval(&block) if block_given?
+      instance_eval(&block) if block_given?
     end
 
     def trait(trait_name)
-      unless ApiDefinition.instance.traits.has_key? trait_name
-        raise Exceptions::InvalidTrait.new("Trait #{trait_name} not found in the system")
-      end
+      raise Exceptions::InvalidTrait, "Trait #{trait_name} not found in the system" unless ApiDefinition.instance.traits.key? trait_name
 
       trait = ApiDefinition.instance.traits.fetch(trait_name)
       trait.apply!(self)
@@ -77,13 +69,11 @@ module Praxis
       attribute.type.attributes(**options, &block)
     end
 
-    def response(name, type=nil, **args, &block)
+    def response(name, type = nil, **args, &block)
       if type
         # should verify type is a media type
 
-        if block_given?
-          type = type.construct(block)
-        end
+        type = type.construct(block) if block_given?
 
         args[:media_type] = type
       end
@@ -92,27 +82,22 @@ module Praxis
       @responses[name] = template.compile(self, **args)
     end
 
-    def create_attribute(type=Attributor::Struct, **opts, &block)
-      unless opts.key?(:reference)
-        opts[:reference] = @reference_media_type if @reference_media_type && block
-      end
+    def create_attribute(type = Attributor::Struct, **opts, &block)
+      opts[:reference] = @reference_media_type if !opts.key?(:reference) && (@reference_media_type && block)
 
-      return Attributor::Attribute.new(type, opts, &block)
+      Attributor::Attribute.new(type, opts, &block)
     end
 
-    def params(type=Attributor::Struct, **opts, &block)
-      return @params if !block && ( opts.nil? || opts.empty? ) && type == Attributor::Struct
+    def params(type = Attributor::Struct, **opts, &block)
+      return @params if !block && (opts.nil? || opts.empty?) && type == Attributor::Struct
 
-      unless( opts.key? :required )
+      unless opts.key? :required
         opts[:required] = true # Make the payload required by default
       end
 
       if @params
-        unless type == Attributor::Struct && @params.type < Attributor::Struct
-          raise Exceptions::InvalidConfiguration.new(
-            "Invalid type received for extending params: #{type.name}"
-          )
-        end
+        raise Exceptions::InvalidConfiguration, "Invalid type received for extending params: #{type.name}" unless type == Attributor::Struct && @params.type < Attributor::Struct
+
         update_attribute(@params, opts, block)
       else
         @params = create_attribute(type, **opts, &block)
@@ -121,66 +106,59 @@ module Praxis
       @params
     end
 
-    def payload(type=Attributor::Struct, **opts, &block)
-      return @payload if !block && ( opts.nil? || opts.empty? ) && type == Attributor::Struct
+    def payload(type = Attributor::Struct, **opts, &block)
+      return @payload if !block && (opts.nil? || opts.empty?) && type == Attributor::Struct
 
       unless opts.key?(:required)
-        opts = {required: true, null: false}.merge(opts) # Make the payload required and non-nullable by default
+        opts = { required: true, null: false }.merge(opts) # Make the payload required and non-nullable by default
       end
 
       if @payload
-        unless type == Attributor::Struct && @payload.type < Attributor::Struct
-          raise Exceptions::InvalidConfiguration.new(
-            "Invalid type received for extending params: #{type.name}"
-          )
-        end
+        raise Exceptions::InvalidConfiguration, "Invalid type received for extending params: #{type.name}" unless type == Attributor::Struct && @payload.type < Attributor::Struct
+
         update_attribute(@payload, opts, block)
       else
         @payload = create_attribute(type, **opts, &block)
       end
     end
 
-    def headers(type=nil, **opts, &block)
+    def headers(type = nil, **opts, &block)
       return @headers unless block
 
-      unless( opts.key? :required )
+      unless opts.key? :required
         opts[:required] = true # Make the payload required by default
       end
 
       if @headers
         update_attribute(@headers, opts, block)
       else
-        type = Attributor::Hash.of(key:String) unless type
+        type ||= Attributor::Hash.of(key: String)
         @headers = create_attribute(type,
                                     dsl_compiler: HeadersDSLCompiler, case_insensitive_load: true,
                                     **opts, &block)
 
         @headers
       end
-      @precomputed_header_keys_for_rack = nil #clear memoized data
+      @precomputed_header_keys_for_rack = nil # clear memoized data
     end
 
     # Good optimization to avoid creating lots of strings and comparisons
     # on a per-request basis.
     # However, this is hacky, as it is rack-specific, and does not really belong here
     def precomputed_header_keys_for_rack
-      @precomputed_header_keys_for_rack ||= begin
-        @headers.attributes.keys.each_with_object(Hash.new) do |key,hash|
-          name = key.to_s
-          name = "HTTP_#{name.gsub('-','_').upcase}" unless ( name == "CONTENT_TYPE" || name == "CONTENT_LENGTH" )
-          hash[name] = key
-        end
+      @precomputed_header_keys_for_rack ||= @headers.attributes.keys.each_with_object({}) do |key, hash|
+        name = key.to_s
+        name = "HTTP_#{name.gsub('-', '_').upcase}" unless %w[CONTENT_TYPE CONTENT_LENGTH].include?(name)
+        hash[name] = key
       end
     end
 
-
     def routing(&block)
-      @routing_config.instance_eval &block
+      @routing_config.instance_eval(&block)
 
       @route = @routing_config.route
     end
 
-
     def description(text = nil)
       @description = text if text
       @description
@@ -194,7 +172,7 @@ module Praxis
 
       query_string = URI.encode_www_form(hash[:query_params])
       url = hash[:url]
-      url = [url,query_string].join('?') unless query_string.empty?
+      url = [url, query_string].join('?') unless query_string.empty?
 
       route_description[:example] = url
       route_description
@@ -219,24 +197,23 @@ module Praxis
           hash[:payload] = payload_description(example: payload_example)
         end
 
-        hash[:responses] = responses.inject({}) do |memo, (response_name, response)|
+        hash[:responses] = responses.each_with_object({}) do |(_response_name, response), memo|
           memo[response.name] = response.describe(context: context)
-          memo
         end
         hash[:traits] = traits if traits.any?
         # FIXME: change to :routes along with api browser
         # FIXME: change urls to url ... (along with the browser)
-        hash[:urls] = [ ActionDefinition.url_description(route: route, params: self.params, params_example: params_example) ]
+        hash[:urls] = [ActionDefinition.url_description(route: route, params: params, params_example: params_example)]
         self.class.doc_decorations.each do |callback|
           callback.call(self, hash)
         end
       end
     end
 
-    def headers_description(example: )
+    def headers_description(example:)
       output = headers.describe(example: example)
-      required_headers = self.headers.attributes.select{|k,attr| attr.options && attr.options[:required] == true  }
-      output[:example] = required_headers.each_with_object({}) do | (name, attr), hash |
+      required_headers = headers.attributes.select { |_k, attr| attr.options && attr.options[:required] == true }
+      output[:example] = required_headers.each_with_object({}) do |(name, _attr), hash|
         hash[name] = example[name].to_s # Some simple types (like Boolean) can be used as header values, but must convert back to s
       end
       output
@@ -247,23 +224,23 @@ module Praxis
       if route.nil?
         warn "Warning: No route defined for #{endpoint_definition.name}##{name}."
       else
-        route_params = route.path.
-          named_captures.
-          keys.
-          collect(&:to_sym)
+        route_params = route.path
+                            .named_captures
+                            .keys
+                            .collect(&:to_sym)
       end
 
       desc = params.describe(example: example)
-      desc[:type][:attributes].keys.each do |k|
+      desc[:type][:attributes].each_key do |k|
         source = if route_params.include? k
-          'url'
-        else
-          'query'
-        end
+                   'url'
+                 else
+                   'query'
+                 end
         desc[:type][:attributes][k][:source] = source
       end
-      required_params = desc[:type][:attributes].select{|k,v| v[:source] == 'query' && v[:required] == true }.keys
-      phash = required_params.each_with_object({}) do | name, hash |
+      required_params = desc[:type][:attributes].select { |_k, v| v[:source] == 'query' && v[:required] == true }.keys
+      phash = required_params.each_with_object({}) do |name, hash|
         hash[name] = example[name]
       end
       desc[:example] = URI.encode_www_form(phash)
@@ -277,12 +254,10 @@ module Praxis
     # of the headers.
     def derive_content_type(example, handler_name)
       # MultipartArrays *must* use the provided content_type
-      if example.kind_of? Praxis::Types::MultipartArray
-        return MediaTypeIdentifier.load(example.content_type)
-      end
+      return MediaTypeIdentifier.load(example.content_type) if example.is_a? Praxis::Types::MultipartArray
 
-       _, content_type_attribute = self.headers && self.headers.attributes.find { |k,v| k.to_s =~ /^content[-_]{1}type$/i }
-      if content_type_attribute && content_type_attribute.options.key?(:values)
+      _, content_type_attribute = headers&.attributes&.find { |k, _v| k.to_s =~ /^content[-_]{1}type$/i }
+      if content_type_attribute&.options&.key?(:values)
 
         # if any defined value match the preferred handler_name, return it
         content_type_attribute.options[:values].each do |ct|
@@ -295,18 +270,15 @@ 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
-        else
-          return pick + handler_name
-        end
+        return pick if Praxis::Application.instance.handlers.include?(pick.handler_name)
+
+        return pick + handler_name
       end
 
       # generic default encoding
       MediaTypeIdentifier.load("application/#{handler_name}")
     end
 
-
     def payload_description(example:)
       hash = payload.describe(example: example)
 
@@ -322,11 +294,10 @@ module Praxis
 
         # in case handler is nil, use dumped_payload as-is.
         generated_payload = if handler.nil?
-          dumped_payload
-        else
-          handler.generate(dumped_payload)
-        end
-
+                              dumped_payload
+                            else
+                              handler.generate(dumped_payload)
+                            end
 
         hash[:examples][default_handler] = {
           content_type: content_type.to_s,
@@ -337,14 +308,13 @@ module Praxis
       hash
     end
 
-
     def nodoc!
       metadata[:doc_visibility] = :none
     end
 
-    # [DEPRECATED] - Warn of the change of method name for the transition 
+    # [DEPRECATED] - Warn of the change of method name for the transition
     def resource_definition
-      raise "Praxis::ActionDefinition does not use `resource_definition` any longer. Use `endpoint_definition` instead."
+      raise 'Praxis::ActionDefinition does not use `resource_definition` any longer. Use `endpoint_definition` instead.'
     end
   end
 end

data/lib/praxis/api_definition.rb

@@ -1,30 +1,28 @@
+# frozen_string_literal: true
+
 require 'singleton'
 require 'forwardable'
 
 module Praxis
-
   class ApiDefinition
     include Singleton
     extend Forwardable
 
-    attr_reader :traits
-    attr_reader :responses
-    attr_reader :infos
-    attr_reader :global_info
+    attr_reader :traits, :responses, :infos, :global_info
 
     attr_accessor :versioning_scheme
 
     def self.define(&block)
-      if block.arity == 0
-        self.instance.instance_eval(&block)
+      if block.arity.zero?
+        instance.instance_eval(&block)
       else
-        yield(self.instance)
+        yield(instance)
       end
     end
 
     def initialize
-      @responses = Hash.new
-      @traits = Hash.new
+      @responses = {}
+      @traits = {}
       @base_path = ''
 
       @global_info = ApiGeneralInfo.new
@@ -39,20 +37,19 @@ module Praxis
     end
 
     def response(name)
-      return @responses.fetch(name) do
+      @responses.fetch(name) do
         raise ArgumentError, "no response template defined with name #{name.inspect}. Are you forgetting to register it with ApiDefinition?"
       end
     end
 
     def trait(name, &block)
-      if self.traits.has_key? name
-        raise Exceptions::InvalidTrait.new("Overwriting a previous trait with the same name (#{name})")
-      end
-      self.traits[name] = Trait.new(&block)
+      raise Exceptions::InvalidTrait, "Overwriting a previous trait with the same name (#{name})" if traits.key? name
+
+      traits[name] = Trait.new(&block)
     end
 
     # Setting info to the nil version, means setting it for all versions (if they don't override them)
-    def info(version=nil, &block)
+    def info(version = nil, &block)
       if version.nil?
         if block_given?
           @global_info.instance_eval(&block)
@@ -61,26 +58,23 @@ module Praxis
         end
       else
         i = @infos[version]
-        if block_given?
-          i.instance_eval(&block)
-        end
+        i.instance_eval(&block) if block_given?
         i
       end
     end
 
     def describe
       data = Hash.new do |hash, version|
-        hash[version] = Hash.new
+        hash[version] = {}
       end
 
       data[:global][:info] = @global_info.describe
 
       # Fill in the "info" portion
-      @infos.each do |version,info|
+      @infos.each do |version, info|
         data[version][:info] = info.describe
       end
 
-
       if traits.any?
         data[:traits] = {}
         traits.each do |name, trait|
@@ -92,12 +86,12 @@ module Praxis
     end
 
     define do |api|
-      api.response_template :ok do |media_type: , location: nil, headers: nil, description: nil |
+      api.response_template :ok do |media_type:, location: nil, headers: nil, description: nil|
         status 200
-        description( description || 'Standard response for successful HTTP requests.' )
+        description(description || 'Standard response for successful HTTP requests.')
 
         media_type media_type
-        location if location
+        location
         headers&.each do |(name, value)|
           header(name: name, value: value)
         end
@@ -105,16 +99,14 @@ module Praxis
 
       api.response_template :created do |media_type: nil, location: nil, headers: nil, description: nil|
         status 201
-        description( description || 'The request has been fulfilled and resulted in a new resource being created.' )
+        description(description || 'The request has been fulfilled and resulted in a new resource being created.')
 
         media_type media_type if media_type
-        location if location
+        location
         headers&.each do |(name, value)|
           header(name: name, value: value)
         end
       end
     end
-
   end
-
 end