jschematic 0.0.1

data/lib/jschematic/attributes/minimum.rb

@@ -0,0 +1,22 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class Minimum
+      include Jschematic::Element
+
+      attr_reader :minimum
+
+      def initialize(minimum)
+        @minimum = minimum
+      end
+
+      def accepts?(number)
+        return true unless minimum
+        return true unless (number.kind_of?(Integer) || number.kind_of?(Float))
+
+        (number >= minimum) || fail_validation!(">= #{@minimum}", number)
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/pattern.rb

@@ -0,0 +1,18 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class Pattern
+      include Jschematic::Element
+
+      def initialize(pattern)
+        @pattern = Regexp.new(pattern)
+      end
+
+      def accepts?(instance)
+        return true unless String === instance
+        instance.match(@pattern) || fail_validation!("string matching #{@pattern}", instance)
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/pattern_properties.rb

@@ -0,0 +1,23 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class PatternProperties
+      include Jschematic::Element
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def accepts?(instance)
+        instance.all? do |property, value|
+          if match = @schema.find{ |re, schema| property =~ Regexp.new(re) }
+            Schema.new(match[1]).accepts?(value)
+          else
+            false
+          end
+        end || fail_validation!(@schema, instance)
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/properties.rb

@@ -0,0 +1,38 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class Properties
+      include Jschematic::Element
+
+      def initialize(properties)
+        @schemas = properties.inject({}) do |schemas, (name, schema)|
+          schemas[name] = Schema.new(schema)
+          schemas[name].parent = self
+          schemas
+        end
+      end
+
+      def accepts?(instance)
+        @schemas.all? do |name, schema|
+          value = instance.fetch(name) do |missing|
+            return true unless schema.required?
+            fail_validation!(missing, nil) unless schema.default 
+            schema.default
+          end
+          schema.accepts?(value) || fail_validation!(name, value)
+        end
+      end
+
+      def each(&block)
+        @schemas.values.each do |schema|
+          block.call(schema)
+        end
+      end
+
+      def id
+        @parent.id
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/required.rb

@@ -0,0 +1,28 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class Required
+      include Jschematic::Element
+
+      def initialize(required=false)
+        case required
+        when TrueClass, FalseClass
+          @required = required
+        else
+          raise "Require must be strictly true or false. Truthy and false values are not allowed."
+        end
+      end
+
+      def required?
+        @required
+      end
+
+      def accepts?(instance)
+        if @required
+          instance || fail_validation!(@required, instance)
+        end
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/type.rb

@@ -0,0 +1,61 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class Type
+      include Jschematic::Element
+
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      def accepts?(instance)
+        return true unless type
+
+        case type
+        when /^object$/
+          assert_kind_of([Hash], instance)
+        when /^number$/
+          assert_kind_of([Float, Integer], instance)
+        when /^integer$/
+          assert_kind_of([Integer], instance)
+        when /^boolean$/
+          assert_kind_of([TrueClass, FalseClass], instance)
+        when /^null$/
+          assert_kind_of([NilClass], instance)
+        when /^any$/
+          true
+        when Array # union
+          # TODO: this is gross. A specific Union type is likely called for.
+          type.any? do |union_type|
+            begin
+              if String===union_type
+                Type.new(union_type).accepts?(instance)
+              elsif Hash===union_type
+                Schema.new(union_type).accepts?(instance)
+              end
+            rescue ValidationError
+              false
+            end
+          end
+        else 
+          # TODO: probably worth just putting in explicit mapping for all 
+          # JSON schema types--there are only a few left
+          assert_kind_of([constantize(type)], instance)
+        end
+      end
+
+      private
+      
+      def assert_kind_of(klassen, instance)
+        klassen.any?{ |klass| instance.kind_of?(klass) } || fail_validation!(klassen, instance)
+      end
+
+      def constantize(string)
+        Kernel.const_get(string.capitalize)
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/unique_items.rb

@@ -0,0 +1,18 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class UniqueItems
+      include Jschematic::Element
+
+      def initialize(value=false)
+        @value = value
+      end
+
+      def accepts?(instance)
+        require true unless Array === instance
+        (instance == instance.uniq) || fail_validation!("all items to be unique", instance)
+      end
+    end
+  end
+end

data/lib/jschematic/attributes.rb

@@ -0,0 +1,28 @@
+require 'jschematic/attributes/type'
+require 'jschematic/attributes/properties'
+require 'jschematic/attributes/pattern_properties'
+require 'jschematic/attributes/additional_properties'
+require 'jschematic/attributes/items'
+require 'jschematic/attributes/additional_items'
+require 'jschematic/attributes/required'
+require 'jschematic/attributes/dependencies'
+require 'jschematic/attributes/minimum'
+require 'jschematic/attributes/maximum'
+require 'jschematic/attributes/exclusive_minimum'
+require 'jschematic/attributes/exclusive_maximum'
+require 'jschematic/attributes/min_items'
+require 'jschematic/attributes/max_items'
+require 'jschematic/attributes/unique_items'
+require 'jschematic/attributes/pattern'
+require 'jschematic/attributes/min_length'
+require 'jschematic/attributes/max_length'
+require 'jschematic/attributes/enum'
+require 'jschematic/attributes/format'
+
+module Jschematic
+  module Attributes
+    def self.[](name)
+      const_get(name[0].chr.capitalize + name[1..-1])
+    end
+  end
+end

data/lib/jschematic/element.rb

@@ -0,0 +1,25 @@
+require 'jschematic/validation_error'
+
+module Jschematic
+  module Element
+    attr_accessor :parent
+
+    def required?
+      false
+    end
+
+    def title
+      nil
+    end
+
+    def to_s
+      self.class.to_s
+    end
+
+    private
+
+    def fail_validation!(expected, actual)
+      raise Jschematic::ValidationError.new(self, expected, actual)
+    end
+  end
+end

data/lib/jschematic/errors.rb

@@ -0,0 +1,34 @@
+module Jschematic
+  class Errors
+    include Enumerable
+
+    def initialize(raise_on_error = false)
+      @raise_on_error = raise_on_error
+      @errors = []
+    end
+
+    def add(id, desc)
+      if @raise_on_error
+        raise "Error: #{desc}"
+      else
+        @errors << [id, desc]
+      end
+    end
+
+    def all
+      @errors
+    end
+
+    def empty?
+      @errors.empty?
+    end
+
+    def reset!
+      @errors = []
+    end
+
+    def each(&block)
+      @errors.each(&block)
+    end
+  end
+end

data/lib/jschematic/schema.rb

@@ -0,0 +1,77 @@
+require 'addressable/uri'
+
+require 'jschematic/errors'
+require 'jschematic/element'
+require 'jschematic/attributes'
+
+module Jschematic
+  class Schema
+    include Enumerable
+    include Jschematic::Element
+
+    attr_reader :default, :title, :description, :id
+    attr_writer :parent
+
+    def initialize(raw_schema)
+      @raw_schema  = raw_schema.dup || {}
+
+      @default     = @raw_schema.delete("default")
+      @title       = @raw_schema.delete("title") || ""
+      @description = @raw_schema.delete("description") || ""
+      @id          = Addressable::URI.parse(@raw_schema.delete("id") || "")
+
+      @attributes = []
+
+      @raw_schema.each_pair do |attribute, value|
+        begin
+          attribute = Attributes[attribute].new(value){ |dep| @raw_schema[dep] }
+          attribute.parent = self
+          @attributes << attribute
+        rescue NameError => e
+          # Not finding an attribute is not necessarily an error, but this is
+          # obviously not the right way to handle it. Need to find a better way to
+          # report information.
+          # should we create accessors for property on the schema?
+          # we could have Attributes.[] raise a special exception rather than NameError
+          puts "NameError #{e} encountered... continuing"
+        end
+      end
+    end
+
+    def accepts?(instance)
+      @attributes.all?{ |child| child.accepts?(add_default(instance)) }
+    end
+
+    def required?
+      @attributes.any?{ |child| child.required? }
+    end
+
+    def each(&block)
+      block.call(self)
+      @attributes.each{ |child| child.each(&block) }
+    end
+
+    def id
+      if @parent
+        @parent.id + @id
+      else
+        @id
+      end
+    end
+
+    private
+
+    def add_default(instance)
+      return instance unless default
+
+      case instance
+      when Hash
+        @default.keys.each do |key|
+          instance[key] = @default[key] unless instance.has_key?(key)
+        end
+      end
+
+      instance
+    end
+  end
+end

data/lib/jschematic/validation_error.rb

@@ -0,0 +1,13 @@
+module Jschematic
+  class ValidationError < StandardError
+    attr_reader :what, :expected, :actual
+
+    def initialize(what, expected, actual)
+      @what, @expected, @actual = what, expected, actual
+    end
+
+    def to_s
+      "#{what} expected #{expected} but found #{actual}"
+    end
+  end
+end

data/lib/jschematic.rb

@@ -0,0 +1,13 @@
+require 'jschematic/schema'
+
+module Jschematic
+  def self.validate(instance, schema)
+    validate!(instance, schema)
+  rescue ValidationError
+    false
+  end
+
+  def self.validate!(instance, schema)
+    Schema.new(schema).accepts?(instance)
+  end
+end

data/spec/jschematic/attributes/enum_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module Jschematic
+  module Attributes
+    describe Enum do
+      subject { Enum }
+
+      it "raises unless its schema value is an Array" do
+        expect { subject.new("this is allowed, right?") }.to raise_error
+        expect { subject.new(["not", "really"]) }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/jschematic/attributes/max_items_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Jschematic
+  module Attributes
+    describe MaxItems, "with a maximum of two items" do
+      subject { MaxItems.new(2) }
+
+      describe "#accepts?" do
+        it { should accept([1,2])                           }
+        it { should_not accept([1,2,3])                     }
+        it { should accept("instance that is not an array") }
+      end
+    end
+  end
+end

data/spec/jschematic/attributes/min_items_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Jschematic
+  module Attributes
+    describe MinItems, "with a minimum of two items" do
+      subject { MinItems.new(2) }
+
+      describe "#accepts?" do
+        it { should     accept([1,2])                           }
+        it { should_not accept([1])                             }
+        it { should     accept("instance that is not an array") }
+      end
+    end
+  end
+end

data/spec/jschematic/attributes/minimum_maximum_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Jschematic
+  module Attributes
+    describe Minimum do
+      subject { Minimum.new(2112) }
+
+      it { should accept("portokalli") }
+    end
+
+    describe Maximum do
+      subject { Maximum.new(2112) }
+      
+      it { should accept("portokalli") }
+    end
+
+    describe ExclusiveMinimum do
+      subject { ExclusiveMinimum }
+
+      it "raises if minimum is not defined" do
+        expect { subject.new(true){|needed| nil} }.to raise_error(/'exclusiveMinimum' depends on 'minimum'/)
+      end
+    end
+
+    describe ExclusiveMaximum do
+      subject { ExclusiveMaximum }
+
+      it "raises if maximum is not defined" do
+        expect { subject.new(true){|needed| nil} }.to raise_error(/'exclusiveMaximum' depends on 'maximum'/)
+      end
+    end
+  end
+end

data/spec/jschematic/attributes/required_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module Jschematic
+  module Attributes
+    describe Required do
+      describe "#required?" do
+        subject { Required }
+
+        context "by default" do
+          it "answers false" do
+            subject.new.should_not be_required
+          end
+        end
+
+        context "when true" do
+          it "answers true" do
+            subject.new(true).should be_required
+          end
+        end
+
+        context "when truthy or falsy" do
+          it "raises an error" do
+            expect { subject.new("true") }.to raise_error
+          end
+        end
+      end
+    end
+  end
+end

data/spec/jschematic/attributes/type_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module Jschematic
+  module Attributes
+    describe Type do
+      context "string" do
+        subject { Type.new("string") }
+        it { should_not accept(nil) }
+      end
+
+      context "number" do
+        subject { Type.new("number") }
+        it { should_not accept(nil) }
+        it { should accept(2112) }
+      end
+
+      context "integer" do 
+        subject { Type.new("integer") }
+        it { should_not accept(nil) }
+      end
+
+      context "boolean" do
+        subject { Type.new("boolean") }
+        it { should_not accept(nil) }
+        it { should_not accept("true") }
+        it { should_not accept([1,2,3]) }
+      end
+
+      context "object" do
+        subject { Type.new("object") }
+        it { should_not accept(nil) }
+        it { should_not accept([1,2,3]) }
+        it { should_not accept("string") }
+      end
+
+      context "array" do
+        subject { Type.new("array") }
+        it { should_not accept(nil) }
+        it { should_not accept({:foo => "bar"}) }
+        it { should_not accept(1234) }
+      end
+
+      context "null" do
+        subject { Type.new("null") }
+        it { should accept(nil) }
+        it { should_not accept(true) }
+        it { should_not accept("string") }
+        it { should_not accept([1,2,3]) }
+      end
+
+      context "any" do
+        subject { Type.new("any") }
+        it { should accept(nil) }
+      end
+
+      context "union" do
+        subject { Type.new(["string", "integer"]) }
+        it { should_not accept(nil) }
+      end
+    end
+  end
+end
+

data/spec/jschematic/attributes_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+module Jschematic
+  describe Attributes do
+    describe ".[]" do
+      it "maps from javascript style names to classes" do
+        Attributes::ExclusiveMaximum.should_receive(:new).with(1, 2)
+        subject["exclusiveMaximum"].new(1, 2)
+      end
+    end
+  end
+end

data/spec/jschematic/errors_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module Jschematic
+  describe Errors do
+    let(:errors) { Errors.new }
+
+    it "is enumerable" do
+      errors.class.should include(Enumerable)
+
+      errors.add(:ident1, "desc1")
+      errors.add(:ident2, "desc2")
+
+      col = []
+      errors.each{ |error| col << error }
+
+      col.should == [[:ident1, "desc1"], [:ident2, "desc2"]]
+    end
+
+    describe "#add" do
+      it "records an error" do
+        errors.add(:ident, "description")
+        errors.all.should == [[:ident, "description"]]
+      end
+
+      context "when raise on error is true" do
+        let(:errors) { Errors.new(true) }
+
+        it "raises when an error is added" do
+          expect { errors.add(:ident, "description") }.to raise_error(/Error: description/)
+        end
+      end
+    end
+
+    describe "#reset!" do
+      it "clears the collected errors" do
+        errors.add(:ident, "desc")
+        errors.should_not be_empty
+        errors.reset!
+        errors.should be_empty
+      end
+    end
+  end
+end