jimmy 0.5.5 → 2.0.0

data/lib/jimmy/reference.rb

@@ -1,39 +0,0 @@
-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_creation.rb

@@ -1,121 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

data/lib/jimmy/schema_types.rb

@@ -1,42 +0,0 @@
-require 'forwardable'
-
-require_relative 'schema_type'
-require_relative 'schema_creation'
-
-module Jimmy
-  module SchemaTypes
-
-    @types = {}
-    @dsls = {}
-    @nested_handlers = {}
-    @compilers = {}
-
-    class << self
-      extend Forwardable
-
-      delegate %i[each keys values key?] => :@types
-
-      attr_reader :dsls, :nested_handlers, :compilers
-
-      def [](type_name)
-        @types[type_name]
-      end
-
-      def register(type_class)
-        type_name = type_class.name[/\w+$/].downcase.to_sym
-        dsl_class = Class.new(type_class.superclass::DSL)
-        type_class.const_set :DSL, dsl_class
-        @dsls[type_name] = dsl_class
-        @types[type_name] = type_class
-      end
-
-    end
-
-    Dir[ROOT + 'lib/jimmy/schema_types/*.rb'].each do |path|
-      require path
-    end
-
-    nested_handlers.each { |klass, handler| SchemaCreation.apply_to klass::DSL, &handler }
-
-  end
-end

data/lib/jimmy/schema_types/array.rb

@@ -1,30 +0,0 @@
-module Jimmy
-  class SchemaTypes::Array < SchemaType
-    register!
-
-    trait :min_items
-    trait :max_items
-    trait(:unique) { attrs[:unique_items] = true }
-    trait Range do |range|
-      min, max = [range.first, range.last].sort
-      min_items min
-      max_items max
-    end
-    trait(Integer) { |value| min_items value; max_items value }
-
-    nested do |schema|
-      (attrs[:items] ||= []) << schema
-    end
-
-    compile do |hash|
-      hash.merge! camelize_attrs(%i[min_items max_items unique_items])
-      items = attrs[:items] || []
-      if items.length > 1
-        hash['items'] = {'anyOf' => items.map(&:compile)}
-      elsif items.length == 1
-        hash['items'] = items.first.compile
-      end
-    end
-
-  end
-end

data/lib/jimmy/schema_types/boolean.rb

@@ -1,6 +0,0 @@
-module Jimmy
-  class SchemaTypes::Boolean < SchemaType
-    register!
-
-  end
-end

data/lib/jimmy/schema_types/integer.rb

@@ -1,8 +0,0 @@
-require_relative 'number'
-
-module Jimmy
-  class SchemaTypes::Integer < SchemaTypes::Number
-    register!
-
-  end
-end

data/lib/jimmy/schema_types/null.rb

@@ -1,6 +0,0 @@
-module Jimmy
-  class SchemaTypes::Null < SchemaType
-    register!
-
-  end
-end

data/lib/jimmy/schema_types/number.rb

@@ -1,34 +0,0 @@
-module Jimmy
-  class SchemaTypes::Number < SchemaType
-    register!
-
-    trait :multiple_of
-    trait :minimum
-    trait :maximum
-    trait(:<) { |value| maximum value; attrs[:exclusive_maximum] = true; self }
-    trait(:<=) { |value| maximum value; attrs[:exclusive_maximum] = nil; self }
-    trait(:>) { |value| minimum value; attrs[:exclusive_minimum] = true; self }
-    trait(:>=) { |value| minimum value; attrs[:exclusive_minimum] = nil; self }
-    trait(:enum) do |*values|
-      attrs[:enum] ||= []
-      attrs[:enum] |= values.flatten
-    end
-    trait(Numeric, Array) { |value| enum value }
-    trait(Range) do |range|
-      if range.first <= range.last
-        minimum range.first
-        maximum range.last
-        attrs[:exclusive_maximum] ||= range.exclude_end? || nil
-      else
-        minimum range.last
-        maximum range.first
-        attrs[:exclusive_minimum] ||= range.exclude_end? || nil
-      end
-    end
-
-    compile do |hash|
-      hash.merge! camelize_attrs(%i[minimum maximum exclusive_minimum exclusive_maximum multiple_of enum])
-    end
-
-  end
-end

data/lib/jimmy/schema_types/object.rb

@@ -1,45 +0,0 @@
-require_relative '../transform_keys'
-
-module Jimmy
-  class SchemaTypes::Object < SchemaType
-    register!
-
-    trait :require do |*required_keys|
-      if required_keys == [0]
-        attrs[:required] = SymbolArray.new
-      else
-        attrs[:required] ||= SymbolArray.new
-        attrs[:required] |= required_keys.flatten.map(&:to_s).uniq
-      end
-    end
-
-    trait :all do
-      SymbolArray.new(attrs[:properties].keys.select { |x| x.is_a? Symbol })
-    end
-
-    trait(:none) { 0 }
-
-    trait(:allow_additional) { attrs[:additional_properties] = true }
-
-    nested do |schema, property_name|
-      (attrs[:properties] ||= {})[TransformKeys.transformer.transform(property_name, domain.options[:transform_keys])] = schema
-    end
-
-    compile do |hash|
-      (attrs[:properties] || {}).each do |key, value|
-        collection, key =
-            if key.is_a? Regexp
-              ['patternProperties', key.inspect.gsub(%r`^/|/[a-z]*$`, '')]
-            else
-              ['properties', key.to_s]
-            end
-        hash[collection] ||= {}
-        hash[collection][key] = value.compile
-      end
-      required = attrs[:required]
-      hash['required'] = required.to_a if required && !required.empty?
-      hash['additionalProperties'] = !!attrs[:additional_properties]
-    end
-
-  end
-end

data/lib/jimmy/schema_types/string.rb

@@ -1,40 +0,0 @@
-module Jimmy
-  class SchemaTypes::String < SchemaType
-    register!
-
-    trait :min_length
-    trait :max_length
-    trait(:pattern) { |regex| attrs[:pattern] = regex.is_a?(Regexp) ? regex.inspect.gsub(%r`^/|/[a-z]*$`, '') : regex }
-    trait(:format) { |value| attrs[:format] = value.to_s.gsub('_', '-') }
-    %i[
-      date_time
-      email
-      hostname
-      ipv4
-      ipv6
-      uri
-    ].each { |k| trait(k) { format k } }
-    trait(:enum) do |*values|
-      attrs[:enum] ||= []
-      attrs[:enum] |= values.flatten.map(&:to_s)
-    end
-    trait(Regexp) { |regex| pattern regex }
-    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(Integer) { |value| min_length value; max_length value }
-    trait(Array) { |value| enum value }
-
-    compile do |hash|
-      hash.merge! camelize_attrs(%i[min_length max_length pattern enum format])
-    end
-
-  end
-end