golden_fleece 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 69b0eddc5da9185615c28fa06cb491850643d5ce
+  data.tar.gz: a6f855832e94fe8d72d71f9f837dea0004fc370b
+SHA512:
+  metadata.gz: 02edc695368a00db6beadb66b7ca9ee9ac06384581bf09119cdef5e1e904d384b418ccb58d649b28c587e2d02c4c4b08cb57ee0ef1c6a5fbc6b93d302f72135a
+  data.tar.gz: 8c67be8b70be4d7b37502fa8b52984708e4c95f8972b2c7801d342d15155d03d200766eed9f83091b53cf430ad790fcf1fe81e8e5a00524dcc2b095c2b5b89f6

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.3
+before_install: gem install bundler -v 1.14.3

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at ersin.akinci@instacart.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Ersin Akinci
+
+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,242 @@
+# Golden Fleece 🐑
+
+Easy schemas for JSON columns in your Ruby data models. Currently supports ActiveRecord/ActiveModel >= 3.0 (i.e., Rails 3, 4 and 5).
+
+Golden Fleece lets you define a schema for your Ruby data models, which can be used to do fun things:
+
+- Validate JSON data types and formats
+- Normalize JSON data
+- Provide default values within nested JSON
+
+It's like [JSON Schema](http://json-schema.org/) but more opinionated and, in our opinion, more straightforward to use.
+
+🍊 Battle-tested at Instacart.
+
+## Quick start
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'golden_fleece'
+```
+
+Then `include GoldenFleece::Model` and define schemas in your data models:
+
+```ruby
+class Person < ActiveRecord::Base
+  include GoldenFleece::Model
+
+  fleece do
+    define_schemas :profile, {
+      first_name: { type: :string },
+      last_name:  { types: [:string, :null] },
+      zip_code:   { type: :string, default: '90210' }
+    }
+  end
+end
+
+person.profile['first_name'] = 'Jane'
+person.profile['last_name'] = nil
+person.valid?        # true
+person.export_fleece # { profile: { first_name: 'Jane', last_name: nil, zip_code: '90210' } }
+
+person.profile.delete 'first_name'
+person.valid? # false
+```
+
+## Usage
+
+### Schemas
+
+Golden Fleece's core concept is the schema. A schema is a structure that defines what your JSON columns should look like and are defined within the `fleece` block on a model using `define_schemas`:
+
+```ruby
+class Person < ActiveRecord::Base
+  include GoldenFleece::Model
+
+  fleece do
+    define_schemas :profile, {
+      first_name: { type: :string },
+      last_name:  { types: [:string, :null] },
+      zip_code:   { type: :string, default: '90210' }
+    }
+  end
+end
+```
+
+The above example defines a schema on the `Person` model's `profile` column and introduces certain restraints on the `first_name`, `last_name` and `zip_code` fields within the `profile` column's JSON object. Note that Golden Fleece assumes that all columns with a schema are valid JSON objects.
+
+Note that any keys added to a JSON object that aren't listed in the schema are invalid:
+
+```ruby
+define_schemas :profile, {
+  first_name: ...,
+  last_name: ...,
+  zip_code: ...,
+}
+
+person.profile['address'] = '123 Nottingham Way'
+person.valid? # false
+```
+
+### Types
+
+Type checks are introduced with the `type` or `types` option (both are interchangeable):
+
+```ruby
+define_schemas :profile, {
+  zip_code: { type: :string }
+}
+
+person.profile['zip_code'] = 90210
+person.valid? # false
+```
+
+Note that passing `:null` to `type`/`types` allows the field to be nullable.
+
+### Defaults
+
+Defaults defined on schemas will fill in `nil` values in your JSON columns when validating and exporting. Defaults are safe and will _never_ backfill your model's columns:
+
+```ruby
+define_schemas :profile, {
+  zip_code: { type: :string, default: '90210' }
+}
+
+person.profile['zip_code'] = nil
+person.valid?              # true
+person.export_fleece       # { profile: { zip_code: '90210' } }
+person.profile['zip_code'] # nil
+```
+
+In addition to static values, you can use Proc's to dynamically generate defaults at runtime:
+
+```ruby
+define_schemas :profile, {
+  zip_code: { type: :string, default: -> record { record.closest_location.zip_code } }
+}
+
+person.export_fleece # { profile: { zip_code: '94131' } }
+```
+
+### Getters
+
+Top-level keys in your JSON columns can automatically be mapped as getters on your data model's instances using `define_getters`. Getters are safe and will _never_ override any preexisting instance methods:
+
+```ruby
+define_schemas :profile, {
+  zip_code: ...,
+  class: ...
+}
+define_getters :profile
+
+person.zip_code            # '90210'
+person.profile['zip_code'] # nil
+
+person.profile['class'] = 'Freshman'
+person.class # Person
+```
+
+Note that getters will return the exported value of your JSON key rather than the raw value.
+
+### Normalizers
+
+Normalizers are Procs that normalize your data before validating, exporting or saving:
+
+```ruby
+define_normalizers({
+  cast_string: -> record, value { value.to_s }
+})
+
+define_schemas :profile, {
+  zip_code: { type: :string, normalizer: :cast_string }
+}
+
+person.profile['zip_code'] = 90210
+person.profile['zip_code'] # 90210
+person.zip_code            # '90210'
+person.valid?              # true
+
+person.save
+person.profile['zip_code'] # '90210'
+person.zip_code            # '90210'
+```
+
+Note that multiple normalizers can be chained with `normalizers`:
+
+```ruby
+define_normalizers({
+  cast_string: ...,
+  sha1: -> record, value { sha1(value) }
+})
+
+define_schemas :profile, {
+  zip_code: { type: :string, normalizers: [:cast_string, :sha1] }
+}
+
+person.profile['zip_code'] = 90210
+person.zip_code            # '2b02dbc1030b278245b2b9cb11667eebf7275a52'
+```
+
+### Formats
+
+Formats are Procs that can be used to enforce complex validations:
+
+```ruby
+define_formats({
+  zip_code: -> record, value { raise ArgumentError.new("must be a valid ZIP code") unless value =~ /^[0-9]{5}(?:-[0-9]{4})?$/ }
+})
+
+define_schemas :profile, {
+  zip_code: { type: :string, format: :zip_code }
+}
+
+person.profile['zip_code'] = '90210'      # person.valid? == true
+person.profile['zip_code'] = '90210-1234' # person.valid? == true
+person.profile['zip_code'] = '90210-12'   # person.valid? == false
+person.errors.messages                    # "Invalid format at '/zip_code' on column 'profile': must be a valid ZIP code"
+```
+
+Note that unlike types and normalizers, you can only use one format at a time for each schema.
+
+### Nested JSON
+
+Schemas can be nested with `subschemas`:
+
+```ruby
+define_schemas :profile, {
+  address: { type: :object, subschemas: {
+      number: { type: :number },
+      street: { type: :string },
+      zip_code: { type: :string, default: '90210' }
+    }
+  }
+}
+
+person.profile['address'] # nil
+person.address            # { number: nil, street: nil, zip_code: '90210' }
+person.valid?             # false
+```
+
+### Exporting
+
+TODO
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Using Golden Fleece with other ORM's
+
+TODO
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/earksiinni/golden_fleece. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "golden_fleece"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/golden_fleece.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'golden_fleece/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "golden_fleece"
+  spec.version       = GoldenFleece::VERSION
+  spec.authors       = ["Ersin Akinci"]
+  spec.email         = ["ersin.akinci@gmail.com"]
+
+  spec.summary       = %q{Easy schemas for your JSON columns.}
+  spec.description   = %q{Golden Fleece lets you validate, normalize, set up defaults for and provide getters for JSON data in your Ruby data models through easy to use schemas. More opinionated and easier to use than JSON Schema.}
+  spec.homepage      = "https://github.com/earksiinni/golden_fleece"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "activemodel", "~> 3.0"
+  spec.add_development_dependency "activesupport", "~> 3.0"
+  spec.add_development_dependency "pry",  "~> 0.9"
+  spec.add_dependency "hana", "~> 1.3"
+end

data/lib/golden_fleece.rb

@@ -0,0 +1,14 @@
+require "golden_fleece/context"
+require "golden_fleece/definitions"
+require "golden_fleece/format"
+require "golden_fleece/model"
+require "golden_fleece/normalizer"
+require "golden_fleece/schema"
+require "golden_fleece/type"
+require "golden_fleece/utility"
+require "golden_fleece/value"
+require "golden_fleece/version"
+
+module GoldenFleece
+
+end

data/lib/golden_fleece/context.rb

@@ -0,0 +1,37 @@
+require "golden_fleece/context/export"
+require "golden_fleece/context/formats"
+require "golden_fleece/context/getters"
+require "golden_fleece/context/normalizers"
+require "golden_fleece/context/schemas"
+require 'golden_fleece/schema'
+
+module GoldenFleece
+  class Context
+    include ::GoldenFleece::Context::Export
+    include ::GoldenFleece::Context::Formats
+    include ::GoldenFleece::Context::Getters
+    include ::GoldenFleece::Context::Normalizers
+    include ::GoldenFleece::Context::Schemas
+
+    attr_accessor :rules
+    attr_reader :model_class, :normalizers, :formats, :attributes, :schemas, :setup_callbacks, :has_run_setup
+
+    def initialize(model_class)
+      @model_class = model_class
+      @normalizers = {}
+      @formats = {}
+      @attributes = []
+      @schemas = Schema.new(self, '/', {})
+      @setup_callbacks = []
+      @has_run_setup = false
+    end
+
+    def run_setup_callbacks
+      @setup_callbacks.each do |cb|
+        cb.call self
+      end
+
+      @has_run_setup = true
+    end
+  end
+end

data/lib/golden_fleece/context/export.rb

@@ -0,0 +1,19 @@
+module GoldenFleece
+  class Context
+    module Export
+      def export(record, export_attributes)
+        export_attributes = Array.wrap export_attributes
+
+        schemas.reduce({}) { |memo, (attribute, schema)|
+          if export_attributes.include? attribute
+            memo[attribute] = schema.reduce({}) { |memo, (schema_name, schema)|
+              memo[schema_name] = schema.value.compute(record)
+              memo
+            }
+          end
+          memo
+        }
+      end
+    end
+  end
+end

data/lib/golden_fleece/context/formats.rb

@@ -0,0 +1,15 @@
+require 'golden_fleece/format'
+
+module GoldenFleece
+  class Context
+    module Formats
+      def define_formats(lambdas = {})
+        lambdas.each do |name, fn|
+          name = name.to_sym
+
+          formats[name] = Format.new(name, fn)
+        end
+      end
+    end
+  end
+end

data/lib/golden_fleece/context/getters.rb

@@ -0,0 +1,23 @@
+module GoldenFleece
+  class Context
+    module Getters
+      def define_getters(*attributes)
+        # For each attribute...
+        attributes.each do |attribute|
+          # ...and each top-level schema of each attribute...
+          schemas[attribute.to_sym].each do |schema_name, schema|
+            # ...if there isn't already an instance method named after the schema...
+            if !model_class.new.respond_to?(schema_name)
+              # ...define a getter for that schema's value!
+              model_class.class_eval do
+                define_method schema_name do
+                  self.class.fleece_context.schemas[attribute.to_sym][schema_name].value.compute(self)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/golden_fleece/context/normalizers.rb

@@ -0,0 +1,15 @@
+require 'golden_fleece/normalizer'
+
+module GoldenFleece
+  class Context
+    module Normalizers
+      def define_normalizers(lambdas = {})
+        lambdas.each do |name, fn|
+          name = name.to_sym
+
+          normalizers[name] = Normalizer.new(name, fn)
+        end
+      end
+    end
+  end
+end

data/lib/golden_fleece/context/schemas.rb

@@ -0,0 +1,10 @@
+module GoldenFleece
+  class Context
+    module Schemas
+      def define_schemas(attribute, schema_definitions = {})
+        schemas[attribute.to_sym] ||= schema_definitions
+        attributes << attribute
+      end
+    end
+  end
+end

data/lib/golden_fleece/definitions.rb

@@ -0,0 +1,14 @@
+require 'golden_fleece/type'
+
+module GoldenFleece
+  module Definitions
+    TYPES = {
+      array: Type.new(:array, Array),
+      boolean: Type.new(:boolean, FalseClass, TrueClass),
+      null: Type.new(:null, NilClass),
+      number: Type.new(:number, Numeric),
+      object: Type.new(:object, Hash),
+      string: Type.new(:string, String)
+    }.freeze
+  end
+end

data/lib/golden_fleece/format.rb

@@ -0,0 +1,18 @@
+module GoldenFleece
+  class Format
+    attr_reader :name
+
+    def initialize(name, fn)
+      @name = name
+      @fn = fn
+    end
+
+    def validate(record, value)
+      fn.call record, value
+    end
+
+    private
+
+    attr_reader :fn
+  end
+end

data/lib/golden_fleece/model.rb

@@ -0,0 +1,25 @@
+require "golden_fleece/model/context"
+require "golden_fleece/model/export"
+require "golden_fleece/model/normalization"
+require "golden_fleece/model/active_model/normalization"
+require "golden_fleece/model/active_model/validation"
+
+module GoldenFleece
+  module Model
+    def self.included(base)
+      # Include ORM-specific modules depending on what ORM we're using
+      orm = if defined? ::ActiveModel
+        "ActiveModel"
+      end
+      orm_module = "GoldenFleece::Model::#{orm}".constantize
+
+      base.class_eval do
+        include GoldenFleece::Model::Context
+        include GoldenFleece::Model::Export
+        include GoldenFleece::Model::Normalization
+        include orm_module::Normalization
+        include orm_module::Validation
+      end
+    end
+  end
+end

data/lib/golden_fleece/model/active_model/normalization.rb

@@ -0,0 +1,17 @@
+require 'active_model'
+
+module GoldenFleece
+  module Model
+    module ActiveModel
+      module Normalization
+        def self.included(base)
+          base.class_eval do
+            before_save do
+              normalize_fleece
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/golden_fleece/model/active_model/validation.rb

@@ -0,0 +1,22 @@
+require 'active_model'
+require 'golden_fleece/validations/active_model/fleece_schema_conformance_validator'
+
+module GoldenFleece
+  module Model
+    module ActiveModel
+      module Validation
+        def self.included(base)
+          base.class_eval do
+            validate_attributes = -> fleece_context {
+              fleece_context.model_class.class_eval do
+                validates *fleece_context.attributes, 'GoldenFleece::Validations::ActiveModel::FleeceSchemaConformance' => true
+              end
+            }
+
+            fleece_context.setup_callbacks << validate_attributes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/golden_fleece/model/context.rb

@@ -0,0 +1,24 @@
+require 'golden_fleece/context'
+
+module GoldenFleece
+  module Model
+    module Context
+      def self.included(base)
+        base.extend ClassMethods
+
+        base.instance_eval do
+          @fleece_context = GoldenFleece::Context.new(self)
+        end
+      end
+
+      module ClassMethods
+        attr_reader :fleece_context
+
+        def fleece(&block)
+          fleece_context.instance_eval(&block)
+          fleece_context.run_setup_callbacks unless fleece_context.has_run_setup
+        end
+      end
+    end
+  end
+end

data/lib/golden_fleece/model/export.rb

@@ -0,0 +1,13 @@
+module GoldenFleece
+  module Model
+    module Export
+      def self.included(base)
+        base.class_eval do
+          def export_fleece(attribs = self.class.fleece_context.attributes)
+            self.class.fleece_context.export self, attribs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/golden_fleece/model/normalization.rb

@@ -0,0 +1,23 @@
+module GoldenFleece
+  module Model
+    module Normalization
+      include Utility
+
+      def normalize_fleece
+        self.class.fleece_context.schemas.each do |attribute, schema|
+          persisted_json = read_attribute attribute
+
+          schema.each do |schema_name, schema|
+            schema_name = schema_name.to_s
+            computed_json = { schema_name => schema.value.compute(self) }
+            deep_stringify_keys computed_json if computed_json.is_a? Hash
+
+            if !persisted_json[schema_name].nil? && persisted_json[schema_name] != computed_json[schema_name]
+              write_attribute attribute, computed_json
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/golden_fleece/normalizer.rb

@@ -0,0 +1,18 @@
+module GoldenFleece
+  class Normalizer
+    attr_reader :name
+
+    def initialize(name, fn)
+      @name = name
+      @fn = fn
+    end
+
+    def normalize(record, value)
+      fn.call record, value
+    end
+
+    private
+
+    attr_reader :fn
+  end
+end

data/lib/golden_fleece/schema.rb

@@ -0,0 +1,117 @@
+require 'golden_fleece/definitions'
+require 'golden_fleece/schema'
+require 'golden_fleece/utility'
+
+module GoldenFleece
+  class Schema
+    include Utility
+
+    attr_reader :attribute, :name, :path, :json_path, :types, :normalizers, :format, :value, :default
+
+    def initialize(context, path, definitions)
+      @context = context
+      @path = path
+      @name = path.split("/").last
+      @attribute = path.split("/")[1]
+      @json_path = path.split("/")[2..-1]
+      @json_path = @json_path.join("/") if @json_path
+      @subschemas = {}
+
+      # .count == 1 means we're at the root
+      # .count == 2 means we're at the attribute
+      # .count >= 3 means we're cookin'
+      if path.split("/").count <= 2
+        @types = [Definitions::TYPES[:object]]
+        map_subschemas(definitions)
+      else
+        map_value
+        map_types(definitions[:type], definitions[:types])
+        map_normalizers(definitions[:normalizer], definitions[:normalizers])
+        map_format(definitions[:format])
+        map_default(definitions[:default])
+        map_subschemas(definitions[:subschemas])
+      end
+    end
+
+    def [](subschema_name)
+      subschemas[subschema_name]
+    end
+
+    def []=(subschema_name, subschema_definition)
+      subschemas[subschema_name] = Schema.new(context, build_json_path(path, subschema_name), subschema_definition)
+    end
+
+    def each(&block)
+      subschemas.each(&block)
+    end
+
+    def reduce(memo, &block)
+      subschemas.reduce(memo, &block)
+    end
+
+    def parent?
+      subschemas.count > 0
+    end
+
+    def keys
+      subschemas.keys
+    end
+
+    def values
+      subschemas.values
+    end
+
+    private
+
+    attr_reader :context, :subschemas
+
+    def map_value
+      @value = Value.new self
+    end
+
+    def map_types(*args)
+      @types = args.flatten.compact.map { |type|
+        type = type.to_sym
+
+        raise ArgumentError.new("Invalid type '#{type}' specified for #{error_suffix(attribute, json_path)}}") unless Definitions::TYPES.include? type
+
+        Definitions::TYPES[type]
+      }.uniq
+    end
+
+    def map_normalizers(*args)
+      @normalizers = args.flatten.compact.map { |normalizer|
+        normalizer = normalizer.to_sym
+
+        raise ArgumentError.new("Invalid normalizer(s) '#{normalizer}' specified for #{error_suffix(attribute, json_path)}") unless context.normalizers.include?(normalizer)
+
+        context.normalizers[normalizer]
+      }.uniq
+    end
+
+    def map_format(fmt)
+      unless fmt.nil?
+        fmt = fmt.to_sym
+
+        raise ArgumentError.new("Invalid format '#{fmt}' specified for #{error_suffix(attribute, json_path)}") unless context.formats.include?(fmt)
+
+        @format = context.formats[fmt]
+      end
+    end
+
+    def map_default(default)
+      @default = default
+    end
+
+    def map_subschemas(subschema_definitions)
+      @subschemas = subschema_definitions.reduce({}) { |memo, (subschema_name, subschema_definition)|
+        raise ArgumentError.new("'subschemas' option can only be set for 'object' type schemas, attempted to provide subschemas for #{error_suffix(attribute, json_path)}") unless types.include? Definitions::TYPES[:object]
+        raise ArgumentError.new("The 'subschemas' option must be passed a hash, please check #{error_suffix(attribute, json_path)}") unless subschema_definition.is_a?(Hash)
+
+        subschema_path = build_json_path(path, subschema_name)
+        memo[subschema_name] = Schema.new(context, subschema_path, subschema_definition)
+        memo
+      } if subschema_definitions.present?
+    end
+  end
+end

data/lib/golden_fleece/type.rb

@@ -0,0 +1,22 @@
+module GoldenFleece
+  class Type
+    attr_reader :name, :classes
+
+    def initialize(name, *classes)
+      @name = name.to_sym
+      @classes = classes
+    end
+
+    def matches?(value)
+      classes.any? { |klass| value.is_a? klass }
+    end
+
+    def to_s
+      ":#{name}"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+end

data/lib/golden_fleece/utility.rb

@@ -0,0 +1,30 @@
+module GoldenFleece
+  module Utility
+    FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"].to_set
+
+    def build_json_path(parent_path, key_name)
+      "#{parent_path}#{'/' unless parent_path =~ /\/$/}#{key_name}"
+    end
+
+    def error_suffix(attribute, path)
+      "'#{path}' on column '#{attribute}'"
+    end
+
+    # Copied from ActiveModel::Type::Boolean
+    # https://github.com/rails/rails/blob/master/activemodel/lib/active_model/type/boolean.rb
+    def cast_boolean(value)
+      if value == ""
+        nil
+      else
+        !FALSE_VALUES.include?(value)
+      end
+    end
+
+    def deep_stringify_keys(hash)
+      hash.reduce({}) { |memo, (key, value)|
+        memo[key.to_s] = value.is_a?(Hash) ? deep_stringify_keys(value) : value
+        memo
+      }
+    end
+  end
+end

data/lib/golden_fleece/validations/active_model/fleece_schema_conformance_validator.rb

@@ -0,0 +1,18 @@
+require 'active_model'
+require 'golden_fleece/validations/validator_context'
+
+module GoldenFleece
+  module Validations
+    module ActiveModel
+      class FleeceSchemaConformanceValidator < ::ActiveModel::EachValidator
+        def validate_each(record, attribute, persisted_json)
+          context = record.class.fleece_context
+          errors = ValidatorContext.new(record, attribute, persisted_json, context.schemas[attribute], '/').validate
+
+          errors.each { |e| record.errors.add attribute, e }
+          errors.empty?
+        end
+      end
+    end
+  end
+end

data/lib/golden_fleece/validations/validator_context.rb

@@ -0,0 +1,74 @@
+require 'golden_fleece/utility'
+
+# An ORM-independent recursive validator that goes down into every level of
+# your nested JSON and applies various validation logic. ORM-specific validation
+# classes should use this class for their core processing. Returns an array of
+# error messages.
+
+module GoldenFleece
+  class ValidatorContext
+    include Utility
+
+    def initialize(record, attribute, persisted_json, schemas, parent_path)
+      @persisted_json = persisted_json
+      @schemas = schemas
+      @parent_path = parent_path
+      persisted_keys = if persisted_json && persisted_json.keys
+        persisted_json.keys.map(&:to_sym)
+      else
+        []
+      end
+      schemas_keys = schemas ? schemas.keys : []
+      @validatable_keys = (persisted_keys + schemas_keys).uniq
+      @record = record
+      @attribute = attribute
+      @errors = []
+    end
+
+    def validate
+      validatable_keys.each do |key|
+        path = build_json_path(parent_path, key)
+
+        validate_key key, path
+
+        # If all keys on our current level are valid, proceed
+        if errors.empty?
+          schema = schemas[key]
+          value = schema.value.compute(record)
+
+          validate_type(value, schema.types, path)
+          validate_format(value, schema.format, path)
+
+          # If the key's value is a nested JSON object, recurse down
+          errors << ValidatorContext.new(record, attribute, (persisted_json ? persisted_json[key.to_s] : nil), schemas[key], path).validate if value.is_a?(Hash)
+        end
+      end
+
+      errors.flatten
+    end
+
+    private
+
+    attr_reader :persisted_json, :schemas, :parent_path, :validatable_keys, :record, :attribute, :errors
+
+    def validate_key(key, path)
+      errors << "Invalid key #{error_suffix(attribute, path)}" unless schemas.keys.include? key
+    end
+
+    def validate_type(value, valid_types, path)
+      unless valid_types.any? { |valid_type| valid_type.matches? value }
+        errors << "Invalid type at #{error_suffix(attribute, path)}, must be one of #{valid_types}"
+      end
+    end
+
+    def validate_format(value, valid_format, path)
+      if valid_format
+        begin
+          valid_format.validate record, value
+        rescue Exception => e
+          errors << "Invalid format at #{error_suffix(attribute, path)}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/golden_fleece/value.rb

@@ -0,0 +1,69 @@
+require 'golden_fleece/definitions'
+require 'hana'
+
+module GoldenFleece
+  class Value
+    include Utility
+    
+    def initialize(schema)
+      @schema = schema
+      self.value_initialized = false
+    end
+
+    def compute(record)
+      @record = record
+
+      if dirty?
+        @value = Hana::Pointer.new(schema.json_path).eval(record.read_attribute(schema.attribute))
+
+        cast_booleans
+        apply_normalizers
+        apply_default
+
+        self.value_initialized = true
+      end
+
+      value
+    end
+
+    private
+
+    attr_accessor :value_initialized
+    attr_reader :schema, :record, :value
+
+    def dirty?
+      record.send("#{schema.attribute}_changed?") || !value_initialized
+    end
+
+    # Cast boolean values the way that Rails normally does on boolean columns
+    def cast_booleans
+      if schema.types.include? Definitions::TYPES[:boolean]
+        @value = cast_boolean(value)
+      end
+    end
+
+    def apply_normalizers
+      @value = schema.normalizers.reduce(value) { |memo, normalizer| normalizer.normalize record, memo }
+    end
+
+    # If there's a persisted value, use that
+    # If not, use the default value; if the default is a lambda, call it
+    def apply_default
+      @value = if value.nil?
+        if schema.parent?
+          d = schema.reduce({}) { |memo, (subschema_name, subschema)|
+            memo[subschema_name] = subschema.value.compute(record)
+            memo
+          }
+          d.values.compact.empty? ? nil : d
+        elsif schema.default.respond_to?(:call)
+          schema.default.call(record)
+        else
+          schema.default
+        end
+      else
+        value
+      end
+    end
+  end
+end

data/lib/golden_fleece/version.rb

@@ -0,0 +1,3 @@
+module GoldenFleece
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: golden_fleece
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ersin Akinci
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-05-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: hana
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Golden Fleece lets you validate, normalize, set up defaults for and provide
+  getters for JSON data in your Ruby data models through easy to use schemas. More
+  opinionated and easier to use than JSON Schema.
+email:
+- ersin.akinci@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- golden_fleece.gemspec
+- lib/golden_fleece.rb
+- lib/golden_fleece/context.rb
+- lib/golden_fleece/context/export.rb
+- lib/golden_fleece/context/formats.rb
+- lib/golden_fleece/context/getters.rb
+- lib/golden_fleece/context/normalizers.rb
+- lib/golden_fleece/context/schemas.rb
+- lib/golden_fleece/definitions.rb
+- lib/golden_fleece/format.rb
+- lib/golden_fleece/model.rb
+- lib/golden_fleece/model/active_model/normalization.rb
+- lib/golden_fleece/model/active_model/validation.rb
+- lib/golden_fleece/model/context.rb
+- lib/golden_fleece/model/export.rb
+- lib/golden_fleece/model/normalization.rb
+- lib/golden_fleece/normalizer.rb
+- lib/golden_fleece/schema.rb
+- lib/golden_fleece/type.rb
+- lib/golden_fleece/utility.rb
+- lib/golden_fleece/validations/active_model/fleece_schema_conformance_validator.rb
+- lib/golden_fleece/validations/validator_context.rb
+- lib/golden_fleece/value.rb
+- lib/golden_fleece/version.rb
+homepage: https://github.com/earksiinni/golden_fleece
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Easy schemas for your JSON columns.
+test_files: []