schemacop 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7ff5d0ab4c17e94b315ae9d4b765f80876dbcdcd
+  data.tar.gz: 21f7ac81ccd77383b15e1b07a6e131d6d8d99bb8
+SHA512:
+  metadata.gz: 92f19ccddbc4201eb295e2e8216bb8f6096a92a6a54658f79c0cabc244c7e8c6e9a77ded4941c5147ab3f1d1a644645466d335fadd98bef5c0252a23f64dd897
+  data.tar.gz: 863cc1423683b8eaeed9ae889c0a3a424030bf35b2efbb0a34a41edc14edd29d790e6d59ed6199af6df00d7e86e3d2babfcba3b592d9ae70a13a27c0e8dd4836

data/.gitignore

@@ -0,0 +1,15 @@
+/bin/ruby
+/.bundle
+.DS_Store
+*.tmproj
+tmtags
+/Gemfile.lock
+*~
+\#*
+.\#*
+*.swp
+/vendor/gems/*
+/vendor/bundle/*
+/spec/reports
+/.yardoc
+.idea

data/.rubocop.yml

@@ -0,0 +1,42 @@
+AllCops:
+  Exclude:
+    - 'local/**/*'
+    - 'vendor/**/*'
+    - 'tmp/**/*'
+    - '*.gemspec'
+
+  DisplayCopNames: true
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: False
+
+Metrics/CyclomaticComplexity:
+  Enabled: False
+
+Metrics/PerceivedComplexity:
+  Enabled: False
+
+Metrics/LineLength:
+  Max: 160
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/RedundantReturn:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+  EnforcedStyle: compact
+  SupportedStyles:
+    - nested
+    - compact

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+ - 2.0
+ - 2.2
+ - 2.3.0
+script: bundle exec rake test

data/.yardopts

@@ -0,0 +1 @@
+--markup=markdown --readme=README.md --no-private lib/**/*.rb

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify gem dependencies in the .gemspec file
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sitrox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,346 @@
+[![Build Status](https://travis-ci.org/sitrox/schemacop.svg?branch=master)](https://travis-ci.org/sitrox/schemacop)
+
+
+# Schemacop
+
+Schemacop validates ruby structures consisting of nested hashes and arrays
+against simple schema definitions.
+
+Example:
+
+```ruby
+schema = {
+  type: :hash,
+  hash: {
+    first_name: :string,
+    last_name: :string
+  }
+}
+
+data = {
+  first_name: 'John',
+  last_name: 'Doe'
+}
+
+Schemacop.validate!(schema, data)
+```
+
+## Installation
+
+To install the **Schemacop** gem:
+
+```sh
+$ gem install schemacop
+```
+
+To install it using `bundler` (recommended for any application), add it
+to your `Gemfile`:
+
+```ruby
+gem 'schemacop'
+```
+
+## Basic usage
+
+Schemacop's interface is very simple:
+
+```ruby
+Schemacop.validate!(schema, data)
+```
+
+It will throw an exception if either the schema is wrong or the given data does
+not comply with the schema. See section *Exceptions* for more information.
+
+## Defining schemas
+
+Schemacop can validate recursive structures of arrays nested into hashes and
+vice-versa. 'Leaf-nodes' can be of any data type, but their internal structure
+is not validated.
+
+Schema definitions are always a hash, even if they specify an array. Each level
+of a definition hash has to define a type.
+
+You can specify any type, but only the types `:hash` and `:array` allow you to
+specify a sub structure.
+
+### Defining hashes
+
+Once a level is defined as a hash (`type: :hash`), you can provide the key
+`hash` which in turn specifies the keys contained in that hash:
+
+```ruby
+{
+  type: :hash,
+  hash: {
+    first_name: { type: :string },
+    last_name: { type: :string }
+  }
+}
+```
+
+If you don't provide the `:hash` key, the hash won't be validated (other than
+the verification that it really is a hash):
+
+```ruby
+{ type: :hash }
+```
+
+Hash definitions can be nested deeply:
+
+```ruby
+{
+  type: :hash,
+  hash: {
+    name: {
+      type: :hash,
+      hash: {
+        first_name: { type: :string },
+        last_name: { type: :string }
+      }
+    }
+  }
+}
+```
+
+### Defining arrays
+
+When you define a level as an array (`type: :array`), you can provide further
+specification of the array's contents uby supplying the key `:array`:
+
+```ruby
+{
+  type: :array,
+  array: {
+    type: :string
+  }
+}
+```
+
+This example would define an array of strings.
+
+Arrays can nest hashes and vice-versa:
+
+```ruby
+{
+  type: :array,
+  array: {
+    type: :string
+  }
+}
+```
+
+If you don't provide the `:array` key, the array contents won't be validated:
+
+```ruby
+{ type: :array }
+```
+
+## Types
+
+For each level in your schema, you can specify the type in one of the following
+manors:
+
+- A ruby class:
+
+  ```ruby
+  { type: String }
+  ```
+
+- A type alias (see {Schemacop::Validator::TYPE_ALIASES} for a full list of
+  available type aliasses):
+
+  ```ruby
+  { type: :boolean }
+  ```
+
+- A list of ruby classes or type aliases:
+
+  ```ruby
+  { type: [String, :integer] }
+  ```
+
+  When specifying more than one type, it is validated that the given data
+  structure matches *one* of the given types.
+
+  If you specify both `:array` and `:hash` in such a type array, you can provide
+  a specification for both `array` and `hash` types:
+
+  ```ruby
+  {
+    type: [:array, :hash],
+    array: {
+      type: :string
+    },
+    hash: {
+      first_name: :string
+    }
+  }
+  ```
+
+  It will then determine which specification to use based on the actual data.
+
+## Null and required
+
+Using the optional parameters `required` and `null`, you can control whether a
+specific substructure must be provided (`required`) and if it can be `nil`
+(`null`).
+
+These two parameters can be combined in any way.
+
+### Required validation
+
+When validating with `required = false`, it means that the whole key can be
+omitted. As an example:
+
+```ruby
+# Successfully validates data hash: {}
+{
+  type: :hash,
+  hash: {
+    first_name: { type: :string, required: false }
+  }
+}
+```
+
+### Null validation
+
+When validating with `null = true`, the key must still be present, but it can
+also be `nil`.
+
+```ruby
+# Successfully validates data hash: { first_name: nil }
+{
+  type: :hash,
+  hash: {
+    first_name: { type: :string, null: false }
+  }
+}
+```
+
+## Allowed values
+
+For any level, you can optionally specify an array of values that are allowed.
+
+For example:
+
+```ruby
+{
+  type: :hash,
+  hash: {
+    category: { type: :integer, allowed_values: [1, 2, 3] }
+  }
+}
+```
+
+## Shortcuts
+
+### Type shortcut
+
+If you'd just like to define a type for a level but don't need to supply any
+additional information, you can just skip passing an extra hash and just pass
+the type instead.
+
+For example, the following
+
+```ruby
+{
+  type: :array,
+  array: {
+    type: :string
+  }
+}
+```
+
+can also be written as:
+
+```ruby
+{
+  type: :array,
+  array: :string
+}
+```
+
+### Quick hash and array
+
+When specifying a level as hash or array and you're further specifying the
+hashe's fields or the array's content types, you can omit the `type` key.
+
+For example, the following
+
+```ruby
+{
+  type: :array,
+  array: {
+    type: :string
+  }
+}
+```
+
+can also be written as:
+
+```ruby
+{
+  array: :string
+}
+```
+
+## Example schema
+
+```ruby
+{
+  hash: {
+    id: [Integer, String],
+    name: :string,
+    meta: {
+      hash: {
+        groups: { array: :integer },
+        birthday: Date,
+        comment: {
+          type: :string,
+          required: false,
+          null: true
+        },
+        ar_object: User
+      }
+    }
+  },
+}
+```
+
+## Exceptions
+
+Schemacop will throw one of the following checked exceptions:
+
+* {Schemacop::Exceptions::InvalidSchema}
+
+  This exception is thrown when the given schema definition format is invalid.
+
+* {Schemacop::Exceptions::Validation}
+
+  This exception is thrown when the given data does not comply with the given
+  schema definition.
+
+## Known limitations
+
+* Schemacop does not yet allow cyclic structures with infinite depth.
+
+* Schemacop aborts when it encounters an error. It is not able to collect a full
+  list of multiple errors.
+
+* Schemacop is not made for validating complex causalities (i.e. field `a`
+  needs to be given only if field `b` is present).
+
+* Schemacop does not yet support string regex matching.
+
+## Contributors
+
+Thanks to [Rubocop](https://github.com/bbatsov/rubocop) for great inspiration
+concerning their name and the structure of their README file.
+
+## Changelog
+
+Schemacop's changelog is available [here](CHANGELOG.md).
+
+## Copyright
+
+Copyright (c) 2016 Sitrox. See [LICENSE](LICENSE) for further details.