dry-swagger 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ed13f9dd94583c53a6397262cd798a8a8897b4ac7d7f1c4484116751ff37e5d
-  data.tar.gz: 777014e503f1f3febde2662275cf858a423806671e0ee4a843be3af43287df10
+  metadata.gz: 81ebe584ca27d649b54274106892160bc2b093f99b478dffc06873da1d4e46a5
+  data.tar.gz: eaecf374689642228916df2b7abf02799aa6ac6f22c7d31cbc1786ba215527d1
 SHA512:
-  metadata.gz: 16a4528fbed7c9dfaba78a4757f489f49e80ffef3801b8cf5a10a49c13951530789ffb2ef1e89daba94b618ef8c3348cb4d4790e4e26db420eef74548cc51664
-  data.tar.gz: a3411261ed52732f5d85fa7402fe232fbd4596b0d4618e22316d8f7f37ee70715481340a9256969a81418ba6c99b2321bcd09570ca371a9ec9c27702c48b5f2b
+  metadata.gz: e29e1554ee459d668656ef0dfb9dba87dc531cd27d841a3b6dc77eb9d97eb5b40a7fee88fdc3cf968e4b87db65ba7ee4dec285d24e619ad4149b7ba012ba02b8
+  data.tar.gz: 61a89adcc627a3ee432cfdad4de2d1bafb1ee215046f46e4fa20188111e1676ff87507587c612474dc0441d207944e1c794c37246b851ff6428221f510c3f6fb

data/.gitignore

@@ -10,3 +10,4 @@
 # rspec failure tracking
 .rspec_status
 .idea/
+config/

data/Gemfile

@@ -7,3 +7,4 @@ gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
 gem "dry-validation"
 gem "dry-struct"
+gem 'i18n'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dry-swagger (0.5.2)
+    dry-swagger (0.6.0)
 
 GEM
   remote: https://rubygems.org/
@@ -46,6 +46,8 @@ GEM
       dry-equalizer (~> 0.2)
       dry-initializer (~> 3.0)
       dry-schema (~> 1.5, >= 1.5.2)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
     ice_nine (0.11.2)
     rake (12.3.3)
     rspec (3.10.0)
@@ -69,6 +71,7 @@ DEPENDENCIES
   dry-struct
   dry-swagger!
   dry-validation
+  i18n
   rake (~> 12.0)
   rspec (~> 3.0)
 

data/README.md

@@ -15,269 +15,269 @@ And then execute:
 
     bundle install
 
-Or install it yourself as:
-
-    gem install dry-swagger
-
-## Usage
-## Dry::Validation::Contract
-    class Contract < Dry::Validation::Contract
-        json do
-            required(:required_field).value(:str?)
-            required(:required_nullable_field).maybe(:str?)
-            required(:required_filled_field).filled(:str?)
-            
-            optional(:optional_field).value(:str?)
-            optional(:optional_nullable_field).maybe(:str?)
-            optional(:optional_filled_field).filled(:str?)
-        end
-    end
+After installing, execute the following command:
     
-    Dry::Swagger::ContractParser.new.call(Contract).to_swagger
-    => {
-         "type": "object",
-         "properties": {
-           "required_field": {
-             "type": "string",
-             "nullable": false
-           },
-           "required_nullable_field": {
-             "type": "string",
-             "nullable": true
-           },
-           "required_filled_field": {
-             "type": "string",
-             "nullable": false
-           },
-           "optional_field": {
-             "type": "string",
-             "nullable": false
-           },
-           "optional_nullable_field": {
-             "type": "string",
-             "nullable": true
-           },
-           "optional_filled_field": {
-             "type": "string",
-             "nullable": false
-           }
-         },
-         "required": [
-           "required_field",
-           "required_nullable_field",
-           "required_filled_field"
-         ]
-       }
-#### With nested fields - hash or array
-    class Contract < Dry::Validation::Contract
-      json do
-        required(:array_field).array(:int?)
-        required(:array_of_hash).array(:hash) do
-          required(:field).value(:str?)
-        end
-        required(:hash_field).hash do
-          required(:field).value(:str?)
+    rake dry-swagger:install
+
+This will generate configuration files in your project under `project/config`. See Configuration section for more details.
+
+##Usage
+
+####With Dry::Validation::Contract
+Lets say we have the following Dry::Validation::Contract definition:
+    
+    class TestContract < Dry::Validation::Contract
+        params do
+            required(:some_field).value(:str?, min_size?: 5, max_size?: 10)
+            required(:some_array_of_objects).array(:hash) do
+                required(:some_nested_attribute).value(:str?)
+            end
+            required(:some_array_of_integers).array(:int?)
+            required(:dto).value(:hash) do
+                optional(:some_nested_attribute).maybe(:str?)
+            end
         end
-      end
     end
     
-    Dry::Swagger::ContractParser.new.call(Contract).to_swagger
-    => {
-         "type": "object",
-         "properties": {
-           "array_field": {
-             "type": "array",
-             "items": {
-               "type": "integer"
-             }
-           },
-           "array_of_hash": {
-             "type": "array",
-             "items": {
-               "type": "object",
-               "properties": {
-                 "field": {
-                   "type": "string",
-                   "x-nullable": false
-                 }
-               },
-               "required": [
-                 "field"
-               ]
-             }
-           },
-           "hash_field": {
-             "type": "object",
-             "properties": {
-               "field": {
-                 "type": "string",
-                 "x-nullable": false
-               }
-             },
-             "required": [
-               "field"
-             ]
-           }
-         },
-         "required": [
-           "array_field",
-           "array_of_hash",
-           "hash_field"
-         ]
-       }
+    parser = Dry::Swagger::ContractParser.new
 
-### With Dry::Struct
-    class DTO < 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
+`parser.call(TestContract)` will set the `keys` of the `parser` object to:
     
-    Dry::Swagger::StructParser.new.call(DTO).to_swagger
-    => {
-         "type": "object",
-         "properties": {
-           "required_string": {
-             "type": "string",
-             "x-nullable": false
-           },
-           "required_nullable_string": {
-             "type": "string",
-             "x-nullable": true
-           },
-           "required_string_with_enum": {
-             "type": "string",
-             "enum": [
-               "enum1"
-             ],
-             "x-nullable": false
-           },
-           "optional_string": {
-             "type": "string",
-             "x-nullable": false
-           },
-           "optional_nullable_string": {
-             "type": "string",
-             "x-nullable": true
-           }
+    {
+        :some_field => {
+            :required => true,
+            :type => "string",
+            :description => "Minimum size: 5, Maximum size: 10"
+        },
+         :some_array_of_objects => { 
+            :required => true,
+            :array => true,
+            :type => "array",
+            :keys => {
+                :some_nested_attribute => {
+                    :required=>true, :type=>"string"
+                }
+            }
          },
-         "required": [
-           "required_string",
-           "required_nullable_string",
-           "required_string_with_enum"
-         ]
-       }
-#### 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
+         :some_array_of_integers => {
+            :required=>true, 
+            :array=>true, 
+            :type=>"integer"
+         },
+         :dto => {
+            :required => true,
+            :type => "hash",
+            :keys => {
+                :some_nested_attribute => {
+                    :required => false, 
+                    :"x-nullable"=>true, 
+                    :type=>"string"
+                }
+            }
+         }
+    }
+
+As we can see, the `ContractParser` goes through all the params defined in the
+schema and generates a hash. The hash is saved in the `keys` attribute of the parser,
+so that we can call `to_swagger` later.
+
+The required key in our result will be set to `true` if the field is defined as
+`required(:field_name)`, and `false` if defined as `optional(:field_name)`.
+
+The "x-nullable" key depends on whether we have defined the field as value, maybe or filled.
+
+For nested objects like array of objects or hash, we add a keys field with a definition
+for each field inside the nested hash.
+
+If the field is an array of primitive type, the type field will equal to the primitive type, and a
+array flag will be set on the field.
+
+Calling `parser.to_swagger` will give the following result:
     
-    Dry::Swagger::StructParser.new.call(DTO).to_swagger
-    => {
+    {
       "type": "object",
       "properties": {
-        "array_of_integer": {
-          "type": "array",
-          "items": {
-            "type": "integer"
-          },
+        "some_field": {
+          "type": "string",
+          "description": "Minimum size: 5, Maximum size: 10",
           "x-nullable": false
         },
-        "array_of_objects": {
+        "some_array_of_objects": {
           "type": "array",
           "items": {
             "type": "object",
             "properties": {
-              "required_string": {
-                "type": "string",
-                "x-nullable": false
-              },
-              "required_nullable_string": {
-                "type": "string",
-                "x-nullable": true
-              },
-              "required_string_with_enum": {
-                "type": "string",
-                "enum": [
-                  "enum1"
-                ],
-                "x-nullable": false
-              },
-              "optional_string": {
+              "some_nested_attribute": {
                 "type": "string",
                 "x-nullable": false
-              },
-              "optional_nullable_string": {
-                "type": "string",
-                "x-nullable": true
               }
             },
             "required": [
-              "required_string",
-              "required_nullable_string",
-              "required_string_with_enum"
-            ]
+              "some_nested_attribute"
+            ],
+            "x-nullable": false
+          },
+          "x-nullable": false
+        },
+        "some_array_of_integers": {
+          "type": "array",
+          "items": {
+            "type": "integer",
+            "x-nullable": false
           },
           "x-nullable": false
         },
         "dto": {
           "type": "object",
           "properties": {
-            "required_string": {
-              "type": "string",
-              "x-nullable": false
-            },
-            "required_nullable_string": {
-              "type": "string",
-              "x-nullable": true
-            },
-            "required_string_with_enum": {
-              "type": "string",
-              "enum": [
-                "enum1"
-              ],
-              "x-nullable": false
-            },
-            "optional_string": {
-              "type": "string",
-              "x-nullable": false
-            },
-            "optional_nullable_string": {
+            "some_nested_attribute": {
               "type": "string",
               "x-nullable": true
             }
           },
           "required": [
-            "required_string",
-            "required_nullable_string",
-            "required_string_with_enum"
+    
           ],
           "x-nullable": false
         }
       },
       "required": [
-        "array_of_integer",
-        "array_of_objects",
+        "some_field",
+        "some_array_of_objects",
+        "some_array_of_integers",
         "dto"
       ]
     }
-## Overriding fields on run time
-You can also modify the fields during runtime by passing a block after the .call() method.
 
-For example:
+####With Dry::Struct
+The `Dry::Swagger::StructParser` works the same as the contract parser.
+
+The required key depends on whether we define the field as attribute or attribute?
+
+The "x-nullable" key depends on whether we define the type as Type or Type.optional.
+
+For more complex types, for example DTO1 | DTO2 or Types::Array.of(DTO1 | DTO2), 
+the parser converts the field value to an array of both schemas.
+
+Example:
+    
+    class DTO1 < Dry::Struct
+        attribute :dto1_field, Types::String
+    end
+    
+    class DTO2 < Dry::Struct
+        attribute :dto2_field, Types::String
+    end
+    
+    class DTO < Dry::Struct
+        attribute :dynamic_dto, DTO1 | DTO2
+    end
+    parser = Dry::Swagger::StructParser.new
+    
+    parser.call(DTO)
+    => {
+         "dynamic_dto": [ # ARRAY
+           {
+             "type": "hash",
+             "required": true,
+             "x-nullable": false,
+             "keys": {
+               "dto1_field": {
+                 "type": "string",
+                 "required": true,
+                 "x-nullable": false
+               }
+             }
+           },
+           {
+             "type": "hash",
+             "required": true,
+             "x-nullable": false,
+             "keys": {
+               "dto2_field": {
+                 "type": "string",
+                 "required": true,
+                 "x-nullable": false
+               }
+             }
+           }
+         ]
+       }
+
+Calling `parser.to_swagger` will give the following result:
     
+    {
+      "type": "object",
+      "properties": {
+        "dynamic_dto": {
+          "type": "object",
+          "properties": {
+            "definition_1": {
+              "type": "object",
+              "properties": {
+                "dto1_field": {
+                  "type": "string",
+                  "x-nullable": false
+                }
+              },
+              "required": [
+                "dto1_field"
+              ],
+              "x-nullable": false
+            },
+            "definition_2": {
+              "type": "object",
+              "properties": {
+                "dto2_field": {
+                  "type": "string",
+                  "x-nullable": false
+                }
+              },
+              "required": [
+                "dto2_field"
+              ],
+              "x-nullable": false
+            }
+          },
+          "example": "Dynamic Field. See Model Definitions",
+          "oneOf": [
+            {
+              "type": "object",
+              "properties": {
+                "dto1_field": {
+                  "type": "string",
+                  "x-nullable": false
+                }
+              },
+              "required": [
+                "dto1_field"
+              ],
+              "x-nullable": false
+            },
+            {
+              "type": "object",
+              "properties": {
+                "dto2_field": {
+                  "type": "string",
+                  "x-nullable": false
+                }
+              },
+              "required": [
+                "dto2_field"
+              ],
+              "x-nullable": false
+            }
+          ]
+        }
+      },
+      "required": [
+        "dynamic_dto"
+      ]
+    }
+
+## Overriding fields
+You can also modify the fields by passing a block after the .call() method.
+
     Dry::Swagger::StructParser.new.call(DTO) do |it|
       # types = string/integer/hash/array
       
@@ -311,26 +311,12 @@ For example:
       }
       
     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::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".
+##Custom Configuration For Your Project
+You can override default configurations by changing the values in the `config/initializers/dry-swagger.rb` file generated from the rake command in the Installation section.
+
+To modify the descriptions for the Contracts, modify the values in `config/locale/dry-swagger.yml`.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/dry/swagger.rb

@@ -7,8 +7,10 @@ require 'dry/swagger/errors/missing_type_error'
 require 'dry/swagger/config/configuration'
 require 'dry/swagger/config/contract_configuration'
 require 'dry/swagger/config/struct_configuration'
+require 'i18n'
 
 module Dry
   module Swagger
+    ::I18n.load_path << Dir[File.expand_path("config/locales") + "/*.yml"]
   end
 end

data/lib/dry/swagger/contract_parser.rb

@@ -116,18 +116,8 @@ module Dry
         end
       end
 
-      def predicate_description(name, validation)
-        case name
-        when 'eql?' then "Must be equal to #{validation}"
-        when 'max_size?' then "Maximum size: #{validation}"
-        when 'min_size?' then "Minimum size: #{validation}"
-        when 'gteq?' then "Greater or equal #{validation}"
-        when 'gt?' then "Greater than #{validation}"
-        when 'lt?' then "Lower than #{validation}"
-        when 'lteq?' then "Lower than or equal to #{validation}"
-        else
-          ''
-        end
+      def predicate_description(name, value)
+        ::I18n.t("contract.descriptions.#{name}", value: value, default: '')
       end
 
       def to_swagger

data/lib/dry/swagger/documentation_generator.rb

@@ -17,83 +17,90 @@ module Dry
 
       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
+        fields.each do |field_name, definition|
+          documentation[:properties][field_name] = generate_field_properties(definition)
+          if definition.is_a?(Hash)
+            documentation[:required] << field_name if definition.fetch(:required, true) && @config.enable_required_validation
           else
-            documentation[:required] << field_name if attributes_hash[0].fetch(:required, true) && @config.enable_required_validation
+            documentation[:required] << field_name if definition[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 }
+          raise StandardError.new e.message % { field_name: field_name, valid_types: SWAGGER_FIELD_TYPE_DEFINITIONS.keys, definition: definition }
         rescue Errors::MissingHashSchemaError => e
-          raise StandardError.new e.message % { field_name: field_name, valid_types: SWAGGER_FIELD_TYPE_DEFINITIONS.keys, attributes_hash: attributes_hash }
+          raise StandardError.new e.message % { field_name: field_name, valid_types: SWAGGER_FIELD_TYPE_DEFINITIONS.keys, definition: definition }
         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
-          if attributes_hash[0][:type] == 'array'
-            attributes_hash.each { |definition| definition[:type] = 'hash'}
-            {
-                type: :array,
-                items: {
-                    type: :object,
-                    properties: properties,
-                    oneOf: attributes_hash.map{ |it| generate_field_properties(it) },
-                    example: 'Dynamic Field. See Model Definitions'
-                },
-            }
-          else
-            {
-                oneOf: attributes_hash.map{ |it| generate_field_properties(it) },
-                type: :object,
-                properties: properties,
-                example: 'Dynamic Field. See Model Definitions'
-            }
-          end
-        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
+      def generate_field_properties(definition)
+        return generate_for_sti_type(definition) if definition.is_a?(Array)
 
-          @config.enable_nullable_validation ?
-              documentation.merge(@config.nullable_type => attributes_hash.fetch(@config.nullable_type, false)) :
-              documentation.merge(@config.nullable_type => true)
+        if definition[:type] == 'array' || definition[:array]
+          documentation = generate_for_array(definition)
+        elsif definition[:type] == 'hash'
+          documentation = generate_for_hash(definition)
+        else
+          documentation = generate_for_primitive_type(definition)
         end
+        @config.enable_nullable_validation ?
+            documentation.merge(@config.nullable_type => definition.fetch(@config.nullable_type, false)) :
+            documentation.merge(@config.nullable_type => true)
 
       rescue KeyError
         raise Errors::MissingTypeError.new
       end
+
+      def generate_for_sti_type(definition)
+        properties = {}
+
+        definition.each_with_index do |_, index|
+          properties["definition_#{index + 1}"] = generate_field_properties(definition[index])
+        end
+
+        documentation = {
+            type: :object,
+            properties: properties,
+            example: 'Dynamic Field. See Model Definitions'
+        }
+
+        if definition[0][:type] == 'array'
+          definition.each { |it| it[:type] = 'hash'}
+          documentation[:oneOf] = definition.map{ |it| generate_field_properties(it) }
+          { type: :array, items: documentation }
+        else
+          documentation[:oneOf] = definition.map{ |it| generate_field_properties(it) }
+          documentation
+        end
+      end
+
+      def generate_for_array(definition)
+        items = array_of_primitive_type?(definition) ?
+                    SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(definition.fetch(:type)) :
+                    generate_documentation(definition.fetch(:keys))
+        items =  @config.enable_nullable_validation ?
+                     items.merge(@config.nullable_type => definition.fetch(@config.nullable_type, false)) :
+                     items.merge(@config.nullable_type => true)
+        { type: :array, items: items }
+      end
+
+      def generate_for_hash(definition)
+        raise Errors::MissingHashSchemaError.new unless definition[:keys]
+        generate_documentation(definition.fetch(:keys))
+      end
+
+      def generate_for_primitive_type(definition)
+        documentation = SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(definition.fetch(:type))
+        documentation = documentation.merge(enum: definition.fetch(:enum)) if definition[:enum] && @config.enable_enums
+        documentation = documentation.merge(description: definition.fetch(:description)) if definition[:description] &&
+                                                                                            @config.enable_descriptions
+        documentation
+      end
+
+      def array_of_primitive_type?(definition)
+        definition[:array] && definition.fetch(:type) != 'array'
+      end
     end
   end
 end

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

@@ -6,7 +6,7 @@ module Dry
           "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}
+          The parser has generated the following definition for the field: %{field_name}: %{definition}
           "
         end
       end

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

@@ -6,7 +6,7 @@ module Dry
           "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}.
+          The parser has generated the following definition for the field: %{field_name}: %{definition}.
           "
         end
       end

data/lib/dry/swagger/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Swagger
-    VERSION = "0.5.2"
+    VERSION = "0.6.0"
   end
 end

data/rakelib/configuration_generator.rake

@@ -0,0 +1,49 @@
+require 'fileutils'
+
+namespace 'dry-swagger' do
+  desc 'Create a configuration file for Struct and Contract'
+  task :create_configuration_file do
+    FileUtils.mkdir_p "#{ Dir.pwd }/config/initializers/"
+    File.open("#{ Dir.pwd }/config/initializers/dry-swagger.rb", "w") { |file|
+file.puts 'Dry::Swagger::Config::StructConfiguration.configuration do |config|
+  config.enable_required_validation = true
+  config.enable_nullable_validation = true
+  config.enable_enums = true
+  config.enable_descriptions = true
+  config.nullable_type = :"x-nullable" # or :nullable
+end
+
+Dry::Swagger::Config::ContractConfiguration.configuration do |config|
+  config.enable_required_validation = true
+  config.enable_nullable_validation = true
+  config.enable_enums = true
+  config.enable_descriptions = true
+  config.nullable_type = :"x-nullable" # or :nullable
+end'
+    }
+  end
+
+  desc 'Create a YAML file for Contract swagger field descriptions'
+  task :create_contract_descriptions_yaml do
+    FileUtils.mkdir_p "#{ Dir.pwd }/config/locales/"
+    File.open("#{ Dir.pwd }/config/locales/dry-swagger.yml", "w") { |file|
+file.puts 'en:
+  contract:
+    descriptions:
+      eql?: "Must be equal to %{value}"
+      max_size?: "Maximum size: %{value}"
+      min_size?: "Minimum size: %{value}"
+      gteq?: "Greater than or equal to %{value}"
+      gt?: "Greater than %{value}"
+      lt?: "Lower than %{value}"
+      lteq?: "Lower than or equal to %{value}"
+'
+    }
+  end
+
+  desc 'Creates configuration files'
+  task :install do
+    Rake::Task['dry-swagger:create_configuration_file'].execute
+    Rake::Task['dry-swagger:create_contract_descriptions_yaml'].execute
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-swagger
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Jane-Terziev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-03 00:00:00.000000000 Z
+date: 2021-08-06 00:00:00.000000000 Z
 dependencies: []
 description: A parser which converts dry-validation or dry-struct into valid swagger
   documentation
@@ -42,6 +42,7 @@ files:
 - lib/dry/swagger/struct_parser.rb
 - lib/dry/swagger/types.rb
 - lib/dry/swagger/version.rb
+- rakelib/configuration_generator.rake
 homepage: https://github.com/Jane-Terziev/dry-swagger
 licenses:
 - MIT