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

schemacop 1.0.2 → 2.0.0

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