schemacop 3.0.0.rc2 → 3.0.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73279c1805de5438933af200c883a7f6a813878d583c92bf7e597580f392df95
-  data.tar.gz: 2ac5ce2925de12c5df8a4f82086d967c68d31cd9f8c598cff0da9231d221f5ff
+  metadata.gz: b93149de6cee935353aba3381d9e1ee76b51bc4b19763d8634566d375208fcac
+  data.tar.gz: cb8e1a8b82104f6482d5017d90e3d5c2094d564ac9ef1001d2336bac137886cb
 SHA512:
-  metadata.gz: c04434b491dac3c09018969b13293c029347011a58386234ea5dcca6b3aa7ed8ebe3f291b8d819869d79b3c8c80d5a998bbbca0a95d928988367e04efcad4ec2
-  data.tar.gz: 75564dd05800d295f3eb7ebb606f97ea67f2c19512a62193d49651cc77828836cfa95977465692ac85a5738a8407c7a2275a7cbe34db110c8400e70aa5057e95
+  metadata.gz: 0df1ba4b0c314901d015ca969996ffa9df862c79df0a52129bc3b749add7ff2e60ff52a9fb8a874f82b57017fef821c1e8d5d703093e0fd3bade224e8c84d259
+  data.tar.gz: 1f501b7fdee6cc8347fe1acaf522f268ef5882e595f0c136c68c773b98615b37a05aeeaf1b472c3152546cdd3ae0859dd216eae9850f9f2992c2e970c7111157

data/.releaser_config

@@ -1,4 +1,3 @@
 version_file: VERSION
 always_from_master: true
-yard_path: doc
 gem_style: github

data/CHANGELOG.md

@@ -10,13 +10,19 @@
 ### Changes
 -->
 
-## 3.0.0.r2
+## 3.0.0.rc3 (2020-01-28)
+
+* Add minor improvements to the documentation
+
+* Internal restructuring, no changes in API
+
+## 3.0.0.rc2 (2020-01-28)
 
 * Represent node names as strings internally
 
 * Update documentation
 
-## 3.0.0.rc1
+## 3.0.0.rc1 (2020-01-22)
 
 * Add support for ruby `3.0.0`
 
@@ -24,7 +30,7 @@
 
 * Document all `v3` nodes
 
-## 3.0.0.rc0
+## 3.0.0.rc0 (2020-01-14)
 
 * Add `Schemacop::Schema3`
 

data/README_V3.md

@@ -24,7 +24,7 @@
 
 ## Validation
 
-Using schemacop, you can either choose to validate the data either using the
+Using Schemacop, you can either choose to validate your data either using the
 graceful `validate` method, or the bang variant, `validate!`.
 
 The `validate` method on a schema with some supplied data will return a
@@ -68,14 +68,14 @@ schema.validate!('Foo')         # => Schemacop::Exceptions::ValidationError: /:
 
 Schemacop can raise the following exceptions:
 
-* `Schemacop::Exceptions::ValidationError`: This exception is raised when the `validate!`
-  method is used, and the data that was passed in is invalid. The exception message contains
-  additional informations why the validation failed.
+* `Schemacop::Exceptions::ValidationError`: This exception is raised when the
+  `validate!` method is used, and the data that was passed in is invalid. The
+  exception message contains additional information why the validation failed.
 
   Example:
 
   ```ruby
-  schema = Schemacop::Schema3.new :hash do
+  schema = Schemacop::Schema3.new do
     int! :foo
   end
 
@@ -83,14 +83,14 @@ Schemacop can raise the following exceptions:
   # => Schemacop::Exceptions::ValidationError: /foo: Invalid type, expected "integer".
   ```
 
-* `Schemacop::Exceptions::InvalidSchemaError`: This exception is raised when the schema
-  itself is not valid. The exception message contains additional informations why the
-  validation failed.
+* `Schemacop::Exceptions::InvalidSchemaError`: This exception is raised when the
+  schema itself is not valid. The exception message contains additional
+  information why the validation failed.
 
   Example:
 
- ```ruby
-  Schemacop::Schema3.new :hash do
+  ```ruby
+  Schemacop::Schema3.new do
     int!
   end
 
@@ -109,7 +109,6 @@ The nodes in Schemacop v3 also support generic keywords, similar to JSON schema:
 * `default`: You may provide a default value for items that will be set if the
   value is not given
 
-
 The three keywords `title`, `description` and `examples` aren't used for validation,
 but can be used to document the schema. They will be included in the JSON output
 when you use the `as_json` method:
@@ -134,7 +133,7 @@ schema.validate!('bar') # => "bar"
 schema.validate!('baz') # => Schemacop::Exceptions::ValidationError: /: Value not included in enum ["foo", "bar"].
 ```
 
-Please note, that you can also specify values in the enum that are not valid for
+Please note that you can also specify values in the enum that are not valid for
 the schema. This means that the validation will still fail:
 
 ```ruby
@@ -196,9 +195,9 @@ transformed into various types.
 #### Options
 
 * `min_length`
-  Defines the minimum required string length
+  Defines the (inclusive) minimum required string length
 * `max_length`
-  Defines the maximum required string length
+  Defines the (inclusive) maximum required string length
 * `pattern`
   Defines a (ruby) regex pattern the value will be matched against. Must be a
   string and should generally start with `^` and end with `$` so as to evaluate
@@ -230,7 +229,7 @@ transformed into various types.
 
 * `boolean`
   The string must be either `true` or `false`. This value will be casted to
-  ruby's `TrueClass` or `FalseClass`.
+  Ruby's `TrueClass` or `FalseClass`.
 
 * `binary`
   The string is expected to contain binary contents. No casting or additional
@@ -403,11 +402,11 @@ It consists of one or multiple values, which can be validated using arbitrary no
 
 #### Contains
 
-The `array` node features the contains node, which you can use with the DSL
-method `cont`. With that DSL method, you can specify a schema which at least
-one item in the array needs to validate against.
+The `array` node features the *contains* node, which you can use with the DSL
+method `cont`. With that DSL method, you can specify a schema which at least one
+item in the array needs to validate against.
 
-One usecase for example could be that you want an array of integers, from which
+One use case for example could be that you want an array of integers, from which
 at least one must be 5 or larger:
 
 ```ruby
@@ -447,9 +446,10 @@ how you specify your array contents.
 
 List validation validates a sequence of arbitrary length where each item matches
 the same schema. Unless you specify a `min_items` count on the array node, an
-empty array will also validate. To specify a list validation, use the `list`
-DSL method, and specify the type you want to validate against. Here, you need
-to specify the type of the element using the long `type` name (e.g. `integer` and not `int`).
+empty array will also suffice. To specify a list validation, use the `list` DSL
+method, and specify the type you want to validate against. Here, you need to
+specify the type of the element using the long `type` name (e.g. `integer` and
+not `int`).
 
 For example, you can specify that you want an array with only integers between 1 and 5:
 
@@ -542,8 +542,8 @@ schema.validate!([1, 'foo', 'bar']) # => Schemacop::Exceptions::ValidationError:
 schema.validate!([1, 'foo', 2, 3])  # => [1, "foo", 2, 3]
 ```
 
-Please note, that you cannot use multiple `add` in the same array schema, this will result in
-an exception:
+Please note that you cannot use multiple `add` in the same array schema, this
+will result in an exception:
 
 ```ruby
 schema = Schemacop::Schema3.new :array do
@@ -555,9 +555,10 @@ end
 # => Schemacop::Exceptions::InvalidSchemaError: You can only use "add" once to specify additional items.
 ```
 
-If you want to specify that your schema accept multiple additional types, use the `one_of`
-type (see below for more infos). The correct way to specify that you want to allow additional
-items, which may be an integer or a string is as follows:
+If you want to specify that your schema accept multiple additional types, use
+the `one_of` type (see below for more infos). The correct way to specify that
+you want to allow additional items, which may be an integer or a string is as
+follows:
 
 ```ruby
 schema = Schemacop::Schema3.new :array do
@@ -592,7 +593,7 @@ It consists of key-value-pairs that can be validated using arbitrary nodes.
 * `property_names`
   This option allows to specify a regexp pattern (as string) which validates the
   keys of any properties that are not specified in the hash. This option only
-  makes sense if `additional_properties` is enabled. See below for more informations.
+  makes sense if `additional_properties` is enabled. See below for more information.
 
 * `min_properties`
   Specifies the (inclusive) minimum number of properties a hash must contain.
@@ -645,8 +646,8 @@ schema.validate!('foo' => 42) # => {"foo"=>42}
 
 The result in both cases will be a
 [HashWithIndifferentAccess](https://api.rubyonrails.org/classes/ActiveSupport/HashWithIndifferentAccess.html),
-which means that you can access the data in the hash with the symbol as well
-as the string representation:
+which means that you can access the data in the hash with the symbol as well as
+the string representation:
 
 ```ruby
 schema = Schemacop::Schema3.new :hash do
@@ -660,9 +661,9 @@ result[:foo]  # => 42
 result['foo'] # 42
 ```
 
-Please note, that if you specify the value twice in the data you want to validate,
-once with the key being a symbol and once being a string, Schemacop will raise an
-error:
+Please note that if you specify the value twice in the data you want to
+validate, once with the key being a symbol and once being a string, Schemacop
+will raise an error:
 
 ```ruby
 schema = Schemacop::Schema3.new :hash do
@@ -798,10 +799,11 @@ schema.validate!({
 Type: `:object`\
 DSL: `obj`
 
-The object type represents a ruby `Object`. Please note that the `as_json`  method
-on nodes of this type will just return `{}` (an empty JSON object), as there isn't
-a useful way to represent a ruby object without conflicting with the `Hash` type.
-If you want to represent an JSON object, you should use the `Hash` node.
+The object type represents a Ruby `Object`. Please note that the `as_json`
+method on nodes of this type will just return `{}` (an empty JSON object), as
+there isn't a useful way to represent a Ruby object without conflicting with the
+`Hash` type. If you want to represent a JSON object, you should use the `Hash`
+node.
 
 In the most basic form, this node will accept anything:
 
@@ -882,7 +884,7 @@ schema.validate!('foooo') # => Schemacop::Exceptions::ValidationError: /: Does n
 Type: `:any_of`\
 DSL: `any_of`
 
-Similar to the AllOf node, you can specify multiple schemas, for which the
+Similar to the `all_of` node, you can specify multiple schemas, for which the
 given value needs to validate against at least one of the schemas.
 
 For example, your value needs to be either a string which is at least 2
@@ -899,7 +901,7 @@ schema.validate!('foo') # => "foo"
 schema.validate!(42)    # => 42
 ```
 
-Please note that you need to specify at least one item in the AllOf node:
+Please note that you need to specify at least one item in the `any_of` node:
 
 ```ruby
 Schemacop::Schema3.new :any_of # => Schemacop::Exceptions::InvalidSchemaError: Node "any_of" makes only sense with at least 1 item.
@@ -910,9 +912,9 @@ Schemacop::Schema3.new :any_of # => Schemacop::Exceptions::InvalidSchemaError: N
 Type: `:one_of`\
 DSL: `one_of`
 
-Similar to the AllOf node, you can specify multiple schemas, for which the
-given value needs to validate against at exaclty one of the schemas. If the
-given value validates against multiple schemas, the value is invalid.
+Similar to the `all_of` node, you can specify multiple schemas, for which the
+given value needs to validate against exaclty one of the schemas. If the given
+value validates against multiple schemas, the value is invalid.
 
 For example, if you want an integer which is either a multiple of 2 or 3,
 but not both (i.e. no multiple of 6), you could do it as follows:
@@ -951,7 +953,7 @@ schema.validate!(6) # => Schemacop::Exceptions::ValidationError: /: Matches 2 de
 Type: `:is_not`\
 DSL: `is_not`
 
-With the IsNot node, you can specify a schema which the given value must not
+With the `is_not` node, you can specify a schema which the given value must not
 validate against, i.e. every value which matches the schema will make this node
 invalid.
 
@@ -969,7 +971,7 @@ schema.validate!(3)     # => Schemacop::Exceptions::ValidationError: /: Must not
 schema.validate!('foo') # => "foo"
 ```
 
-Note that a IsNot node needs exactly one item:
+Note that a `is_not` node needs exactly one item:
 
 ```ruby
 schema = Schemacop::Schema3.new :is_not # => Schemacop::Exceptions::InvalidSchemaError: Node "is_not" only allows exactly one item.
@@ -984,7 +986,7 @@ Type: `reference`
 **Definition**
 DSL: `scm`
 
-Finally, with the Reference node, you can define schemas and then later reference
+Finally, with the *Reference* node, you can define schemas and then later reference
 them for usage, e.g. when you have a rather long schema which you need at multiple
 places.
 
@@ -1052,7 +1054,7 @@ schema.validate!([id: 42, first_name: 'Joe'])             # => Schemacop::Except
 
 ## Context
 
-Schemacop als features the concept of a `Context`. You can define schemas in a
+Schemacop also features the concept of a `Context`. You can define schemas in a
 context, and then reference them in other schemas in that context. This is e.g.
 useful if you need a part of the schema to be different depending on the
 business action.
@@ -1076,7 +1078,7 @@ context.schema :PersonInfo do
 end
 
 # Now we can define our general schema, where we reference the :Person schema.
-# Note that at this point, we don't know what's in the :Person sche,a
+# Note that at this point, we don't know what's in the :Person schema.
 schema = Schemacop::Schema3.new :reference, path: :Person
 
 # Validate the data in the context we defined before, where we need the first_name
@@ -1097,7 +1099,7 @@ other_context.schema :Person do
 end
 
 # Finally, validate the data in the new context. We do not want the real name or
-# birth date of the person, instead only the nickname is allowed
+# birth date of the person, instead only the nickname is allowed.
 Schemacop.with_context other_context do
   schema.validate!({first_name: 'Joe', last_name: 'Doe', info: { born_at: '1980-01-01'} })
   # => Schemacop::Exceptions::ValidationError: /nickname: Value must be given.
@@ -1115,11 +1117,11 @@ to use other data in the second context than in the first.
 
 ## External schemas
 
-Finally, schemacop features the possibilit to specify schemas in seperate files.
-This is especially useful is you have schemas in your application which are used
-multiple times through the application.
+Finally, Schemacop features the possibility to specify schemas in seperate
+files.  This is especially useful is you have schemas in your application which
+are used multiple times throughout the application.
 
-For each schema, you define the schema in a single file, and after loading the
+For each schema, you define the schema in a separate file, and after loading the
 schemas, you can reference them in other schemas.
 
 The default load path is `'app/schemas'`, but this can be configured by setting
@@ -1192,4 +1194,4 @@ however you need to eager load the schemas yourself:
 
 ```ruby
 Schemacop::V3::GlobalContext.eager_load!
-```
+```

data/VERSION

@@ -1 +1 @@
-3.0.0.rc2
+3.0.0.rc3

data/lib/schemacop/v2.rb

@@ -10,7 +10,6 @@ require 'schemacop/v2/node'
 require 'schemacop/v2/node_with_block'
 require 'schemacop/v2/node_supporting_type'
 require 'schemacop/v2/field_node'
-require 'schemacop/v2/root_node'
 require 'schemacop/v2/node_supporting_field'
 require 'schemacop/v2/caster'
 require 'schemacop/v2/dupper'

data/lib/schemacop/v2/root_node.rb

@@ -1,6 +0,0 @@
-module Schemacop
-  module V2
-    class RootNode < NodeSupportingType
-    end
-  end
-end

data/lib/schemacop/v3/hash_node.rb

@@ -11,6 +11,8 @@ module Schemacop
 
       supports_children(name: true)
 
+      attr_reader :properties
+
       def self.allowed_options
         super + ATTRIBUTES - %i[dependencies] + %i[additional_properties]
       end
@@ -19,6 +21,14 @@ module Schemacop
         super + NodeRegistry.dsl_methods(true) + %i[dsl_dep dsl_add]
       end
 
+      def self.sanitize_exp(exp)
+        exp = exp.to_s
+        if exp.start_with?('(?-mix:')
+          exp = exp.to_s.gsub(/^\(\?-mix:/, '').gsub(/\)$/, '')
+        end
+        return exp
+      end
+
       def add_child(node)
         unless node.name
           fail Exceptions::InvalidSchemaError, 'Child nodes must have a name.'
@@ -54,7 +64,7 @@ module Schemacop
 
         json = {}
         json[:properties] = Hash[properties.values.map { |p| [p.name, p.as_json] }] if properties.any?
-        json[:patternProperties] = Hash[pattern_properties.values.map { |p| [sanitize_exp(p.name), p.as_json] }] if pattern_properties.any?
+        json[:patternProperties] = Hash[pattern_properties.values.map { |p| [self.class.sanitize_exp(p.name), p.as_json] }] if pattern_properties.any?
 
         # In schemacop, by default, additional properties are not allowed,
         # the users explicitly need to enable additional properties
@@ -75,14 +85,6 @@ module Schemacop
         return process_json(ATTRIBUTES, json)
       end
 
-      def sanitize_exp(exp)
-        exp = exp.to_s
-        if exp.start_with?('(?-mix:')
-          exp = exp.to_s.gsub(/^\(\?-mix:/, '').gsub(/\)$/, '')
-        end
-        return exp
-      end
-
       def allowed_types
         { Hash => :object }
       end
@@ -191,10 +193,10 @@ module Schemacop
             next
           end
 
-          result[prop.name] = prop.cast(data_hash[prop.name])
+          result[prop.as || prop.name] = prop.cast(data_hash[prop.name])
 
-          if result[prop.name].nil? && !data_hash.include?(prop.name)
-            result.delete(prop.name)
+          if result[prop.as || prop.name].nil? && !data_hash.include?(prop.name)
+            result.delete(prop.as || prop.name)
           end
         end
 

data/lib/schemacop/v3/node.rb

@@ -2,6 +2,7 @@ module Schemacop
   module V3
     class Node
       attr_reader :name
+      attr_reader :as
       attr_reader :default
       attr_reader :title
       attr_reader :description
@@ -32,8 +33,10 @@ module Schemacop
         if options.delete(:cast_str)
           format = NodeRegistry.name(klass)
           one_of_options = {
-            required: options.delete(:required),
-            name:     options.delete(:name)
+            required:    options.delete(:required),
+            name:        options.delete(:name),
+            as:          options.delete(:as),
+            description: options.delete(:description)
           }
           node = create(:one_of, **one_of_options) do
             self.node node
@@ -45,7 +48,7 @@ module Schemacop
       end
 
       def self.allowed_options
-        %i[name required default description examples enum parent options cast_str title]
+        %i[name required default description examples enum parent options cast_str title as]
       end
 
       def self.dsl_methods
@@ -75,6 +78,7 @@ module Schemacop
         # Assign attributes #
         @name = options.delete(:name)
         @name = @name.to_s unless @name.nil? || @name.is_a?(Regexp)
+        @as = options.delete(:as)
         @required = !!options.delete(:required)
         @default = options.delete(:default)
         @title = options.delete(:title)

data/schemacop.gemspec

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
-# stub: schemacop 3.0.0.rc2 ruby lib
+# stub: schemacop 3.0.0.rc3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "schemacop".freeze
-  s.version = "3.0.0.rc2"
+  s.version = "3.0.0.rc3"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: schemacop
 version: !ruby/object:Gem::Version
-  version: 3.0.0.rc2
+  version: 3.0.0.rc3
 platform: ruby
 authors:
 - Sitrox
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
 date: 2021-01-28 00:00:00.000000000 Z
@@ -150,8 +150,8 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.21.2
-description: 
-email: 
+description:
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -264,7 +264,7 @@ homepage: https://github.com/sitrox/schemacop
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -279,8 +279,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Schemacop validates ruby structures consisting of nested hashes and arrays
   against simple schema definitions.