dry-swagger 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ea8396c1d7976844254a7e7564a74a0cdc0391c3bf42a4aa49fc479fd99e11e
-  data.tar.gz: 611a49427c0c0ece4bd4ec1e134afd8bcebc01f43b0803eecabdd9cf16df4d14
+  metadata.gz: 5179183ed4122bcf5042f8aa812b6830b1126ae00d4eb2975bd17203af2bf375
+  data.tar.gz: 9eb614eaaaca4752a39f9a77ef2fac3dffb4df2179a0c7e7f427d13f9f02333e
 SHA512:
-  metadata.gz: 7d1e8404d230897c6f4e88fffbd1870ee1fbf305b725d8d9067f5529c3f2bcdda71990b364372478d3ff9f780e6a997144c557f57f574768d705caea10255923
-  data.tar.gz: 0d7b5f769a536d9fd18b594cf097c5c9922b92f74bdf009ff2dd90ea099e90c5bc9d36aa684efcdd49a1176f299d6db2574a786a8a98213a5301a15bfdb223bf
+  metadata.gz: 58dea258473d5fea4c521d699a2332ec8a444d15504b81ff3eefba0ef50c08371fe5d9b3fd7e2d3331613375f625bdb3ea54073dde31cfc20eafdc0d29e49202
+  data.tar.gz: 2ec6862a8021cb836101cac89b394482507a6b48021cfbf304b63c8753fe0bcefb822730a194ae869da6c83dc34e965af771a58b6052dc729cea0d528a97b6a4

data/Gemfile.lock

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

data/README.md

@@ -33,7 +33,7 @@ Or install it yourself as:
         end
     end
     
-    Dry::Swagger::ContractParser.new.call(Contract)
+    Dry::Swagger::ContractParser.new.call(Contract).to_swagger
     => {
          "type": "object",
          "properties": {
@@ -81,7 +81,7 @@ Or install it yourself as:
       end
     end
     
-    Dry::Swagger::ContractParser.new.call(Contract)
+    Dry::Swagger::ContractParser.new.call(Contract).to_swagger
     => {
          "type": "object",
          "properties": {
@@ -135,7 +135,7 @@ Or install it yourself as:
       attribute? :optional_nullable_string, Types::String.optional
     end
     
-    Dry::Swagger::StructParser.new.call(DTO)
+    Dry::Swagger::StructParser.new.call(DTO).to_swagger
     => {
          "type": "object",
          "properties": {
@@ -170,7 +170,22 @@ Or install it yourself as:
          ]
        }
 #### With nested fields
-    {
+    class NestedDTO < Dry::Struct
+      attribute  :required_string, Types::String
+      attribute  :required_nullable_string, Types::String.optional
+      attribute  :required_string_with_enum, Types::String.enum('enum1')
+      attribute? :optional_string, Types::String
+      attribute? :optional_nullable_string, Types::String.optional
+    end
+    
+    class DTO < Dry::Struct
+      attribute  :array_of_integer, Types::Array.of(Types::Integer)
+      attribute  :array_of_objects, Types::Array.of(NestedDTO)
+      attribute  :dto, NestedDTO
+    end
+    
+    Dry::Swagger::StructParser.new.call(DTO).to_swagger
+    => {
       "type": "object",
       "properties": {
         "array_of_integer": {
@@ -258,21 +273,63 @@ Or install it yourself as:
         "dto"
       ]
     }
+## Overriding fields on run time
+You can also modify the fields during runtime by passing a block after the .call() method.
+
+For example:
+    
+    Dry::Swagger::StructParser.new.call(DTO) do |it|
+      # types = string/integer/hash/array
+      
+      # Remove a field
+      its.keys = it.keys.except(:field_name) 
+      
+      # Add new field on root level
+      it.keys[:new_field_name] = { type: type, required: true/false, :it.config.nullable_type=>true/false } 
+      
+      # Add a new field in nested hash/array
+      it.keys[:nested_field][:keys][:new_field_name] = { 
+        type: type, required: true/false, :it.config.nullable_type=>true/false
+      }
+      
+      # Remove a field in nested hash/array
+      it.keys = it.keys[:nested_field][:keys].except(:field_name)
+      
+      # Add an array or hash
+      it.keys[:nested_field] = { 
+        type: "array/hash", required: true/false, :it.config.nullable_type=> true/false, keys: {
+          # List all nested fields
+          new_field: { type: :type, required: true/false, :it.config.nullable_type=>true/false }
+        }
+      }
+      
+      # Add an Array of primitive types, type field needs to be the element type(string, integer, float), 
+      and add an array: true flag
+      
+      it.keys[:array_field_name] = { 
+        type: type, array: true, required: true/false, :it.config.nullable_type=> true/false 
+      }
+      
+    end.to_swagger()
 ## 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,86 @@
+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)
+          if attributes_hash.is_a?(Hash)
+            documentation[:required] << field_name if attributes_hash.fetch(:required, true) && @config.enable_required_validation
+          else
+            documentation[:required] << field_name if attributes_hash[0].fetch(:required, true) && @config.enable_required_validation
+          end
+
+        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.is_a?(Array)
+          properties = {}
+          attributes_hash.each_with_index do |_, index|
+            properties["definition_#{index + 1}"] = generate_field_properties(attributes_hash[index])
+          end
+          {
+              oneOf: attributes_hash.map{ |it| generate_field_properties(it) },
+              type: :object,
+              properties: properties,
+              example: 'Dynamic Field. See Model Definitions'
+          }
+        else
+          if attributes_hash[:type] == 'array'
+            items = generate_documentation(attributes_hash.fetch(:keys))
+            items =  @config.enable_nullable_validation ?
+                         items.merge(@config.nullable_type => attributes_hash.fetch(@config.nullable_type, false)) :
+                         items.merge(@config.nullable_type => true)
+            documentation = { type: :array, items: items }
+          elsif attributes_hash[:array] && attributes_hash.fetch(:type) != 'array'
+            items = SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(attributes_hash.fetch(:type))
+            items = @config.enable_nullable_validation ?
+                        items.merge(@config.nullable_type => attributes_hash.fetch(@config.nullable_type, false)) :
+                        items.merge(@config.nullable_type => true)
+            documentation = { type: :array, items:  items }
+          elsif attributes_hash[:type] == 'hash'
+            raise Errors::MissingHashSchemaError.new unless attributes_hash[:keys]
+            documentation = generate_documentation(attributes_hash.fetch(:keys))
+          else
+            documentation = SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(attributes_hash.fetch(:type))
+            if attributes_hash[:enum] && @config.enable_enums
+              documentation = documentation.merge(enum: attributes_hash.fetch(:enum))
+            end
+
+            if attributes_hash[:description] && @config.enable_descriptions
+              documentation = documentation.merge(description: attributes_hash.fetch(:description))
+            end
+          end
+
+          @config.enable_nullable_validation ?
+              documentation.merge(@config.nullable_type => attributes_hash.fetch(@config.nullable_type, false)) :
+              documentation.merge(@config.nullable_type => true)
+        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,144 @@
 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 = Dry::Swagger::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
+      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
+
+        return unless key
+
+        target_info =  target.to_h if opts[:member]
+
+        type = opts[:array]? 'array' : 'hash'
+
+        definition = {
+            type: type,
+            required: required,
+            @config.nullable_type => nullable,
+            **target_info
+        }
+
+        if opts[:oneOf]
+          keys[key] = keys[key] ? keys[key] << definition : [definition]
         else
-          schema = is_dynamic_schema?(type) ? type.left : type
-          definition = call(schema)
+          keys[key] = definition
         end
+      end
+
+      def visit_key(node, opts = {})
+        name, required, rest = node
+        opts[:key] = name
+        opts[:required] = required
+        visit(rest, opts)
+      end
 
-        ::Dry::Swagger.struct_enable_nullable_validation ? definition.merge(::Dry::Swagger.nullable_type => nullable) : definition
+      def visit_constrained(node, opts = {})
+        node.each {|it| visit(it, opts) }
       end
 
-      private
+      def visit_nominal(_node, _opts); end
+
+      def visit_predicate(node, opts = {})
+        name, rest = node
+        type = rest[0][1]
 
-      def is_enum?(class_name)
-        class_name == 'Dry::Types::Enum'
+        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
 
-      def is_array?(type_name)
-        type_name == 'Array'
+      def visit_and(node, opts = {})
+        left, right = node
+
+        visit(left, opts)
+        visit(right, opts)
+      end
+
+      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 = {})
+        if node[0][0].equal?(:constrained)
+          opts[:nullable] = true
+          visit(node[1], opts) # ignore NilClass constrained
+        elsif node[0][0].equal?(:struct) && node[1][0].equal?(:struct)
+          opts[:oneOf] = true
+          visit(node[0], opts)
+          visit(node[1], opts)
+        end
+      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.5.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.5.0
 platform: ruby
 authors:
 - Jane-Terziev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-31 00:00:00.000000000 Z
+date: 2021-08-03 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