RubyGems - schemacop - Versions diffs - 1.0.2 → 2.0.0 - Mend

schemacop 1.0.2 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (90) hide show

checksums.yaml +4 -4
data/.gitignore +2 -1
data/.rubocop.yml +59 -1
data/CHANGELOG.md +10 -0
data/README.md +389 -199
data/Rakefile +2 -0
data/VERSION +1 -1
data/doc/Schemacop.html +41 -130
data/doc/Schemacop/ArrayValidator.html +329 -0
data/doc/Schemacop/BooleanValidator.html +145 -0
data/doc/Schemacop/Collector.html +535 -0
data/doc/Schemacop/Exceptions.html +39 -39
data/doc/Schemacop/Exceptions/InvalidSchemaError.html +124 -0
data/doc/Schemacop/Exceptions/ValidationError.html +124 -0
data/doc/Schemacop/FieldNode.html +409 -0
data/doc/Schemacop/FloatValidator.html +158 -0
data/doc/Schemacop/HashValidator.html +263 -0
data/doc/Schemacop/IntegerValidator.html +158 -0
data/doc/Schemacop/NilValidator.html +145 -0
data/doc/Schemacop/Node.html +1426 -0
data/doc/Schemacop/NodeResolver.html +242 -0
data/doc/Schemacop/NodeSupportingField.html +590 -0
data/doc/Schemacop/NodeSupportingType.html +614 -0
data/doc/Schemacop/NodeWithBlock.html +289 -0
data/doc/Schemacop/NumberValidator.html +232 -0
data/doc/Schemacop/ObjectValidator.html +288 -0
data/doc/Schemacop/RootNode.html +171 -0
data/doc/Schemacop/Schema.html +697 -0
data/doc/Schemacop/StringValidator.html +295 -0
data/doc/ScopedEnv.html +351 -0
data/doc/_index.html +190 -47
data/doc/class_list.html +24 -31
data/doc/css/full_list.css +32 -31
data/doc/css/style.css +244 -91
data/doc/file.README.html +428 -232
data/doc/file_list.html +26 -30
data/doc/frames.html +7 -16
data/doc/index.html +428 -232
data/doc/inheritance.graphml +524 -0
data/doc/inheritance.pdf +825 -0
data/doc/js/app.js +106 -77
data/doc/js/full_list.js +170 -135
data/doc/method_list.html +494 -38
data/doc/top-level-namespace.html +36 -36
data/lib/schemacop.rb +22 -7
data/lib/schemacop/collector.rb +34 -0
data/lib/schemacop/exceptions.rb +2 -8
data/lib/schemacop/field_node.rb +26 -0
data/lib/schemacop/node.rb +127 -0
data/lib/schemacop/node_resolver.rb +14 -0
data/lib/schemacop/node_supporting_field.rb +62 -0
data/lib/schemacop/node_supporting_type.rb +112 -0
data/lib/schemacop/node_with_block.rb +16 -0
data/lib/schemacop/root_node.rb +4 -0
data/lib/schemacop/schema.rb +61 -0
data/lib/schemacop/scoped_env.rb +18 -0
data/lib/schemacop/validator/array_validator.rb +30 -0
data/lib/schemacop/validator/boolean_validator.rb +5 -0
data/lib/schemacop/validator/float_validator.rb +5 -0
data/lib/schemacop/validator/hash_validator.rb +18 -0
data/lib/schemacop/validator/integer_validator.rb +5 -0
data/lib/schemacop/validator/nil_validator.rb +5 -0
data/lib/schemacop/validator/number_validator.rb +19 -0
data/lib/schemacop/validator/object_validator.rb +21 -0
data/lib/schemacop/validator/string_validator.rb +37 -0
data/schemacop.gemspec +7 -5
data/test/custom_check_test.rb +86 -0
data/test/custom_if_test.rb +95 -0
data/test/nil_dis_allow_test.rb +41 -0
data/test/short_forms_test.rb +316 -0
data/test/test_helper.rb +6 -0
data/test/types_test.rb +83 -0
data/test/validator_array_test.rb +97 -0
data/test/validator_boolean_test.rb +15 -0
data/test/validator_float_test.rb +57 -0
data/test/validator_hash_test.rb +71 -0
data/test/validator_integer_test.rb +46 -0
data/test/validator_nil_test.rb +13 -0
data/test/validator_number_test.rb +60 -0
data/test/validator_object_test.rb +87 -0
data/test/validator_string_test.rb +76 -0
metadata +78 -14
data/doc/Schemacop/Exceptions/Base.html +0 -127
data/doc/Schemacop/Exceptions/InvalidSchema.html +0 -141
data/doc/Schemacop/Exceptions/Validation.html +0 -142
data/doc/Schemacop/MethodValidation.html +0 -120
data/doc/Schemacop/MethodValidation/ClassMethods.html +0 -196
data/doc/Schemacop/Validator.html +0 -254
data/lib/schemacop/validator.rb +0 -145
data/test/schemacop_validator_test.rb +0 -257

data/doc/Schemacop/Validator.html DELETED Viewed

@@ -1,254 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<title>
-  Class: Schemacop::Validator
-    &mdash; Documentation by YARD 0.8.7.6
-</title>
-  <link rel="stylesheet" href="../css/style.css" type="text/css" charset="utf-8" />
-  <link rel="stylesheet" href="../css/common.css" type="text/css" charset="utf-8" />
-<script type="text/javascript" charset="utf-8">
-  hasFrames = window.top.frames.main ? true : false;
-  relpath = '../';
-  framesUrl = "../frames.html#!Schemacop/Validator.html";
-</script>
-  <script type="text/javascript" charset="utf-8" src="../js/jquery.js"></script>
-  <script type="text/javascript" charset="utf-8" src="../js/app.js"></script>
-  </head>
-  <body>
-    <div id="header">
-      <div id="menu">
-    <a href="../_index.html">Index (V)</a> &raquo;
-    <span class='title'><span class='object_link'><a href="../Schemacop.html" title="Schemacop (module)">Schemacop</a></span></span>
-     &raquo;
-    <span class="title">Validator</span>
-  <div class="noframes"><span class="title">(</span><a href="." target="_top">no frames</a><span class="title">)</span></div>
-</div>
-      <div id="search">
-    <a class="full_list_link" id="class_list_link"
-        href="../class_list.html">
-      Class List
-    </a>
-    <a class="full_list_link" id="method_list_link"
-        href="../method_list.html">
-      Method List
-    </a>
-    <a class="full_list_link" id="file_list_link"
-        href="../file_list.html">
-      File List
-    </a>
-</div>
-      <div class="clear"></div>
-    </div>
-    <iframe id="search_frame"></iframe>
-    <div id="content"><h1>Class: Schemacop::Validator
-</h1>
-<dl class="box">
-    <dt class="r1">Inherits:</dt>
-    <dd class="r1">
-      <span class="inheritName">Object</span>
-        <ul class="fullTree">
-          <li>Object</li>
-            <li class="next">Schemacop::Validator</li>
-        </ul>
-        <a href="#" class="inheritanceTree">show all</a>
-      </dd>
-    <dt class="r2 last">Defined in:</dt>
-    <dd class="r2 last">lib/schemacop/validator.rb</dd>
-</dl>
-<div class="clear"></div>
-  <h2>Constant Summary</h2>
-    <dl class="constants">
-        <dt id="TYPE_ALIASES-constant" class="">TYPE_ALIASES =
-        </dt>
-        <dd><pre class="code"><span class='lbrace'>{</span>
-  <span class='label'>hash:</span>    <span class='lbracket'>[</span><span class='const'>Hash</span><span class='rbracket'>]</span><span class='comma'>,</span>
-  <span class='label'>array:</span>   <span class='lbracket'>[</span><span class='const'>Array</span><span class='rbracket'>]</span><span class='comma'>,</span>
-  <span class='label'>string:</span>  <span class='lbracket'>[</span><span class='const'>String</span><span class='rbracket'>]</span><span class='comma'>,</span>
-  <span class='label'>integer:</span> <span class='lbracket'>[</span><span class='const'>Integer</span><span class='rbracket'>]</span><span class='comma'>,</span>
-  <span class='label'>boolean:</span> <span class='lbracket'>[</span><span class='const'>TrueClass</span><span class='comma'>,</span> <span class='const'>FalseClass</span><span class='rbracket'>]</span>
-<span class='rbrace'>}</span></pre></dd>
-    </dl>
-    <h2>
-      Class Method Summary
-      <small>(<a href="#" class="summary_toggle">collapse</a>)</small>
-    </h2>
-    <ul class="summary">
-        <li class="public ">
-  <span class="summary_signature">
-      <a href="#validate%21-class_method" title="validate! (class method)">+ (void) <strong>validate!</strong>(schema, data) </a>
-  </span>
-    <span class="summary_desc"><div class='inline'><p>Validates <code>data</code> against <code>schema</code> and throws an exception on missmatch.</p>
-</div></span>
-</li>
-    </ul>
-  <div id="class_method_details" class="method_details_list">
-    <h2>Class Method Details</h2>
-      <div class="method_details first">
-  <h3 class="signature first" id="validate!-class_method">
-    + (<tt>void</tt>) <strong>validate!</strong>(schema, data)
-</h3><div class="docstring">
-  <div class="discussion">
-    <p class="note returns_void">This method returns an undefined value.</p><p>Validates <code>data</code> against <code>schema</code> and throws an exception on missmatch.</p>
-  </div>
-</div>
-<div class="tags">
-  <p class="tag_title">Parameters:</p>
-<ul class="param">
-    <li>
-        <span class='name'>schema</span>
-        <span class='type'>(<tt>Hash</tt>)</span>
-        &mdash;
-        <div class='inline'><p>The schema to validate against</p>
-</div>
-    </li>
-    <li>
-        <span class='name'>data</span>
-        <span class='type'>(<tt>Object</tt>)</span>
-        &mdash;
-        <div class='inline'><p>The data to validate</p>
-</div>
-    </li>
-</ul>
-</div><table class="source_code">
-  <tr>
-    <td>
-      <pre class="lines">
-16
-17
-18
-19</pre>
-    </td>
-    <td>
-      <pre class="code"><span class="info file"># File 'lib/schemacop/validator.rb', line 16</span>
-<span class='kw'>def</span> <span class='kw'>self</span><span class='period'>.</span><span class='id identifier rubyid_validate!'>validate!</span><span class='lparen'>(</span><span class='id identifier rubyid_schema'>schema</span><span class='comma'>,</span> <span class='id identifier rubyid_data'>data</span><span class='rparen'>)</span>
-  <span class='id identifier rubyid_new'>new</span><span class='lparen'>(</span><span class='id identifier rubyid_schema'>schema</span><span class='comma'>,</span> <span class='id identifier rubyid_data'>data</span><span class='rparen'>)</span>
-  <span class='kw'>return</span> <span class='kw'>nil</span>
-<span class='kw'>end</span></pre>
-    </td>
-  </tr>
-</table>
-</div>
-  </div>
-</div>
-    <div id="footer">
-  Generated on Thu Oct  6 19:45:02 2016 by
-  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.8.7.6 (ruby-2.3.1).
-</div>
-  </body>
-</html>

data/lib/schemacop/validator.rb DELETED Viewed

@@ -1,145 +0,0 @@
-module Schemacop
-  class Validator
-    TYPE_ALIASES = {
-      hash:    [Hash],
-      array:   [Array],
-      string:  [String],
-      integer: [Integer],
-      boolean: [TrueClass, FalseClass]
-    }
-    # Validates `data` against `schema` and throws an exception on missmatch.
-    #
-    # @param [Hash] schema The schema to validate against
-    # @param [Object] data The data to validate
-    # @return [void]
-    def self.validate!(schema, data)
-      new(schema, data)
-      return nil
-    end
-    private
-    def initialize(schema, data)
-      validate_branch '', schema, data
-    end
-    def prepare_schema(schema)
-      schema = { types: schema } unless schema.is_a?(Hash)
-      schema = schema.dup
-      if schema.include?(:type)
-        schema[:types] = schema.delete(:type)
-      else
-        schema[:types] = :array unless schema[:array].nil?
-        schema[:types] = :hash  unless schema[:hash].nil?
-      end
-      schema[:types] = [*schema[:types]]
-      schema[:types].map! do |type|
-        alias_type = TYPE_ALIASES.select { |_, v| v.include?(type) }.keys.first
-        type = alias_type unless alias_type.nil?
-        type
-      end
-      schema[:types].each do |type|
-        if type == :hash
-          if schema.include?(:fields)
-            schema[:hash] = schema.delete(:fields)
-          end
-          schema[:hash] = schema[:hash] || {}
-          if schema[:hash].is_a?(Hash)
-            schema[:hash].each do |key, value|
-              schema[:hash][key] = prepare_schema(value)
-            end
-          end
-        end
-        schema[:array] = prepare_schema(schema[:array]) if type == :array
-      end
-      schema
-    end
-    def assign_data_type(type)
-      if type.is_a?(Symbol)
-        fail Exceptions::InvalidSchema, "Type alias #{type} is not supported." if TYPE_ALIASES[type].nil?
-        TYPE_ALIASES[type]
-      elsif type.is_a?(String)
-        type.to_s.classify.safe_constantize
-      else
-        type
-      end
-    end
-    def validate_branch(path, schema, data)
-      schema = prepare_schema(schema)
-      # ---------------------------------------------------------------
-      # Type validation
-      # ---------------------------------------------------------------
-      supported_types = schema[:types].map { |type| assign_data_type type }.flatten
-      # ---------------------------------------------------------------
-      # Check root path rules
-      # ---------------------------------------------------------------
-      if path.empty?
-        supported_types << NilClass if schema[:null] == true
-        if schema.include? :require
-          fail Exceptions::InvalidSchema, "The :require property can't be used on top level of schema."
-        end
-      end
-      if schema[:types].present? && !supported_types.any? { |t| data.is_a?(t) }
-        fail Exceptions::Validation, "Property at path #{path} must be of type #{supported_types.inspect}."
-      end
-      # ---------------------------------------------------------------
-      # Check for allowed values
-      # ---------------------------------------------------------------
-      if schema[:allowed_values] && !schema[:allowed_values].include?(data)
-        fail Exceptions::Validation, "Value #{data.inspect} of property at path #{path} is not valid. Valid are: #{schema[:allowed_values].inspect}."
-      end
-      # ---------------------------------------------------------------
-      # Validate children
-      # ---------------------------------------------------------------
-      if data.is_a?(Hash)
-        data = HashWithIndifferentAccess.new data
-        unless schema.include? :hash
-          fail Exceptions::InvalidSchema, "Missing schema entry :hash at path #{path}."
-        end
-        schema_keys = schema[:hash].keys.collect(&:to_s)
-        unless schema_keys.empty?
-          data_keys = data.keys.collect(&:to_s)
-          unless (obsolete_keys = data_keys - schema_keys).empty?
-            fail Exceptions::Validation, "Obsolete keys at path #{path}: #{obsolete_keys.inspect}."
-          end
-        end
-        schema[:hash].each do |sub_key, sub_schema|
-          if sub_schema[:required] != false && !data.include?(sub_key)
-            fail Exceptions::Validation, "Missing property at path #{path}.#{sub_key}."
-          end
-          if data[sub_key].nil?
-            unless sub_schema[:null] == true
-              fail Exceptions::Validation, "Property at path #{path}.#{sub_key} can't be null."
-            end
-          else
-            validate_branch("#{path}.#{sub_key}", sub_schema, data[sub_key])
-          end
-        end
-      elsif schema[:types].include?(:array)
-        data.each_with_index do |value, index|
-          validate_branch("#{path}[#{index}]", schema[:array], value)
-        end
-      end
-    end
-  end
-end

data/test/schemacop_validator_test.rb DELETED Viewed

@@ -1,257 +0,0 @@
-require 'minitest/autorun'
-require 'schemacop'
-# rubocop: disable Metrics/ClassLength
-class SchemacopValidatorTest < Minitest::Test
-  def test_top_level_schema
-    assert_schema({ type: :integer }, 1)
-    assert_schema({ type: :hash, null: true }, nil)
-  end
-  def test_short_type_schema
-    assert_schema({ type: :array, array: :string }, %w(Hello world))
-    assert_schema({ type: [Array], array: :string }, %w(Hello world))
-    assert_schema({ array: :string }, %w(Hello world))
-    assert_schema({ hash: { first_name: :string, last_name: :string } }, first_name: 'John', last_name: 'Doe')
-    assert_schema_failure({ type: :array, array: :integer }, %w(Hello world))
-    assert_schema_failure({ type: Array, array: :string }, [1, 2, 3])
-    assert_schema_failure({ type: [Array], array: :integer }, %w(Hello world))
-  end
-  def test_many_types_schema
-    assert_schema({ type: [String, :integer] }, 'Hello world')
-    assert_schema({ type: [:string, 'integer'] }, 123)
-    assert_schema({ type: String }, 'Hello world')
-    assert_schema({ type: :string }, 'Hello world')
-    assert_schema({ type: :array, array: :string }, %w(John Doe))
-    assert_schema({ type: :hash, hash: { name: :string } }, name: 'John Doe')
-    assert_schema({ type: [:array, :hash], array: { type: :string }, hash: { name: :string } }, name: 'John Doe')
-    assert_schema({ type: [:array, :hash], array: { type: :string }, hash: { name: :string } }, %w(John Doe))
-  end
-  def test_unify_schema
-    schema_rules = {
-      hash: {
-        id: [Integer, String],
-        name: :string,
-        meta: {
-          hash: {
-            groups: { array: :integer },
-            birthday: Date,
-            comment: {
-              type: :string,
-              required: false,
-              null: true
-            }
-          }
-        }
-      }
-    }
-    assert_schema(schema_rules, id: 123, name: 'John Doe', meta: { groups: [1, 2, 3], birthday: Date.today, comment: 'Hello world' })
-    assert_schema(schema_rules, id: 'XYZ', name: 'John Doe', meta: { groups: [1, 2, 3], birthday: Date.today })
-  end
-  def test_hash_without_specification
-    schema_rules = {
-      type: :hash
-    }
-    assert_schema(schema_rules, user: 'hello')
-    assert_schema(schema_rules, user: :world)
-    assert_schema(schema_rules, user: 123)
-  end
-  def test_array_without_specification
-    schema_rules = {
-      type: :array
-    }
-    assert_schema(schema_rules, [1, 'hello', :world])
-    assert_schema(schema_rules, [])
-  end
-  def test_hash_attributes_without_specification
-    schema_rules = {
-      type: :hash,
-      hash: {
-        user: { type: :hash, null: true }
-      }
-    }
-    assert_schema(schema_rules, user: { foo: :bar })
-    assert_schema(schema_rules, user: nil)
-  end
-  def test_array_in_hash_without_specification
-    schema_rules = {
-      type: Hash,
-      hash: {
-        types: { type: :array, null: true }
-      }
-    }
-    assert_schema(schema_rules, types: ['test', 1, :hello])
-    assert_schema(schema_rules, types: [])
-    assert_schema(schema_rules, types: nil)
-  end
-  def test_array_in_hash_with_multiple_types
-    schema_rules = {
-      type: :hash,
-      hash: {
-        types: { type: Array, array: [Integer, String] }
-      }
-    }
-    assert_schema(schema_rules, types: ['test', 1])
-    assert_schema(schema_rules, types: [])
-    assert_schema_failure(schema_rules, types: ['test', 1, :hello_world])
-  end
-  def test_nested_hash_schema
-    schema_rules = {
-      type: :hash,
-      hash: {
-        name: {
-          type: :hash,
-          hash: {
-            first_name: { type: :string },
-            last_name: { type: :string }
-          }
-        }
-      }
-    }
-    assert_schema(schema_rules, name: { first_name: 'John', last_name: 'Doe' })
-  end
-  def test_flat_hash_old_schema
-    schema_rules = {
-      type: :hash,
-      fields: {
-        name: {
-          type: :string, null: true
-        }
-      }
-    }
-    assert_schema(schema_rules, name: 'John Doe')
-    assert_schema(schema_rules, name: '')
-    assert_schema(schema_rules, name: nil)
-    assert_schema_failure(schema_rules, name: 123)
-    assert_schema_failure(schema_rules, name: true)
-    assert_schema_failure(schema_rules, name: [])
-  end
-  def test_array_hash_old_schema
-    schema_rules = {
-      type: :array,
-      array: {
-        type: :hash,
-        fields: {
-          required: { type: :boolean },
-          name: { type: :string }
-        }
-      }
-    }
-    assert_schema(schema_rules, [{ name: 'John', required: true }, { name: 'Alex', required: false }])
-    assert_schema_failure(schema_rules, name: 'John Doe')
-    assert_schema_failure(schema_rules, [{ name: 'John Doe' }])
-    assert_schema_failure(schema_rules, [{ required: true }])
-    assert_schema_failure(schema_rules, [{ name: 0, required: true }])
-    assert_schema_failure(schema_rules, [{ name: 'John Doe', required: 'string' }])
-  end
-  def test_fields_array_old_schema
-    schema_rules = {
-      type: :hash,
-      fields: {
-        ids: {
-          type: :array,
-          array: {
-            type: :integer
-          }
-        }
-      }
-    }
-    assert_schema(schema_rules, ids: [])
-    assert_schema(schema_rules, ids: [1, 2, 3])
-    assert_schema_failure(schema_rules, ids: [1, '2'])
-    assert_schema_failure(schema_rules, ids: '3')
-    assert_schema_failure(schema_rules, ids: nil)
-  end
-  def test_validate_fields_old_schema
-    schema_rules = {
-      type: :hash,
-      fields: {
-        name: { type: :string, null: true, required: true },
-        age: { type: :integer, required: false, null: true },
-        id: { type: :integer, null: false },
-        ids: { type: :array, array: { type: :integer }, null: true },
-        currency: { type: :string, allowed_values: %w(CHF USD EUR) }
-      }
-    }
-    assert_schema(schema_rules, name: 'John', id: 2, ids: [1, 2, 3], currency: 'CHF')
-    assert_schema(schema_rules, name: nil, id: 2, ids: [1, 2, 3], currency: 'CHF')
-    assert_schema(schema_rules, name: nil, age: 2, id: 2, ids: nil, currency: 'CHF')
-    assert_schema(schema_rules, name: nil, id: 2, ids: nil, currency: 'CHF')
-    assert_schema_failure(schema_rules, id: 2, ids: [1, 2, 3], currency: 'CHF')
-    assert_schema_failure(schema_rules, name: nil, id: nil, ids: [1, 2, 3], currency: 'CHF')
-    assert_schema_failure(schema_rules, name: nil, id: 2, ids: [1, 2, 3], currency: 'JPN')
-  end
-  def test_nested_old_schema
-    schema_rules = {
-      type: :array,
-      array: {
-        type: :hash,
-        fields: {
-          id: { type: :integer },
-          hosts: {
-            type: :array,
-            array: {
-              type: :hash,
-              fields: {
-                hostname: { type: :string }
-              }
-            }
-          }
-        }
-      }
-    }
-    assert_schema schema_rules, [
-      { id: 1, hosts: [{ hostname: 'localhost' }, { hostname: '127.0.0.1' }] },
-      { id: 2, hosts: [{ hostname: '192.168.0.1' }, { hostname: 'somedomain.com' }] }
-    ]
-  end
-  private
-  def assert_schema_failure(schema, data)
-    assert_raises Schemacop::Exceptions::Validation do
-      Schemacop.validate!(schema, data)
-    end
-  end
-  def assert_schema(schema, data)
-    begin
-      Schemacop.validate!(schema, data)
-      success = true
-    rescue
-      success = false
-    end
-    assert success
-  end
-end