dry-swagger 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ea8396c1d7976844254a7e7564a74a0cdc0391c3bf42a4aa49fc479fd99e11e
-  data.tar.gz: 611a49427c0c0ece4bd4ec1e134afd8bcebc01f43b0803eecabdd9cf16df4d14
+  metadata.gz: c52c6906b862ea3104ef5d841db24a69f38bbaa5cbda13ef553305453e1665cc
+  data.tar.gz: 5887800bdbcccd0603aad3cecba5c593391be2644456cbf4437557aa039ca923
 SHA512:
-  metadata.gz: 7d1e8404d230897c6f4e88fffbd1870ee1fbf305b725d8d9067f5529c3f2bcdda71990b364372478d3ff9f780e6a997144c557f57f574768d705caea10255923
-  data.tar.gz: 0d7b5f769a536d9fd18b594cf097c5c9922b92f74bdf009ff2dd90ea099e90c5bc9d36aa684efcdd49a1176f299d6db2574a786a8a98213a5301a15bfdb223bf
+  metadata.gz: a1c2b6b524bf1a06641b7769c90c40246ef27b970177ddcd81d355c7da38435ea32329eb692107dba85ba00d757e234271a5d72bed167dcc2903e1a0c0312f3e
+  data.tar.gz: cbad39dd938d175ca9713d3a4cb834943d83ceb8efe5507e3c93e9cfb231a70251695fd40bb8eeee3a02278472fcfee603826ef04f3a627c915290f85057635d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dry-swagger (0.3.0)
+    dry-swagger (0.4.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -261,18 +261,22 @@ Or install it yourself as:
 ## Custom Configuration For Your Project
 You can override default configurations by creating a file in config/initializers/dry-swagger.rb and changing the following values.
 
-    Dry::Swagger.configuration do |config|
-      config.struct_enable_required_validation = true / false       
-      config.struct_enable_nullable_validation = true / false
-      config.struct_enable_enums = true / false
-      config.struct_enable_descriptions = true / false
-      
-      config.contract_enable_required_validation = true / false
-      config.contract_enable_nullable_validation = true / false
-      config.contract_enable_enums = true / false
-      config.contract_enable_descriptions = true / false
+    Dry::Swagger::Config::StructConfiguration.configuration do |config|
+      config.enable_required_validation = true / false       
+      config.enable_nullable_validation = true / false
+      config.enable_enums = true / false
+      config.enable_descriptions = true / false
       config.nullable_type = :"x-nullable" / :nullable
     end
+    
+    Dry::Swagger::Config::ContractConfiguration.configuration do |config|
+          config.enable_required_validation = true / false       
+          config.enable_nullable_validation = true / false
+          config.enable_enums = true / false
+          config.enable_descriptions = true / false
+          config.nullable_type = :"x-nullable" / :nullable
+        end
+        
 By default, all these settings are true, and nullable_type is :"x-nullable".
 ## Development
 

data/lib/dry/swagger.rb

@@ -1,24 +1,14 @@
 require "dry/swagger/version"
 require "dry/swagger/contract_parser"
 require "dry/swagger/struct_parser"
-require 'helpers/configuration'
+require 'dry/swagger/documentation_generator'
+require 'dry/swagger/errors/missing_hash_schema_error'
+require 'dry/swagger/errors/missing_type_error'
+require 'dry/swagger/config/configuration'
+require 'dry/swagger/config/contract_configuration'
+require 'dry/swagger/config/struct_configuration'
 
 module Dry
   module Swagger
-    class Error < StandardError; end
-
-    extend Configuration
-
-    define_setting :struct_enable_required_validation, true
-    define_setting :struct_enable_nullable_validation, true
-    define_setting :struct_enable_enums, true
-    define_setting :struct_enable_descriptions, true
-
-    define_setting :contract_enable_required_validation, true
-    define_setting :contract_enable_nullable_validation, true
-    define_setting :contract_enable_enums, true
-    define_setting :contract_enable_descriptions, true
-
-    define_setting :nullable_type, :"x-nullable"
   end
 end

data/lib/dry/swagger/config/configuration.rb

@@ -0,0 +1,32 @@
+module Dry
+  module Swagger
+    module Config
+      module Configuration
+        def configuration
+          yield self
+        end
+
+        def define_setting(name, default = nil)
+          class_variable_set("@@#{name}", default)
+
+          define_class_method "#{name}=" do |value|
+            class_variable_set("@@#{name}", value)
+          end
+
+          define_class_method name do
+            class_variable_get("@@#{name}")
+          end
+        end
+
+        private
+
+        def define_class_method(name, &block)
+          (class << self; self; end).instance_eval do
+            define_method name, &block
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/dry/swagger/config/contract_configuration.rb

@@ -0,0 +1,15 @@
+module Dry
+  module Swagger
+    module Config
+      module ContractConfiguration
+        extend Configuration
+
+        define_setting :enable_required_validation, true
+        define_setting :enable_nullable_validation, true
+        define_setting :enable_enums, true
+        define_setting :enable_descriptions, true
+        define_setting :nullable_type, :"x-nullable"
+      end
+    end
+  end
+end

data/lib/dry/swagger/config/struct_configuration.rb

@@ -0,0 +1,15 @@
+module Dry
+  module Swagger
+    module Config
+      module StructConfiguration
+        extend Configuration
+
+        define_setting :enable_required_validation, true
+        define_setting :enable_nullable_validation, true
+        define_setting :enable_enums, true
+        define_setting :enable_descriptions, true
+        define_setting :nullable_type, :"x-nullable"
+      end
+    end
+  end
+end

data/lib/dry/swagger/contract_parser.rb

@@ -15,22 +15,13 @@ module Dry
           time?: 'time'
       }.freeze
 
-      SWAGGER_FIELD_TYPE_DEFINITIONS = {
-          "string" => { type: :string },
-          "integer" => { type: :integer },
-          "boolean" => { type: :boolean },
-          "float" => { type: :float },
-          "datetime" => { type: :string, format: :datetime },
-          "date" => { type: :string, format: :date },
-          "time" => { type: :string, format: :time },
-      }.freeze
-
       # @api private
       attr_reader :keys
 
       # @api private
       def initialize
         @keys = {}
+        @config = Config::ContractConfiguration
       end
 
       # @api private
@@ -43,7 +34,7 @@ module Dry
         @keys = {}
         visit(contract.schema.to_ast)
         instance_eval(&block) if block_given?
-        to_swagger
+        self
       end
 
       # @api private
@@ -75,14 +66,13 @@ module Dry
       end
 
       def visit_not(_node, opts = {})
-        key = opts[:key]
-        keys[key][::Dry::Swagger.nullable_type] = true if ::Dry::Swagger.contract_enable_nullable_validation
+        keys[opts[:key]][@config.nullable_type] = true
       end
 
       # @api private
       def visit_implication(node, opts = {})
         node.each do |el|
-          opts = opts.merge(required: false) if ::Dry::Swagger.contract_enable_required_validation
+          opts = opts.merge(required: false)
           visit(el, opts)
         end
       end
@@ -96,7 +86,7 @@ module Dry
       def visit_key(node, opts = {})
         name, rest = node
         opts = opts.merge(key: name)
-        opts = opts.merge(required: true) if ::Dry::Swagger.contract_enable_required_validation
+        opts = opts.merge(required: true)
         visit(rest, opts)
       end
 
@@ -107,11 +97,13 @@ module Dry
         key = opts[:key]
 
         if name.equal?(:key?)
-          keys[rest[0][1]] = { required: opts.fetch(:required, true) } if ::Dry::Swagger.contract_enable_required_validation
+          keys[rest[0][1]] = { required: opts.fetch(:required, true) }
         elsif name.equal?(:array?)
           keys[key][:array] = true
         elsif name.equal?(:included_in?)
-          keys[key][:enum] = rest[0][1]
+          enums = rest[0][1]
+          enums += [nil] if opts.fetch(@config.nullable_type, false)
+          keys[key][:enum] = enums
         elsif PREDICATE_TO_TYPE[name]
           keys[key][:type] = PREDICATE_TO_TYPE[name]
         else
@@ -139,34 +131,7 @@ module Dry
       end
 
       def to_swagger
-        generate_documentation(keys)
-      end
-
-      private
-
-      def generate_documentation(fields)
-        documentation = { properties: {}, required: [] }
-        fields.each do |field_name, attributes_hash|
-          documentation[:properties][field_name] = generate_field_properties(attributes_hash)
-          documentation[:required] << field_name if ::Dry::Swagger.contract_enable_required_validation && attributes_hash[:required]
-        end
-        { :type => :object, :properties => documentation[:properties], :required => documentation[:required] }
-      end
-
-      def generate_field_properties(attributes_hash)
-        if attributes_hash[:type] == 'array'
-          { type: :array, items: generate_documentation(attributes_hash[:keys]) }
-        elsif attributes_hash[:array] && attributes_hash[:type] != 'array'
-          { type: :array, items: SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(attributes_hash[:type]) }
-        elsif attributes_hash[:type] == 'hash'
-          generate_documentation(attributes_hash[:keys])
-        else
-          field = SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(attributes_hash[:type])
-          field = field.merge(::Dry::Swagger.nullable_type => attributes_hash[::Dry::Swagger.nullable_type] | false) if ::Dry::Swagger.contract_enable_nullable_validation
-          field = field.merge(enum: attributes_hash[:enum]) if attributes_hash[:enum] if ::Dry::Swagger.contract_enable_enums
-          field = field.merge(description: attributes_hash[:description]) if attributes_hash[:description] if ::Dry::Swagger.contract_enable_descriptions
-          field
-        end
+        DocumentationGenerator.new(@config).generate_documentation(keys)
       end
     end
   end

data/lib/dry/swagger/documentation_generator.rb

@@ -0,0 +1,58 @@
+module Dry
+  module Swagger
+    class DocumentationGenerator
+      SWAGGER_FIELD_TYPE_DEFINITIONS = {
+          "string" => { type: :string },
+          "integer" => { type: :integer },
+          "boolean" => { type: :boolean },
+          "float" => { type: :float },
+          "datetime" => { type: :string, format: :datetime },
+          "date" => { type: :string, format: :date },
+          "time" => { type: :string, format: :time },
+      }.freeze
+
+      def initialize(config)
+        @config = config
+      end
+
+      def generate_documentation(fields)
+        documentation = { properties: {}, required: [] }
+        fields.each do |field_name, attributes_hash|
+          documentation[:properties][field_name] = generate_field_properties(attributes_hash)
+          documentation[:required] << field_name if attributes_hash[:required] && @config.enable_required_validation
+
+        rescue Errors::MissingTypeError => e
+          raise StandardError.new e.message % { field_name: field_name, valid_types: SWAGGER_FIELD_TYPE_DEFINITIONS.keys, attributes_hash: attributes_hash }
+        rescue Errors::MissingHashSchemaError => e
+          raise StandardError.new e.message % { field_name: field_name, valid_types: SWAGGER_FIELD_TYPE_DEFINITIONS.keys, attributes_hash: attributes_hash }
+        end
+
+        { :type => :object, :properties => documentation[:properties], :required => documentation[:required] }
+      end
+
+      def generate_field_properties(attributes_hash)
+        if attributes_hash[:type] == 'array'
+          items = generate_documentation(attributes_hash[:keys])
+          items.merge(@config.nullable_type => attributes_hash[@config.nullable_type] | false) if @config.enable_nullable_validation
+          { type: :array, items: items }
+        elsif attributes_hash[:array] && attributes_hash[:type] != 'array'
+          items = SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(attributes_hash[:type])
+          items = items.merge(@config.nullable_type => attributes_hash[@config.nullable_type] | false) if @config.enable_nullable_validation
+          { type: :array, items:  items }
+        elsif attributes_hash[:type] == 'hash'
+          raise Errors::MissingHashSchemaError.new unless attributes_hash[:keys]
+          generate_documentation(attributes_hash[:keys])
+        else
+          field = SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(attributes_hash[:type])
+          field = field.merge(@config.nullable_type => attributes_hash[@config.nullable_type] | false)  if @config.enable_nullable_validation
+          field = field.merge(enum: attributes_hash[:enum]) if attributes_hash[:enum]  if @config.enable_enums
+          field = field.merge(description: attributes_hash[:description]) if attributes_hash[:description] if @config.enable_descriptions
+          field
+        end
+
+      rescue KeyError
+        raise Errors::MissingTypeError.new
+      end
+    end
+  end
+end

data/lib/dry/swagger/errors/missing_hash_schema_error.rb

@@ -0,0 +1,15 @@
+module Dry
+  module Swagger
+    module Errors
+      class MissingHashSchemaError < StandardError
+        def message
+          "Could not generate documentation for field %{field_name}. The field is defined as hash,
+          but the schema is not defined.
+          Valid types are: %{valid_types}.
+          The parser has generated the following definition for the field: %{field_name}: %{attributes_hash}
+          "
+        end
+      end
+    end
+  end
+end

data/lib/dry/swagger/errors/missing_type_error.rb

@@ -0,0 +1,15 @@
+module Dry
+  module Swagger
+    module Errors
+      class MissingTypeError < StandardError
+        def message
+          "Could not generate documentation for field %{field_name}. The field is missing a type.
+          If the field you have defined is an array, you must specify the type of the elements in that array.
+          Valid types are: %{valid_types}.
+          The parser has generated the following definition for the field: %{field_name}: %{attributes_hash}.
+          "
+        end
+      end
+    end
+  end
+end

data/lib/dry/swagger/struct_parser.rb

@@ -1,81 +1,132 @@
 module Dry
   module Swagger
     class StructParser
-      SWAGGER_FIELD_TYPE_DEFINITIONS = {
-          "String" => { type: :string },
-          "Integer" => { type: :integer },
-          "TrueClass | FalseClass" => { type: :boolean },
-          "BigDecimal" => { type: :decimal },
-          "Float" => { type: :float },
-          "DateTime" => { type: :string, format: :datetime },
-          "Date" => { type: :string, format: :date },
-          "Time" => { type: :string, format: :time }
-      }
-
-      def call(dto)
-        documentation = generate_fields_documentation(dto.schema)
-        { :type => :object, :properties => documentation[:properties], :required => documentation[:required]}
+      PREDICATE_TYPES = {
+          String: 'string',
+          Integer: 'integer',
+          Bool: 'boolean',
+          Float: 'float',
+          Date: 'date',
+          DateTime: 'datetime',
+          Time: 'time'
+      }.freeze
+
+      attr_reader :keys
+
+      def initialize
+        @keys = {}
+        @config = Config::StructConfiguration
       end
 
-      def generate_fields_documentation(dto_schema)
-        documentation = { properties: {}, required: [] }
-        dto_schema.name_key_map.each do |name, schema_key_object|
-          documentation[:properties][name] = schema_key_object.type.optional? ?
-                                                 generate_field_properties(schema_key_object.type.right, true) :
-                                                 generate_field_properties(schema_key_object.type, false)
+      def to_h
+        { keys: keys }
+      end
 
-          documentation[:required] << name if ::Dry::Swagger.struct_enable_required_validation && schema_key_object.required?
-        end
-        documentation
+      def call(dto, &block)
+        @keys = {}
+        visit(dto.schema.to_ast)
+        instance_eval(&block) if block_given?
+        self
+      end
+
+      def visit(node, opts = {})
+        meth, rest = node
+        public_send(:"visit_#{meth}", rest, opts)
+      end
+
+      def visit_constructor(node, opts = {})
+        visit(node[0], opts)
       end
 
-      def generate_field_properties(type, nullable)
-        field_type = type.name
-        if SWAGGER_FIELD_TYPE_DEFINITIONS[field_type] # IS PRIMITIVE FIELD?
-          definition = SWAGGER_FIELD_TYPE_DEFINITIONS[field_type]
-          definition = definition
-          if is_enum?(type.class.name) && ::Dry::Swagger.struct_enable_enums
-            enums = type.values
-            enums += [nil] if nullable
-            definition = definition.merge(enum: enums)
-          end
-        elsif is_array?(field_type)
-          definition = { type: :array }
-          if is_primitive?(type.type.member.name)
-            definition = definition
-            definition = definition.merge(items: SWAGGER_FIELD_TYPE_DEFINITIONS[type.type.member.name])
-          else
-            schema = is_array_with_dynamic_schema?(type.type.member) ? type.type.member.left : type.type.member
-            definition = definition.merge(items: call(schema))
-          end
-        else
-          schema = is_dynamic_schema?(type) ? type.left : type
-          definition = call(schema)
+      def visit_schema(node, opts = {})
+        target = (key = opts[:key]) ? self.class.new : self
+
+        required = opts.fetch(:required, true)
+        nullable = opts.fetch(:nullable, false)
+
+        node[0].each do |child|
+          target.visit(child)
         end
 
-        ::Dry::Swagger.struct_enable_nullable_validation ? definition.merge(::Dry::Swagger.nullable_type => nullable) : definition
+        return unless key
+
+        target_info =  target.to_h if opts[:member]
+
+        type = opts[:array]? 'array' : 'hash'
+
+        keys[key] = {
+            type: type,
+            required: required,
+            @config.nullable_type => nullable,
+            **target_info
+        }
+      end
+
+      def visit_key(node, opts = {})
+        name, required, rest = node
+        opts[:key] = name
+        opts[:required] = required
+        visit(rest, opts)
+      end
+
+      def visit_constrained(node, opts = {})
+        node.each {|it| visit(it, opts) }
+      end
+
+      def visit_nominal(_node, _opts); end
+
+      def visit_predicate(node, opts = {})
+        name, rest = node
+        type = rest[0][1]
+
+        if name.equal?(:type?)
+          type = type.to_s.to_sym
+          return unless PREDICATE_TYPES[type]
+
+          type_definition = {
+              type: PREDICATE_TYPES[type],
+              required: opts.fetch(:required),
+              @config.nullable_type => opts.fetch(:nullable, false)
+          }
+
+          type_definition[:array] = opts[:array] if opts[:array]
+
+          keys[opts[:key]] = type_definition
+        elsif name.equal?(:included_in?)
+          type += [nil] if opts.fetch(:nullable, false)
+          keys[opts[:key]][:enum] = type
+        end
       end
 
-      private
+      def visit_and(node, opts = {})
+        left, right = node
 
-      def is_enum?(class_name)
-        class_name == 'Dry::Types::Enum'
+        visit(left, opts)
+        visit(right, opts)
       end
 
-      def is_array?(type_name)
-        type_name == 'Array'
+      def visit_enum(node, opts = {})
+        visit(node[0], opts)
       end
 
-      def is_primitive?(type_name)
-        !SWAGGER_FIELD_TYPE_DEFINITIONS[type_name].nil?
+      def visit_sum(node, opts = {})
+        opts[:nullable] = true
+        visit(node[1], opts)
+      end
+
+      def visit_struct(node, opts = {})
+        opts[:member] = true
+
+        visit(node[1], opts)
       end
 
-      def is_array_with_dynamic_schema?(member)
-        member.respond_to?(:right)
+      def visit_array(node, opts = {})
+        opts[:array] = true
+        visit(node[0], opts)
       end
 
-      def is_dynamic_schema?(type)
-        !type.respond_to?(:schema)
+      def to_swagger
+        DocumentationGenerator.new(@config).generate_documentation(keys)
       end
     end
   end

data/lib/dry/swagger/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Swagger
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-swagger
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Jane-Terziev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-31 00:00:00.000000000 Z
+date: 2021-08-01 00:00:00.000000000 Z
 dependencies: []
 description: A parser which converts dry-validation or dry-struct into valid swagger
   documentation
@@ -32,11 +32,16 @@ files:
 - bin/setup
 - dry-swagger.gemspec
 - lib/dry/swagger.rb
+- lib/dry/swagger/config/configuration.rb
+- lib/dry/swagger/config/contract_configuration.rb
+- lib/dry/swagger/config/struct_configuration.rb
 - lib/dry/swagger/contract_parser.rb
+- lib/dry/swagger/documentation_generator.rb
+- lib/dry/swagger/errors/missing_hash_schema_error.rb
+- lib/dry/swagger/errors/missing_type_error.rb
 - lib/dry/swagger/struct_parser.rb
 - lib/dry/swagger/types.rb
 - lib/dry/swagger/version.rb
-- lib/helpers/configuration.rb
 homepage: https://github.com/Jane-Terziev/dry-swagger
 licenses:
 - MIT

data/lib/helpers/configuration.rb

@@ -1,27 +0,0 @@
-module Configuration
-
-  def configuration
-    yield self
-  end
-
-  def define_setting(name, default = nil)
-    class_variable_set("@@#{name}", default)
-
-    define_class_method "#{name}=" do |value|
-      class_variable_set("@@#{name}", value)
-    end
-
-    define_class_method name do
-      class_variable_get("@@#{name}")
-    end
-  end
-
-  private
-
-  def define_class_method(name, &block)
-    (class << self; self; end).instance_eval do
-      define_method name, &block
-    end
-  end
-
-end