praxis 2.0.pre.17 → 2.0.pre.21

data/lib/praxis/routing_config.rb

@@ -1,28 +1,25 @@
+# frozen_string_literal: true
+
 module Praxis
   class RoutingConfig
+    attr_reader :route, :version, :base
 
-    attr_reader :route
-    attr_reader :version
-    attr_reader :base
-
-    def initialize(version:'n/a'.freeze, base: '', prefix:[], &block)
+    def initialize(version: 'n/a', base: '', prefix: [], &block)
       @version = version
       @base = base
       @prefix_segments = Array(prefix)
 
       @route = nil
 
-      if block_given?
-        instance_eval(&block)
-      end
+      instance_eval(&block) if block_given?
     end
 
     def clear!
       @prefix_segments = []
     end
 
-    def prefix(prefix=nil)
-      return @prefix_segments.join.gsub('//','/') if prefix.nil?
+    def prefix(prefix = nil)
+      return @prefix_segments.join.gsub('//', '/') if prefix.nil?
 
       case prefix
       when ''
@@ -34,28 +31,54 @@ module Praxis
       end
     end
 
-    def options(path, opts={}) add_route 'OPTIONS', path, opts end
-    def get(path, opts={})     add_route 'GET',     path, opts end
-    def head(path, opts={})    add_route 'HEAD',    path, opts end
-    def post(path, opts={})    add_route 'POST',    path, opts end
-    def put(path, opts={})     add_route 'PUT',     path, opts end
-    def delete(path, opts={})  add_route 'DELETE',  path, opts end
-    def trace(path, opts={})   add_route 'TRACE',   path, opts end
-    def connect(path, opts={}) add_route 'CONNECT', path, opts end
-    def patch(path, opts={})   add_route 'PATCH',   path, opts end
-    def any(path, opts={})     add_route 'ANY',     path, opts end
+    def options(path, opts = {})
+      add_route 'OPTIONS', path, opts
+    end
 
-    ABSOLUTE_PATH_REGEX = %r|^//|
+    def get(path, opts = {})
+      add_route 'GET',     path, opts
+    end
 
-    def add_route(verb, path, options={})
-      unless path =~ ABSOLUTE_PATH_REGEX
-        path = prefix + path
-      end
-      prefixed_path = path.gsub('//','/')
-      path = (base + path).gsub('//','/')
-      pattern = Mustermann.new(path, **{ignore_unknown_options: true}.merge( options ))
-      @route = Route.new(verb, pattern, version, prefixed_path: prefixed_path, **options)
+    def head(path, opts = {})
+      add_route 'HEAD',    path, opts
+    end
+
+    def post(path, opts = {})
+      add_route 'POST',    path, opts
+    end
+
+    def put(path, opts = {})
+      add_route 'PUT',     path, opts
+    end
+
+    def delete(path, opts = {})
+      add_route 'DELETE',  path, opts
+    end
+
+    def trace(path, opts = {})
+      add_route 'TRACE',   path, opts
+    end
+
+    def connect(path, opts = {})
+      add_route 'CONNECT', path, opts
+    end
+
+    def patch(path, opts = {})
+      add_route 'PATCH',   path, opts
+    end
+
+    def any(path, opts = {})
+      add_route 'ANY',     path, opts
     end
 
+    ABSOLUTE_PATH_REGEX = %r{^//}.freeze
+
+    def add_route(verb, path, options = {})
+      path = prefix + path unless path =~ ABSOLUTE_PATH_REGEX
+      prefixed_path = path.gsub('//', '/')
+      path = (base + path).gsub('//', '/')
+      pattern = Mustermann.new(path, **{ ignore_unknown_options: true }.merge(options))
+      @route = Route.new(verb, pattern, version, prefixed_path: prefixed_path, **options)
+    end
   end
 end

data/lib/praxis/simple_media_type.rb

@@ -1,29 +1,26 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   # Stripped-down representation of an Internet Media Type where the structure and content of the
   # type are unknown, or are defined externally to the Praxis application.
   #
   # @see Praxis::MediaType
   # @see Praxis::Types::MediaTypeCommon
   SimpleMediaType = Struct.new(:identifier) do
-
     def name
       self.class.name
     end
 
     def self.id
-      "Praxis-SimpleMediaType".freeze
+      'Praxis-SimpleMediaType'
     end
 
     def id
       self.class.id
     end
 
-
-    def describe(shallow=true)
-      {name: name, family: "string", id: id, identifier: identifier}
+    def describe(*)
+      { name: name, family: 'string', id: id, identifier: identifier }
     end
-
   end
-
 end

data/lib/praxis/stage.rb

@@ -1,32 +1,28 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   class Stage
-
-    attr_reader :name
-    attr_reader :context
-    attr_reader :stages
-    attr_reader :before_callbacks
-    attr_reader :after_callbacks
+    attr_reader :name, :context, :stages, :before_callbacks, :after_callbacks
 
     def application
       context
     end
 
-    def initialize(name, context, **opts)
+    def initialize(name, context, **_opts)
       @name = name
       @context = context
-      @before_callbacks = Array.new
-      @after_callbacks = Array.new
-      @deferred_callbacks = Hash.new do |hash,stage|
-        hash[stage] = {before: [], after:[]}
+      @before_callbacks = []
+      @after_callbacks = []
+      @deferred_callbacks = Hash.new do |hash, stage|
+        hash[stage] = { before: [], after: [] }
       end
-      @stages = Array.new
+      @stages = []
     end
 
     def run
-      execute_callbacks(self.before_callbacks)
+      execute_callbacks(before_callbacks)
       execute
-      execute_callbacks(self.after_callbacks)
+      execute_callbacks(after_callbacks)
     end
 
     def setup!
@@ -34,22 +30,20 @@ module Praxis
     end
 
     def setup_deferred_callbacks!
-      @deferred_callbacks.keys.each do |stage_name|
+      @deferred_callbacks.each_key do |stage_name|
         callbacks = @deferred_callbacks.delete stage_name
         callbacks[:before].each do |(*stage_path, block)|
-          self.before(stage_name, *stage_path, &block)
+          before(stage_name, *stage_path, &block)
         end
 
         callbacks[:after].each do |(*stage_path, block)|
-          self.after(stage_name, *stage_path, &block)
+          after(stage_name, *stage_path, &block)
         end
       end
     end
 
     def execute
-      @stages.each do |stage|
-        stage.run
-      end
+      @stages.each(&:run)
     end
 
     def execute_callbacks(callbacks)
@@ -65,7 +59,7 @@ module Praxis
     def before(*stage_path, &block)
       if stage_path.any?
         stage_name = stage_path.shift
-        stage = stages.find { |stage| stage.name == stage_name }
+        stage = stages.find { |s| s.name == stage_name }
         if stage
           stage.before(*stage_path, &block)
         else
@@ -79,7 +73,7 @@ module Praxis
     def after(*stage_path, &block)
       if stage_path.any?
         stage_name = stage_path.shift
-        stage = stages.find { |stage| stage.name == stage_name }
+        stage = stages.find { |s| s.name == stage_name }
         if stage
           stage.after(*stage_path, &block)
         else
@@ -89,7 +83,5 @@ module Praxis
         @after_callbacks << block
       end
     end
-
-
   end
 end

data/lib/praxis/tasks/api_docs.rb

@@ -1,42 +1,43 @@
-namespace :praxis do
+# frozen_string_literal: true
 
+namespace :praxis do
   namespace :docs do
-
-    desc "Generate OpenAPI 3 docs for a Praxis App"
-    task :generate => [:environment] do |t, args|
+    desc 'Generate OpenAPI 3 docs for a Praxis App'
+    task generate: [:environment] do |_t, _args|
       require 'fileutils'
 
       Praxis::Blueprint.caching_enabled = false
-      generator = Praxis::Docs::OpenApiGenerator.new(Dir.pwd)
+      generator = Praxis::Docs::OpenApiGenerator.instance
+      generator.configure_root(Dir.pwd)
       generator.save!
     end
 
-    desc "Preview (and Generate) OpenAPI 3 docs for a Praxis App"
-    task :preview => [:generate] do |t, args|
-      require 'webrick' 
+    desc 'Preview (and Generate) OpenAPI 3 docs for a Praxis App'
+    task preview: [:generate] do |_t, _args|
+      require 'webrick'
       docs_port = 9090
-      root = Dir.pwd + '/docs/openapi/'
+      root = "#{Dir.pwd}/docs/openapi/"
       wb = Thread.new do
-        s = WEBrick::HTTPServer.new(:Port => docs_port, :DocumentRoot => root)
+        s = WEBrick::HTTPServer.new(Port: docs_port, DocumentRoot: root)
         trap('INT') { s.shutdown }
         s.start
       end
       # If there is only 1 version we'll feature it and open the browser onto it
       versions = Dir.children(root)
-      featured_version = (versions.size < 2) ? "#{versions.first}/" : ''
+      featured_version = versions.size < 2 ? "#{versions.first}/" : ''
       `open http://localhost:#{docs_port}/#{featured_version}`
       wb.join
     end
-    desc "Generate and package all OpenApi Docs into a zip, ready for a Web server (like S3...) to present it"
-    task :package => [:generate] do |t, args|
-      docs_root = Dir.pwd + '/docs/openapi/'
-      zip_file = Dir.pwd + '/docs/openapi.zip'
+    desc 'Generate and package all OpenApi Docs into a zip, ready for a Web server (like S3...) to present it'
+    task package: [:generate] do |_t, _args|
+      docs_root = "#{Dir.pwd}/docs/openapi/"
+      zip_file = "#{Dir.pwd}/docs/openapi.zip"
       `rm -f #{zip_file}`
       # NOTE: This assumes the "zip" utility is installed, supporting the recursive flag.
       `zip -r #{zip_file} #{docs_root}`
       puts
       puts "Left packaged API docs in #{zip_file}"
-      puts " --> To view the docs, unzip the file under a web server (or S3...) and access the index.hml files from a browser"
+      puts ' --> To view the docs, unzip the file under a web server (or S3...) and access the index.hml files from a browser'
     end
   end
 end

data/lib/praxis/tasks/console.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 namespace :praxis do
-  desc "Run interactive pry/irb console"
+  desc 'Run interactive pry/irb console'
   task :console do
     have_pry = false
 

data/lib/praxis/tasks/environment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 namespace :praxis do
   task :environment do
     Praxis::Application.instance.setup

data/lib/praxis/tasks/routes.rb

@@ -1,21 +1,22 @@
-namespace :praxis do
+# frozen_string_literal: true
 
+namespace :praxis do
   desc 'List routes, format=json or table, default table'
-  task :routes, [:format] => [:environment] do |t, args|
+  task :routes, [:format] => [:environment] do |_t, args|
     require 'terminal-table'
 
-    table = Terminal::Table.new title: "Routes",
-    headings:  [
-      "Version", "Path", "Verb",
-      "Endpoint", "Action", "Implementation", "Options"
-    ]
+    table = Terminal::Table.new title: 'Routes',
+                                headings: %w[
+                                  Version Path Verb
+                                  Endpoint Action Implementation Options
+                                ]
 
     rows = []
     Praxis::Application.instance.endpoint_definitions.each do |endpoint_definition|
       endpoint_definition.actions.each do |name, action|
         method = begin
-          m = endpoint_definition.controller.instance_method(name)
-        rescue
+          endpoint_definition.controller.instance_method(name)
+        rescue StandardError
           nil
         end
 
@@ -24,31 +25,32 @@ namespace :praxis do
         row = {
           resource: endpoint_definition.name,
           action: name,
-          implementation: method_name,
+          implementation: method_name
         }
 
-        unless action.route
-          warn "Warning: No routes defined for #{endpoint_definition.name}##{name}."
-          rows << row
-        else
+        if action.route
           route = action.route
           rows << row.merge({
-            version: route.version,
-            verb: route.verb,
-            path: route.path,
-            options: route.options
-          })
+                              version: route.version,
+                              verb: route.verb,
+                              path: route.path,
+                              options: route.options
+                            })
+        else
+          warn "Warning: No routes defined for #{endpoint_definition.name}##{name}."
+          rows << row
         end
       end
     end
-    case args[:format] || "table"
-    when "json"
+    format_type = args[:format] || 'table'
+    case format_type
+    when 'json'
       puts JSON.pretty_generate(rows)
-    when "table"
+    when 'table'
       rows.each do |row|
-        formatted_options = row[:options].map{|(k,v)| "#{k}:#{v.to_s}"}.join("\n")
+        formatted_options = row[:options].map { |(k, v)| "#{k}:#{v}" }.join("\n")
         row_data = row.values_at(:version, :path, :verb, :resource,
-                                    :action, :implementation)
+                                 :action, :implementation)
         row_data << formatted_options
         table.add_row(row_data)
       end

data/lib/praxis/tasks.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 require 'praxis/tasks/environment'
 require 'praxis/tasks/console'
 require 'praxis/tasks/routes'
-require 'praxis/tasks/api_docs'
+require 'praxis/tasks/api_docs'

data/lib/praxis/trait.rb

@@ -1,8 +1,8 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   class Trait
-    attr_reader :name
-    attr_reader :attribute_groups
+    attr_reader :name, :attribute_groups
 
     def initialize(&block)
       @name = nil
@@ -11,21 +11,24 @@ module Praxis
       @routing = nil
       @other = []
 
-      @attribute_groups = Hash.new do |h,k|
+      @attribute_groups = Hash.new do |h, k|
         h[k] = []
       end
 
-      if block_given?
-        self.instance_eval(&block)
-      end
+      instance_eval(&block) if block_given?
     end
 
     def method_missing(name, *args, &block)
       @other << [name, args, block]
     end
 
-    def description(desc=nil)
+    def respond_to_missing?(*)
+      true
+    end
+
+    def description(desc = nil)
       return @description if desc.nil?
+
       @description = desc
     end
 
@@ -37,22 +40,20 @@ module Praxis
       @attribute_groups[name] << block
     end
 
-    def headers(*args, &block)
-      create_group(:headers,&block)
+    def headers(*_args, &block)
+      create_group(:headers, &block)
     end
 
-    def params(*args, &block)
-      create_group(:params,&block)
+    def params(*_args, &block)
+      create_group(:params, &block)
     end
 
     def payload(*args, &block)
-      type, opts = args
+      type, _opts = args
 
-      if type && !(type < Attributor::Hash)
-        raise 'payload in a trait with non-hash (or model or struct) is not supported'
-      end
+      raise 'payload in a trait with non-hash (or model or struct) is not supported' if type && !(type < Attributor::Hash)
 
-      create_group(:payload,&block)
+      create_group(:payload, &block)
     end
 
     def routing(&block)
@@ -60,26 +61,24 @@ module Praxis
     end
 
     def describe
-      desc = {description: @description}
+      desc = { description: @description }
       desc[:name] = @name if @name
       desc[:responses] = @responses if @responses.any?
 
-      if @routing
-        desc[:routing] = ConfigHash.new(&@routing).to_hash
-      end
+      desc[:routing] = ConfigHash.new(&@routing).to_hash if @routing
 
       @attribute_groups.each_with_object(desc) do |(name, blocks), hash|
         type_class = if name == :headers
-          # Headers are special:
-          # Keys are strings, they have a special DSL, and are case insensitive
-          hash_opts = {
-            dsl_compiler: ActionDefinition::HeadersDSLCompiler,
-            case_insensitive_load: true
-          }
-          Attributor::Hash.of(key: String).construct(Proc.new {}, **hash_opts)
-        else
-          Attributor::Hash.construct(Proc.new {})
-        end
+                       # Headers are special:
+                       # Keys are strings, they have a special DSL, and are case insensitive
+                       hash_opts = {
+                         dsl_compiler: ActionDefinition::HeadersDSLCompiler,
+                         case_insensitive_load: true
+                       }
+                       Attributor::Hash.of(key: String).construct(proc {}, **hash_opts)
+                     else
+                       Attributor::Hash.construct(proc {})
+                     end
         blocks.each do |block|
           type_class.construct(block)
         end
@@ -89,7 +88,6 @@ module Praxis
       desc
     end
 
-
     def apply!(target)
       @attribute_groups.each do |name, blocks|
         blocks.each do |block|
@@ -97,27 +95,20 @@ module Praxis
         end
       end
 
-      if @routing
-        target.routing(&@routing)
-      end
+      target.routing(&@routing) if @routing
 
       @responses.each do |name, args|
         target.response(name, **args)
       end
+      return unless @other.any?
 
-      if @other.any?
-        @other.each do |name, args, block|
-          if block
-            target.send(name, *args, &block)
-          else
-            target.send(name,*args)
-          end
+      @other.each do |name, args, block|
+        if block
+          target.send(name, *args, &block)
+        else
+          target.send(name, *args)
         end
       end
     end
-
-
-
   end
-
 end

data/lib/praxis/types/fuzzy_hash.rb

@@ -1,35 +1,36 @@
+# frozen_string_literal: true
+
 module Praxis
   module Types
-
     class FuzzyHash
-      def initialize(value={})
+      def initialize(value = {})
         @hash = {}
         @regexes = []
         update(value)
       end
 
       def update(value)
-        value.each do |k,v|
-          self[k] = v
+        value.each do |key, val|
+          self[key] = val
         end
 
         self
       end
 
-      def []=(k,v)
-        case k
+      def []=(key, val)
+        case key
         when Regexp
-          @regexes << k
+          @regexes << key
         end
-        @hash[k] = v
+        @hash[key] = val
       end
 
-      def [](k)
-        return @hash[k] if @hash.key?(k)
+      def [](key)
+        return @hash[key] if @hash.key?(key)
 
-        k = k.to_s
+        key = key.to_s
         @regexes.each do |regex|
-          return @hash[regex] if regex.match(k)
+          return @hash[regex] if regex.match(key)
         end
 
         nil
@@ -42,8 +43,6 @@ module Praxis
       def respond_to_missing?(*args)
         @hash.respond_to?(*args)
       end
-
     end
-
   end
 end

data/lib/praxis/types/media_type_common.rb

@@ -1,43 +1,44 @@
+# frozen_string_literal: true
+
 module Praxis
   module Types
-
     # Traits that are shared by MediaType and SimpleMediaType.
     module MediaTypeCommon
       extend ::ActiveSupport::Concern
 
       module ClassMethods
         def as_json_schema(**args)
-          the_type = @attribute && @attribute.type || member_type
+          the_type = @attribute&.type || member_type
           the_type.as_json_schema(args)
         end
 
         def json_schema_type
-          the_type = @attribute && @attribute.type || member_type
+          the_type = @attribute&.type || member_type
           the_type.json_schema_type
         end
-    
-        def description(text=nil)
+
+        def description(text = nil)
           @description = text if text
           @description
         end
 
-        def display_name( string=nil )
+        def display_name(string = nil)
           unless string
-            return  @display_name ||= self.name.split("::").last  # Best guess at a display name?
+            return @display_name ||= name.split('::').last # Best guess at a display name?
           end
+
           @display_name = string
         end
 
         # Get or set the identifier of this media type.
         #
         # @return [MediaTypeIdentifier] the string-representation of this type's identifier
-        def identifier(identifier=nil)
+        def identifier(identifier = nil)
           return @identifier unless identifier
+
           @identifier = MediaTypeIdentifier.load(identifier)
         end
       end
-
     end
-
   end
 end