strain 0.0.1

data/lib/json_schema/draft_4_meta_schema.json

@@ -0,0 +1,150 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}

data/lib/strain/engine.rb

@@ -0,0 +1,21 @@
+module Strain
+  class Engine < ::Rails::Engine
+
+    require "json-schema"
+    require "jsonapi-resources"
+
+    isolate_namespace Strain
+
+    config.autoload_paths += Dir["#{config.root}/lib/**/"]
+
+    config.generators do |g|
+      g.test_framework      :rspec,
+        view_specs: false,
+        helper_specs: false,
+        routing_specs: true,
+        controller_specs: true,
+        request_specs: true
+      g.fixture_replacement :factory_girl, dir: "spec/factories"
+    end
+  end
+end

data/lib/strain/schema_tools/defaults.rb

@@ -0,0 +1,53 @@
+module Strain
+  module SchemaTools
+    class Defaults
+
+      def initialize(schema_hash, data_hash)
+        @schema = schema_hash
+        @data = data_hash
+      end
+
+      def default_values
+        raise "Invalid schema." unless @schema["type"] == "object" && @schema.has_key?("properties")
+        property_defaults(@schema["properties"])
+      end
+
+      def data_with_defaults
+        merge_defaults(@data, default_values)
+      end
+
+      private
+
+      def property_defaults(properties_hash)
+        properties_hash.each_with_object({}) do | (prop_name, prop_schema), memo |
+          if prop_schema["type"] === "object" &&
+            prop_schema.has_key?("default")
+            memo[prop_name] = prop_schema["default"]
+          end
+
+          if prop_schema["type"] === "object" &&
+            prop_schema.has_key?("properties")
+            extracted_defaults = property_defaults(prop_schema["properties"])
+            memo[prop_name] = extracted_defaults unless extracted_defaults.empty?
+          elsif prop_schema.has_key?("default")
+            memo[prop_name] = prop_schema["default"]
+          end
+        end
+      end
+
+      def merge_defaults(data, defaults)
+        data.merge(defaults) do | key, data_value, default_value |
+          if data_value.is_a? Hash
+            merge_defaults(data_value, default_value)
+          elsif [nil, "", []].include?(data_value)
+            default_value
+          else
+            data_value
+          end
+        end
+      end
+
+
+    end
+  end
+end

data/lib/strain/version.rb

@@ -0,0 +1,3 @@
+module Strain
+  VERSION = "0.0.1"
+end

data/lib/strain.rb

@@ -0,0 +1,17 @@
+require "strain/engine"
+
+module Strain
+
+  JSONAPI::Exceptions::ValidationErrors.module_eval do
+    def json_api_error(attr_key, message)
+      a = JSONAPI::Error.new(code: JSONAPI::VALIDATION_ERROR,
+                         status: :unprocessable_entity,
+                         title: message,
+                         detail: "#{format_key(attr_key)} - #{message}",
+                         source: { pointer: pointer(attr_key) })
+      # binding.pry
+      a
+    end
+  end
+
+end

data/lib/tasks/strain_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :strain do
+#   # Task goes here
+# end

data/spec/factories/strain_articles.rb

@@ -0,0 +1,15 @@
+FactoryGirl.define do
+
+  factory :article, :class => 'Strain::Article' do
+    body_hash = {
+      "summary": "this is a test article",
+      "main": "This is the main article body."
+    }
+
+    body body_hash
+    slug "test-article"
+    title "Test Article"
+    variant
+  end
+
+end

data/spec/factories/strain_variants.rb

@@ -0,0 +1,34 @@
+FactoryGirl.define do
+  factory :variant, class: Strain::Variant do
+    schema_hash = {
+      "type": "object",
+      "properties": {
+        "summary": {"type": "string"},
+        "main": {"type": "string"}
+      },
+      "additionalProperties": false
+    }
+    name "test"
+    schema schema_hash
+
+    trait :nested_schema do
+      schema_hash = {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "summary": {"type": "string"},
+          "main": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "section_title": {"type": "string"},
+              "section_text": {"type": "string"}
+            }
+          }
+        }
+      }
+      schema schema_hash
+    end
+
+  end
+end

data/spec/lib/strain/schema_tools/defaults_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+require 'strain/schema_tools/defaults.rb'
+
+module Strain::SchemaTools
+  RSpec.describe Defaults do
+    subject(:d) { Defaults.new(schema, data) }
+    let(:schema) do
+      { "type" => "object", "properties" => {
+          "title" => {"type" => "string", "default" => "default title"},
+          "summary" => {"type" => "string"},
+          "author" => {
+            "type" => "object", "properties" => {
+              "name" => {"type" => "string", "default" => "default author"},
+              "date" => {"type" => "integer", "default" => 2005}
+      } } } }
+    end
+    let(:data) do
+      { "title" => nil,
+        "summary" => "test summary",
+        "author" => {
+          "name" => "Jane Author",
+          "date" => nil
+      } }
+    end
+
+    describe "#default_values" do
+      subject(:default_values) {d.default_values}
+
+      context "with a simple schema" do
+        let(:schema) do
+          { "type" => "object", "properties" => {
+            "title" => {"type" => "string", "default" => "default title"}
+          } }
+        end
+        it "returns a hash with all declared defaults" do
+          expect(default_values).to eq({"title" => "default title"})
+        end
+      end
+
+      context "with a typical schema" do
+        it "returns a hash with all declared defaults" do
+          expect(default_values).to eq(
+            {"title"=>"default title", "author"=>{"name"=>"default author", "date"=>2005}}
+          )
+        end
+      end
+
+      context "with a nested schema" do
+        let(:schema) do
+          {
+            "type" => "object", "properties" => {
+            "title" => {"type" => "string", "default" => "default title"},
+            "summary" => {"type" => "string"},
+            "author" => {
+              "type" => "object", "properties" => {
+                "name" => {"type" => "string", "default" => "default author"},
+                "date" => {"type" => "integer", "default" => 2005}
+          } } } }
+        end
+        it "returns a hash with all declared defaults" do
+          expect(default_values).to eq({
+            "title" => "default title",
+            "author" => {
+              "name" => "default author",
+              "date" => 2005
+          } })
+        end
+      end
+
+      context "with array defaults" do
+        let(:schema) do
+          { "type" => "object", "properties" => {
+            "numbers" => {"type" => "array", "default" => "[1, 2, 3]"}
+          } }
+        end
+        it "returns a hash with all declared defaults" do
+          expect(default_values).to eq({"numbers" => "[1, 2, 3]"})
+        end
+      end
+
+      context "with non-conflicting object defaults" do
+        let(:schema) do
+          { "type" => "object", "properties" => {
+            "obj_with_defaults" => {
+              "type" => "object",
+              "default" => {"inner_prop" => "test"},
+              "properties" => {"inner_prop" => { "type": "string" }}
+          } } }
+        end
+        it "returns a hash with all declared defaults" do
+          expect(default_values).to eq(
+            {"obj_with_defaults" => {"inner_prop" => "test"}}
+          )
+        end
+      end
+
+      context "with conflicting object defaults" do
+        let(:schema) do
+          { "type" => "object", "properties" => {
+            "obj_with_defaults" => {
+              "type" => "object",
+              "default" => {"inner_prop" => "outer_default"},
+              "properties" => {
+                "inner_prop" => {"type" => "string", "default" => "inner_default"}
+          } } } }
+        end
+        it "prioritizes inner defaults" do
+          expect(default_values).to eq(
+            {"obj_with_defaults" => {"inner_prop" => "inner_default"}}
+          )
+        end
+      end
+
+      context "with no properties on an object and no defaults" do
+        let(:schema) do
+          { "type" => "object", "properties" => {
+            "obj_with_defaults" => {
+              "type" => "object"
+          } } }
+        end
+        it "returns a blank hash" do
+          expect(default_values).to eq({})
+        end
+      end
+
+      context "with no properties on an object and defaults" do
+        let(:schema) do
+          { "type" => "object", "properties" => {
+            "obj_with_defaults" => {
+              "type" => "object",
+              "default" => {"inner_prop" => "test"}
+          } } }
+        end
+        it "returns a hash with defaults set" do
+          expect(default_values).to eq({"obj_with_defaults" => {"inner_prop" => "test"}})
+        end
+      end
+    end
+
+    describe "#data_with_defaults" do
+      subject(:data_with_defaults) {d.data_with_defaults}
+
+      context "with some missing data and basic schema" do
+        it "merges defaults with the data" do
+          expect(data_with_defaults).to eq({
+            "title" => "default title",
+            "summary" => "test summary",
+            "author" => {
+              "name" => "Jane Author",
+              "date" => 2005
+          } })
+        end
+      end
+
+      context "with blank strings" do
+        let(:data) do
+          { "title" => "",
+            "summary" => "",
+            "author" => ""
+          }
+        end
+        it "replaces blank strings with defaults" do
+          expect(data_with_defaults).to eq({
+            "title" => "default title",
+            "summary" => "",
+            "author" => {
+              "name" => "default author",
+              "date" => 2005
+          } })
+        end
+      end
+
+      context "with blank arrays" do
+        let(:data) do
+          {"numbers" => []}
+        end
+        let(:schema) do
+          { "type" => "object",
+            "properties" => {
+              "numbers" => {"type" => "array", "default" => [1,2,3]}
+          } }
+        end
+        it "replaces blank arrays with defaults" do
+          expect(data_with_defaults).to eq({
+            "numbers" => [1,2,3]
+          })
+        end
+      end
+
+      context "with blank arrays containing objects" do
+        let(:data) do
+          {"tags" => []}
+        end
+        let(:schema) do
+          { "type" => "object",
+            "properties" => {
+              "tags" => {
+                "type" => "array",
+                "items" => {"type" => "string"},
+                "default" => [{"tag1" => "red"}, {"tag2"=>"green"}]
+          } } }
+        end
+        it "replaces blank arrays with defaults" do
+          expect(data_with_defaults).to eq({
+            "tags" => [{"tag1" => "red"}, {"tag2"=>"green"}]
+          })
+        end
+      end
+
+      context "with deeply nested objects" do
+        let(:data) do
+          {"second_level" => {} }
+        end
+        let(:schema) do
+          { "type" => "object",
+            "properties" => {
+              "second_level" => {
+                "type" => "object",
+                "properties" => {
+                  "third_level" => {
+                    "type" => "object",
+                    "default" => {"deep_property" => "test"}
+          } } } } }
+        end
+        it "merges defaults" do
+          expect(data_with_defaults).to eq({
+            "second_level"=>{"third_level"=>{"deep_property"=>"test"}}
+          })
+        end
+      end
+    end
+
+  end
+end

data/spec/models/strain/article_spec.rb

@@ -0,0 +1,72 @@
+require 'rails_helper'
+
+module Strain
+  RSpec.describe Article, type: :model do
+
+    it "has a valid factory" do
+      expect(build(:article)).to be_valid
+    end
+
+    it "is invalid without a slug" do
+      expect(build(:article, slug: nil)).to be_invalid
+    end
+
+    it "is invalid with a non-URL-safe slug" do
+      expect(build(:article, slug: "invalid slug")).to be_invalid
+    end
+
+    it "is invalid without a variant" do
+      expect(build(:article, variant: nil)).to be_invalid
+    end
+
+    it "is invalid without a body" do
+      expect(build(:article, body: nil)).to be_invalid
+    end
+
+    it "is invalid without a title" do
+      expect(build(:article, title: nil)).to be_invalid
+    end
+
+    it "raises a database error with a nonunique slug" do
+      a = create(:article)
+      b = build(:article, slug: a.slug, variant: a.variant)
+      expect {b.save(validate: false)}.to raise_error(ActiveRecord::RecordNotUnique)
+    end
+
+    it "is invalid with a nonunique slug" do
+      a = create(:article)
+      b = build(:article, slug: a.slug, variant: a.variant)
+      expect(b).to be_invalid
+    end
+
+    it "is valid when compliant with its Variant" do
+      v = create(:variant)
+      a = build(:article, variant: v, body: {"summary": "test", "main": "test"})
+      expect(a).to be_valid
+    end
+
+    it "is invalid when not compliant with its Variant" do
+      v = create(:variant)
+      a = build(:article, variant: v, body: {"extra_property": "test", "main": "test"})
+      expect(a).to be_invalid
+    end
+
+    it "fills in schema-defined defaults" do
+      v = build(:variant, schema: {
+        "type": "object",
+        "properties": {
+          "title": {
+            "type": "string",
+            "default": "default Title"
+          }
+        }
+      })
+      a = create(:article, variant: v, body:{})
+      expect(a.body["title"]).to eq("default Title")
+    end
+
+    it "provides detailed errors when invalid according to JSON schema"
+    it "enforces key format? - hyphenated, underscores, camelcase?"
+
+  end
+end

data/spec/models/strain/variant_spec.rb

@@ -0,0 +1,42 @@
+require "rails_helper"
+
+module Strain
+  RSpec.describe Variant, type: :model do
+
+    it "has a valid factory" do
+      expect(build(:variant)).to be_valid
+    end
+
+    it "is invalid without a name" do
+      expect(build(:variant, name: nil)).to be_invalid
+    end
+
+    it "is invalid without a Schema" do
+      expect(build(:variant, schema: nil)).to be_invalid
+      expect(build(:variant, schema: {})).to be_invalid
+    end
+
+    it "is invalid with an invalid JSON Schema" do
+      expect(build(:variant, schema: {"type": "nonsense"})).to be_invalid
+    end
+
+    it "raises a database error with a nonunique name" do
+      a = create(:variant)
+      b = build(:variant, name: a.name)
+      expect {b.save(validate: false)}.to raise_error(ActiveRecord::RecordNotUnique)
+    end
+
+    it "is invalid with a nonunique name" do
+      a = create(:variant)
+      b = build(:variant, name: a.name)
+      expect(b).to be_invalid
+    end
+
+    it "is invalid unless root schema type is object" do
+      a = build(:variant, schema: {"type": "string"})
+      expect(a).to be_invalid
+      expect(a.errors.messages[:schema]).to include("must have an object as root element.")
+    end
+
+  end
+end