jimmy 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8467dcce9891fc3ea4098a9e89ec2591c58cf1df
-  data.tar.gz: 76ce29801be14c4d29e640d1820e5ea23eda0bb5
+  metadata.gz: cc78f64835960e1b8d8724bee79adc324f710bb7
+  data.tar.gz: 647dab7d9050d3ec4642b55a2cbc2211bfac1ab9
 SHA512:
-  metadata.gz: bd47a8d315ea3d3cea8f6faf37441ebb684f0fccb04d8819887bf727dfdefe7d89b810a3d3c09a37d4e2cb0cad50677476220368908da17ec690c29ac00e5d27
-  data.tar.gz: 3b66e4dde7fafab70cb5d52941a4e1d0342509634da90fc9a3f736bbe4b17e5b8d7d2678120c115f9a58dc8a68e178be91c8b382f7188f59760086fb62cd8ae6
+  metadata.gz: d8f71fc6b11b45bca65a0f599ef0cfa161d43d0c93e208fa47ec42b840c9584a76a7f358b4063e3901bcc51e65c3b8db948e86d3b336363ec87be098db6cdc26
+  data.tar.gz: c11234863a1c7f3ccc8180c3e4f55b9d88844c648f34efa06aef0d30a31869aae7c21a345a1fcd0df7a0c3463cd71880f09863ce18cc4460dc35c0e0caafa46c

data/jimmy.gemspec

@@ -19,6 +19,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   spec.license       = 'Apache License, Version 2.0'
 
+  spec.add_dependency 'json-schema', '~> 2.5'
+
   spec.add_development_dependency 'bundler', '~> 1.9'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.2'

data/lib/jimmy.rb

@@ -13,3 +13,4 @@ require_relative 'jimmy/schema_creation'
 require_relative 'jimmy/schema_types'
 require_relative 'jimmy/schema_type'
 require_relative 'jimmy/combination'
+require_relative 'jimmy/validation_error'

data/lib/jimmy/combination.rb

@@ -15,8 +15,8 @@ module Jimmy
       instance_exec &types_proc
     end
 
-    def serialize
-      {"#{condition}Of" => map(&:serialize)}
+    def compile
+      {"#{condition}Of" => map(&:compile)}
     end
 
     SchemaCreation.apply_to(self) { |schema| push schema }

data/lib/jimmy/domain.rb

@@ -1,47 +1,94 @@
 require 'uri'
 require 'pathname'
+require 'json'
+require 'json-schema'
 
 require_relative 'schema_creation'
 
 module Jimmy
   class Domain
 
-    attr_reader :root, :types
+    attr_reader :root, :types, :partials
 
     def initialize(root)
-      @root = URI(root)
-      @schemas = {}
-      @types = {}
+      @root     = URI(root)
+      @schemas  = {}
+      @types    = {}
+      @partials = {}
+      @import_paths = []
     end
 
     def domain
       self
     end
 
-    def import_path(path)
+    def import(path)
       path = Pathname(path) unless path.is_a? Pathname
-      @types = import_schemas(path + 'types', path).map { |k, v| [k.to_sym, v] }.to_h
-      @schemas = import_schemas(path, path, 'types/')
+      @import_paths << path unless @import_paths.include? path
+
+      glob path, only: 'types' do |name, schema|
+        @types[name.to_sym] = schema
+      end
+
+      glob path, only: 'partials' do |name|
+        partial_path = path + 'partials' + "#{name}.rb"
+        @partials[name] = [partial_path.read, partial_path.to_s]
+      end
+
+      glob path, ignore: %r`^(types|partials)/` do |name, schema|
+        @schemas[name] = schema
+      end
+    end
+
+    def autoload_type(name)
+      # TODO: protect from circular dependency
+      return if types.key? name
+      @import_paths.each do |import_path|
+        path = import_path + "types/#{name}.rb"
+        if path.file?
+          @types[name] = load_schema_from_path(path, name)
+          return true
+        end
+      end
+      false
     end
 
     def [](schema_name)
       @schemas[schema_name.to_s]
     end
 
+    def export(path = nil)
+      path = Pathname(path) if path.is_a? String
+      raise 'Please specify an export directory' unless path.is_a?(Pathname) && (path.directory? || !path.exist?)
+      path.mkpath
+      @schemas.each { |name, schema| export_schema schema, path + "#{name.to_s}.json" }
+      @types.each   { |name, schema| export_schema schema, path + 'types' + "#{name.to_s}.json" }
+    end
+
     private
 
-    def import_schemas(path, base_path, reject_prefix = nil)
-      result = {}
-      Dir[path + '**/*.rb'].each do |full_path|
+    def glob(base_path, only: '.', ignore: nil, &block)
+      lookup_path = base_path + only
+      Dir[lookup_path + '**/*.rb'].each do |full_path|
         full_path = Pathname(full_path)
-        relative_path = full_path.relative_path_from(path)
-        next if reject_prefix && relative_path.to_s.start_with?(reject_prefix)
-        base_name = relative_path.to_s[0..-4]
-        schema = instance_eval(full_path.read, full_path.to_s).schema
-        schema.name = full_path.relative_path_from(base_path).to_s[0..-4]
-        result[base_name] = schema
+        relative_path = full_path.relative_path_from(lookup_path)
+        next if ignore === relative_path.to_s
+        args = [relative_path.to_s[0..-4]]
+        args << load_schema_from_path(full_path, full_path.relative_path_from(base_path).to_s[0..-4]) if block.arity == 2
+        yield *args
+      end
+    end
+
+    def load_schema_from_path(path, name)
+      instance_eval(path.read, path.to_s).schema.tap do |schema|
+        schema.name = name.to_s
+        JSON::Validator.add_schema JSON::Schema.new(schema.to_h, nil)
       end
-      result
+    end
+
+    def export_schema(schema, target_path)
+      target_path.parent.mkpath
+      target_path.write JSON.pretty_generate(schema.to_h)
     end
 
     SchemaCreation.apply_to self

data/lib/jimmy/schema.rb

@@ -5,13 +5,7 @@ module Jimmy
     attr_accessor :name
 
     @argument_handlers = Hash.new { |hash, key| hash[key] = {} }
-
-    def self.create(*args, &block)
-      new(*args).tap do |schema|
-        schema.dsl.evaluate block if block
-      end
-    end
-
+    
     def self.set_argument_handler(schema_class, arg_class, handler)
       @argument_handlers[schema_class][arg_class] = handler
     end
@@ -26,28 +20,37 @@ module Jimmy
       result && result.last
     end
 
-    def serialize
-      serializer = nil
+    def compile
+      compiler = nil
       schema_class = SchemaTypes[type]
       until schema_class == SchemaType do
-        serializer ||= SchemaTypes.serializers[schema_class]
+        compiler ||= SchemaTypes.compilers[schema_class]
         schema_class = schema_class.superclass
       end
       {'type' => type.to_s}.tap do |hash|
-        dsl.evaluate serializer, hash if serializer
+        dsl.evaluate compiler, hash if compiler
       end
     end
 
+    def url
+      "#{domain.root}/#{name}.json#"
+    end
+
     def to_h
-      {}.tap do |hash|
-        hash['$schema'] = "#{domain.root}/#{name}#" if name
-        hash.merge! serialize
+      {'$schema' => 'http://json-schema.org/draft-04/schema#'}.tap do |hash|
+        hash['id'] = url if name
+        hash.merge! compile
       end
     end
 
+    def validate(data)
+      errors = JSON::Validator.fully_validate(JSON::Validator.schema_for_uri(url).schema, data, errors_as_objects: true)
+      raise ValidationError.new(self, data, errors) unless errors.empty?
+    end
+
     private
 
-    def initialize(type, domain, *args)
+    def initialize(type, domain, *args, &block)
       @attrs  = {}
       @type   = type
       @domain = domain
@@ -64,6 +67,7 @@ module Jimmy
             dsl.evaluate handler, arg
         end
       end
+      dsl.evaluate block if block
     end
 
   end

data/lib/jimmy/schema_creation.rb

@@ -32,13 +32,15 @@ module Jimmy
           handler = SchemaCreation.handlers[self.class]
           self.class.__send__ :define_method, method do |*inner_args, &inner_block|
             handler_args = handler && inner_args.shift(handler.arity - 1)
-            schema = Schema.create(method, domain, *inner_args, &inner_block)
+            schema = Schema.new(method, domain, *inner_args, &inner_block)
             instance_exec schema, *handler_args, &handler if handler
             schema.dsl
           end
           return __send__ method, *args, &block
         end
 
+        domain.autoload_type method
+
         if domain.types.key? method
           return instance_exec method, *args, &SchemaCreation.handlers[self.class]
         end

data/lib/jimmy/schema_type.rb

@@ -27,8 +27,8 @@ module Jimmy
         SchemaTypes.nested_handlers[self] = handler
       end
 
-      def serialize(&handler)
-        SchemaTypes.serializers[self] = handler
+      def compile(&handler)
+        SchemaTypes.compilers[self] = handler
       end
 
     end
@@ -53,8 +53,12 @@ module Jimmy
         included_args.map { |arg| [arg.to_s.gsub(/_([a-z])/) { $1.upcase }, attrs[arg]] }.to_h
       end
 
-      def serialize_schema(schema)
-        schema.is_a?(Symbol) ? {'$ref' => "/types/#{schema}#"} : schema.serialize
+      def compile_schema(schema)
+        schema.is_a?(Symbol) ? {'$ref' => "/types/#{schema}.json#"} : schema.compile
+      end
+
+      def include(*partial_names)
+        partial_names.each { |name| instance_eval *domain.partials[name.to_s] }
       end
 
     end

data/lib/jimmy/schema_types.rb

@@ -9,14 +9,14 @@ module Jimmy
     @types = {}
     @dsls = {}
     @nested_handlers = {}
-    @serializers = {}
+    @compilers = {}
 
     class << self
       extend Forwardable
 
       delegate %i[each keys values key?] => :@types
 
-      attr_reader :dsls, :nested_handlers, :serializers
+      attr_reader :dsls, :nested_handlers, :compilers
 
       def [](type_name)
         @types[type_name]

data/lib/jimmy/schema_types/array.rb

@@ -15,13 +15,13 @@ module Jimmy
       (attrs[:items] ||= []) << schema
     end
 
-    serialize do |hash|
+    compile do |hash|
       hash.merge! camelize_attrs(%i[min_items max_items])
       items = attrs[:items] || []
       if items.length > 1
-        hash['items'] = {'anyOf' => items.map { |i| serialize_schema i }}
+        hash['items'] = {'anyOf' => items.map { |i| compile_schema i }}
       elsif items.length == 1
-        hash['items'] = serialize_schema(items.first)
+        hash['items'] = compile_schema(items.first)
       end
     end
 

data/lib/jimmy/schema_types/number.rb

@@ -22,7 +22,7 @@ module Jimmy
       end
     end
 
-    serialize do |hash|
+    compile do |hash|
       hash.merge! camelize_attrs(%i[minimum maximum exclusive_minimum exclusive_maximum multiple_of])
     end
 

data/lib/jimmy/schema_types/object.rb

@@ -23,7 +23,7 @@ module Jimmy
       (attrs[:properties] ||= {})[property_name] = schema
     end
 
-    serialize do |hash|
+    compile do |hash|
       (attrs[:properties] || {}).each do |key, value|
         collection, key =
             if key.is_a? Regexp
@@ -32,7 +32,7 @@ module Jimmy
               ['properties', key.to_s]
             end
         hash[collection] ||= {}
-        hash[collection][key] = serialize_schema(value)
+        hash[collection][key] = compile_schema(value)
       end
       hash['required'] = (attrs[:required] || []).to_a
       hash['additionalProperties'] = !!attrs[:additional_properties]

data/lib/jimmy/schema_types/string.rb

@@ -6,11 +6,20 @@ module Jimmy
     trait :max_length
     trait(:pattern) { |regex| attrs[:pattern] = regex.is_a?(Regexp) ? regex.inspect.gsub(%r`^/|/[a-z]*$`, '') : regex }
     trait(Regexp) { |regex| pattern regex }
-    trait(Range) { |value| attrs[:min_length], attrs[:max_length] = [value.first, value.last].sort }
+    trait Range do |value|
+      variation = value.exclude_end? ? 1 : 0
+      if value.first < value.last
+        attrs[:min_length] = value.first
+        attrs[:max_length] = value.last - variation
+      else
+        attrs[:max_length] = value.first
+        attrs[:min_length] = value.last + variation
+      end
+    end
     trait(Fixnum) { |value| min_length value; max_length value }
     trait(Array) { |value| attrs[:enum] = value.map(&:to_s) }
 
-    serialize do |hash|
+    compile do |hash|
       hash.merge! camelize_attrs(%i[min_length max_length pattern enum])
     end
 

data/lib/jimmy/validation_error.rb

@@ -0,0 +1,20 @@
+require 'ostruct'
+
+module Jimmy
+  class ValidationError < StandardError
+
+    attr_reader :schema, :data, :errors
+
+    def initialize(schema, data, errors)
+      @schema = schema
+      @data   = data
+      @errors = errors.map do |info|
+        OpenStruct.new(
+            property: info[:fragment][2..-1],
+            message:  info[:message].gsub(/ in schema \S+$/, ''),
+            aspect:   info[:failed_attribute]
+        )
+      end
+    end
+  end
+end

data/lib/jimmy/version.rb

@@ -1,3 +1,3 @@
 module Jimmy
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: jimmy
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Neil E. Pearson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-29 00:00:00.000000000 Z
+date: 2015-07-29 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -81,6 +95,7 @@ files:
 - lib/jimmy/schema_types/object.rb
 - lib/jimmy/schema_types/string.rb
 - lib/jimmy/symbol_array.rb
+- lib/jimmy/validation_error.rb
 - lib/jimmy/version.rb
 homepage: https://github.com/orionvm/jimmy
 licenses: