jimmy 0.5.5

data/lib/jimmy/link.rb

@@ -0,0 +1,93 @@
+require 'forwardable'
+
+module Jimmy
+  class Link < Hash
+    attr_reader :schema
+
+    def initialize(schema, rel, href)
+      @schema = schema
+      merge! 'rel'  => rel.to_s,
+             'href' => href.to_s
+    end
+
+    def dsl
+      @dsl ||= DSL.new(self)
+    end
+
+    def schemas
+      @schemas ||= {}
+    end
+
+    def domain
+      schema.domain
+    end
+
+    def compile
+      merge schemas.map { |k, v| [(k ? "#{k}Schema" : 'schema'), v.compile] }.to_h
+    end
+
+    def schema_creator
+      @schema_creator ||= SchemaCreator.new(self)
+    end
+
+    class SchemaCreator < Hash
+      include SchemaCreation::Referencing
+      extend Forwardable
+      delegate [:schema, :domain] => :@link
+
+      def initialize(link)
+        @link = link
+      end
+
+      def parent
+        schema
+      end
+
+      SchemaCreation.apply_to(self) { |schema, prefix| @link.schemas[prefix] = schema }
+    end
+
+    class DSL
+      attr_reader :link
+
+      def initialize(link)
+        @link = link
+      end
+
+      def domain
+        link.domain
+      end
+
+      def title(value)
+        link['title'] = value
+      end
+
+      def method(value)
+        link['method'] = value.to_s.upcase
+      end
+
+      def evaluate(&block)
+        instance_exec &block
+      end
+
+      def schema(*args, prefix: nil, **opts, &block)
+        if args.empty? && opts.any?
+          args = opts.shift
+          type = args.shift
+        else
+          type = args.shift || :object
+        end
+        args.unshift type, prefix
+        args << opts if opts.any?
+        link.schema_creator.__send__ *args, &block
+      end
+
+      def target_schema(*args, **opts, &block)
+        schema *args, **opts.merge(prefix: :target), &block
+      end
+
+      def set(**values)
+        values.each { |k, v| link[k.to_s] = v }
+      end
+    end
+  end
+end

data/lib/jimmy/reference.rb

@@ -0,0 +1,39 @@
+require_relative './transform_keys'
+
+module Jimmy
+  class Reference
+    include SchemaCreation::MetadataMethods
+    attr_reader :uri, :data
+
+    def initialize(uri, domain, nullable = false, *args, **opts, &block)
+      @uri      = TransformKeys.transformer.transform_ref(uri, domain.options[:transform_keys])
+      @nullable = nullable
+      @data     = {}
+      args.each { |arg| __send__ arg }
+      opts.each { |arg| __send__ *arg }
+      instance_exec &block if block
+    end
+
+    def compile
+      data.merge(nullable? ?
+        {
+            'anyOf' => [
+                {'type' => 'null'},
+                ref_hash
+            ]
+        } :
+        ref_hash
+      )
+    end
+
+    def nullable?
+      @nullable
+    end
+
+    private
+
+    def ref_hash
+      {'$ref' => uri}
+    end
+  end
+end

data/lib/jimmy/schema.rb

@@ -0,0 +1,114 @@
+module Jimmy
+  class Schema
+    JSON_SCHEMA_URI       = 'http://json-schema.org/draft-04/schema#'
+    JSON_HYPER_SCHEMA_URI = 'http://json-schema.org/draft-04/hyper-schema#'
+
+    attr_reader :dsl, :attrs, :domain, :type, :parent
+    attr_writer :name
+    attr_accessor :nullable
+
+    @argument_handlers = Hash.new { |hash, key| hash[key] = {} }
+    
+    def self.set_argument_handler(schema_class, arg_class, handler)
+      @argument_handlers[schema_class][arg_class] = handler
+    end
+
+    def self.argument_hander(schema_class, argument)
+      handlers = {}
+      until schema_class == SchemaType do
+        handlers = (@argument_handlers[schema_class] || {}).merge(handlers)
+        schema_class = schema_class.superclass
+      end
+      result = handlers.find { |k, _| argument.is_a? k }
+      result && result.last
+    end
+
+    def compile
+      compiler = nil
+      schema_class = SchemaTypes[type]
+      until schema_class == SchemaType do
+        compiler ||= SchemaTypes.compilers[schema_class]
+        schema_class = schema_class.superclass
+      end
+      hash                = {}
+      hash['type']        = nullable ? ['null', type.to_s] : type.to_s
+      hash['definitions'] = definitions.compile unless definitions.empty?
+      hash['links']       = links.map &:compile unless links.empty?
+      hash.merge! data
+      dsl.evaluate compiler, hash if compiler
+      hash['enum'] |= [nil] if nullable && hash.key?('enum')
+      hash
+    end
+
+    def name
+      @name || (parent && parent.name)
+    end
+
+    def uri
+      domain.uri_for name
+    end
+
+    def definitions
+      @definitions ||= Definitions.new(self)
+    end
+
+    def links
+      @links ||= []
+    end
+
+    def data
+      @data ||= {}
+    end
+
+    def hyper?
+      links.any?
+    end
+
+    def schema_uri
+      hyper? ? JSON_HYPER_SCHEMA_URI : JSON_SCHEMA_URI
+    end
+
+    def to_h
+      {'$schema' => schema_uri}.tap do |h|
+        h['id'] = uri.to_s if name
+        h.merge! compile
+      end
+    end
+
+    def validate(data)
+      errors = JSON::Validator.fully_validate(JSON::Validator.schema_for_uri(uri).schema, data, errors_as_objects: true)
+      raise ValidationError.new(self, data, errors) unless errors.empty?
+    end
+
+    def initialize(type, parent)
+      @attrs  = {}
+      @type   = type
+      @domain = parent.domain
+      @dsl    = SchemaTypes.dsls[type].new(self)
+      @parent = parent if parent.is_a? self.class
+    end
+
+    def setup(*args, **locals, &block)
+      args.each do |arg|
+        case arg
+          when Symbol
+            dsl.__send__ arg
+          when Hash
+            arg.each { |k, v| dsl.__send__ k, v }
+          else
+            handler = Schema.argument_hander(SchemaTypes[type], arg)
+            raise "`#{type}` cannot handle arguments of type #{arg.class.name}" unless handler
+            dsl.evaluate handler, arg
+        end
+      end
+      if block
+        if dsl.respond_to? :with_locals
+          dsl.with_locals(locals) { dsl.evaluate block }
+        else
+          dsl.evaluate block
+        end
+      end
+    end
+
+  end
+end

data/lib/jimmy/schema_creation.rb

@@ -0,0 +1,121 @@
+module Jimmy
+  class SchemaCreation
+
+    @handlers = {}
+
+    class << self
+
+      attr_reader :handlers
+
+      def apply_to(klass, &handler)
+        @handlers[klass] = handler
+        %i(one all any).each do |condition|
+          klass.__send__ :define_method, :"#{condition}_of" do |*args, &inner_block|
+            Combination.new(condition, schema).tap do |combo|
+              combo.with_locals(locals) { combo.evaluate inner_block }
+              instance_exec combo, *args, &handler
+            end
+          end
+        end
+        klass.include DefiningMethods
+      end
+    end
+
+    module MetadataMethods
+      def set(**values)
+        values.each { |k, v| data[k.to_s] = v }
+      end
+
+      %i[title description default].each { |k| define_method(k) { |v| set k => v } }
+    end
+
+    module Referencing
+      def method_missing(name, *args, &block)
+        if schema.definitions[name]
+          ref *args, definition(name), &block
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, *)
+        schema.definitions.key?(name) || super
+      end
+
+      def definition(id)
+        "/#{schema.name}#/definitions/#{id}"
+      end
+
+      def ref(*args, uri, &block)
+        handler = SchemaCreation.handlers[self.class]
+        instance_exec(Reference.new(uri, domain, args.delete(:nullable), &block), *args, &handler) if handler
+      end
+    end
+
+    module DefiningMethods
+      include MetadataMethods
+
+      def locals
+        @locals ||= {}
+      end
+
+      def with_locals(**locals)
+        locals.each_key do |key|
+          raise "Local '#{key}' conflicts with an existing DSL method" if reserved? key
+        end
+        original = locals
+        @locals = original.merge(locals)
+        yield.tap { @locals = original }
+      end
+
+      def respond_to_missing?(method, *)
+        locals.key?(method) || reserved?(method, false) || super
+      end
+
+      def method_missing(method, *args, &block)
+        return locals[method] if locals.key?(method)
+
+        if SchemaTypes.key? method
+          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)
+            child_schema = Schema.new(
+                method,
+                respond_to?(:schema) ? schema : domain
+            )
+            child_schema.name = @schema_name if is_a? Domain
+            child_schema.setup *inner_args, **locals, &inner_block
+            instance_exec child_schema, *handler_args, &handler if handler
+            child_schema.dsl
+          end
+          return __send__ method, *args, &block
+        end
+
+        domain.autoload_type method
+
+        if domain.types.key? method
+          return instance_exec TypeReference.new(method, domain, args.include?(:nullable)), *args, &SchemaCreation.handlers[self.class]
+        end
+
+        if kind_of_array?(method)
+          return array(*args) { __send__ method[0..-7], &block }
+        end
+
+        super method, *args, &block
+      end
+
+      private
+
+      def reserved?(key, all = true)
+        domain.autoload_type key
+        (all && respond_to?(key)) || SchemaTypes.key?(key) || domain.types.key?(key) || kind_of_array?(key)
+      end
+
+      def kind_of_array?(key)
+        key =~ /^(\w+)_array$/ && reserved?($1.to_sym)
+      end
+
+    end
+
+  end
+end

data/lib/jimmy/schema_type.rb

@@ -0,0 +1,100 @@
+require 'forwardable'
+
+require_relative 'schema'
+
+module Jimmy
+  class SchemaType
+
+    class << self
+
+      def register!
+        SchemaTypes.register self
+      end
+
+      def trait(*args, &handler)
+        args.each do |name_or_type|
+          case name_or_type
+            when Symbol
+              handler ||= proc { |value| attrs[name_or_type] = value }
+              self::DSL.__send__ :define_method, name_or_type, handler
+            when Class
+              Schema.set_argument_handler self, name_or_type, handler
+            else
+              raise 'Trait must be a Symbol or a Class'
+          end
+        end
+      end
+
+      def nested(&handler)
+        SchemaTypes.nested_handlers[self] = handler
+      end
+
+      def compile(&handler)
+        SchemaTypes.compilers[self] = handler
+      end
+
+    end
+
+    class DSL
+      extend Forwardable
+      include SchemaCreation::Referencing
+      include SchemaCreation::MetadataMethods
+
+      attr_reader :schema
+
+      delegate %i(attrs domain) => :schema
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def evaluate(proc, *args)
+        instance_exec *args, &proc
+      end
+
+      def camelize_attrs(*args)
+        included_args = args.flatten.reject { |arg| attrs[arg].nil? }
+        included_args.map { |arg| [arg.to_s.gsub(/_([a-z])/) { $1.upcase }, attrs[arg]] }.to_h
+      end
+
+      def include(*partial_names, **locals)
+        partial_names.each do |name|
+          with_locals locals do
+            evaluate_partial domain.partials[name.to_s]
+          end
+        end
+      end
+
+      def definitions(&block)
+        schema.definitions.evaluate &block
+      end
+
+      def define(type, *args, &block)
+        definitions { __send__ type, *args, &block }
+      end
+
+      def data
+        schema.data
+      end
+
+      def link(rel_and_href, &block)
+        link = Link.new(schema, *rel_and_href.first)
+        schema.links << link
+        link.dsl.evaluate &block if block
+      end
+
+      def nullable
+        schema.nullable = true
+      end
+
+      private
+
+      # Minimize collisions with local scope (hence the weird name __args)
+      def evaluate_partial(__args)
+        instance_eval *__args
+      end
+
+    end
+
+  end
+end