lurker 0.6.4 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f19d765a42825a49246ece3cfe310a71ef07026
-  data.tar.gz: 04db573bb51da7ac28f3f55c5a85990e6bb6768b
+  metadata.gz: a7c38c4fffd08ae1bcd1b7505298b8b1aaa1a6d2
+  data.tar.gz: ed4335b7f4d6d483482d1690882a6ab3a0518c97
 SHA512:
-  metadata.gz: 4d203a0847bda1f56a2b8b39eda067d0d40f1ddde7bd27c5e800ae61f3000c7cae600c076d619bfc634c087c9f9e4480e6982c745c1f267c3689ec46d77671e7
-  data.tar.gz: 98af7ab781606392252390b6f7f74a844b56d1d61910acd2b6b2c180fbb06dc03ed43b03b6b2d34f59dec7c5cdcc681a0bc188d6235d662335d54f1aa75638d9
+  metadata.gz: f989bfea051dc26d3d52fc169b02fe3addcc9b36e8512f55ae3523bdbc162ffa155e36d4a801945cc1872c0e7533f21ef105b179d92bc8f0ccc7cb131b84fe41
+  data.tar.gz: d5efae11ebaaeb2e4d5af01008ff0f06f5154c30612f0f8dcabb41e103d2c6190ce6a8a0035b65a9fe6e6f6350790f75a96946665daa9379ee75b24304526a6b

data/features/dereferencing_through_inlining.feature

@@ -80,23 +80,23 @@ Feature: $ref defererencing through inlining
     Then the file "lurker/definitions/user_request_parameters.json" should contain exactly:
       """json
       {
-        "description": "",
-        "type": "object",
-        "additionalProperties": false,
-        "required": [
-
-        ],
         "properties": {
           "name": {
-            "description": "",
             "type": "string",
-            "example": "Bob"
+            "example": "Bob",
+            "description": ""
           },
           "surname": {
             "description": "",
             "type": "string",
             "example": "Marley"
           }
-        }
+        },
+        "description": "",
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+
+        ]
       }
       """

data/lib/lurker.rb

@@ -76,6 +76,7 @@ require 'lurker/json/schema'
 require 'lurker/json/schema/object'
 require 'lurker/json/schema/list'
 require 'lurker/json/schema/attribute'
+require 'lurker/json/schema/polymorph'
 require 'lurker/json/schema/tuple'
 require 'lurker/json/schema/tuple/all_of'
 require 'lurker/json/schema/tuple/any_of'

data/lib/lurker/json/parser.rb

@@ -15,6 +15,7 @@ module Lurker
         @root_schema = options[:root_schema]
         @parent_schema = options[:parent_schema]
         @parent_property = options[:parent_property]
+        @polymorph_if_empty = options.fetch(:polymorph_if_empty, false)
         @uri = options[:uri] || @parent_schema.try(:uri)
         @strategy = nil
       end
@@ -64,7 +65,7 @@ module Lurker
 
       def schema_options
         {
-          uri: @uri, root_schema: @root_schema,
+          uri: @uri, root_schema: @root_schema, polymorph_if_empty: @polymorph_if_empty,
           parent_schema: @parent_schema, parent_property: @parent_property
         }
       end

data/lib/lurker/json/parser/expertise.rb

@@ -4,6 +4,12 @@ module Lurker
       module Expertise
         module_function
 
+        def type_polymorph?(array_or_hash)
+          return false unless array_or_hash.is_a?(Hash) || array_or_hash.is_a?(Array)
+
+          array_or_hash.empty?
+        end
+
         def type_defined?(hash)
           return false unless hash.is_a?(Hash)
 

data/lib/lurker/json/parser/typed_strategy.rb

@@ -7,7 +7,10 @@ module Lurker
         attr_reader :schema_options
 
         def initialize(options)
-          @schema_options = options.dup
+          options = options.dup
+
+          @polymorph_if_empty = options.delete(:polymorph_if_empty)
+          @schema_options = options
         end
 
         def parse(payload)
@@ -17,9 +20,12 @@ module Lurker
           when Hash
             return create_by_type(payload) if type_defined?(payload)
             return create_by_supposition(payload) if type_supposed?(payload)
+            return create_polymorph(payload) if polymorph_if_empty? && type_polymorph?(payload)
 
             Lurker::Json::Object.new(payload, schema_options)
           when Array
+            return create_polymorph(payload) if polymorph_if_empty? && type_polymorph?(payload)
+
             Lurker::Json::List.new(payload, schema_options)
           else
             Lurker::Json::Attribute.new(payload, schema_options)
@@ -56,6 +62,14 @@ module Lurker
             Lurker::Json::Attribute.new(payload, schema_options)
           end
         end
+
+        def polymorph_if_empty?
+          @polymorph_if_empty
+        end
+
+        def create_polymorph(payload)
+          Lurker::Json::Polymorph.new(payload, schema_options)
+        end
       end
     end
   end

data/lib/lurker/json/schema.rb

@@ -107,7 +107,7 @@ module Lurker
           when RESPONSE_CODES
             Lurker::Json::ResponseCodes.new(property_schema, subschema_options)
           when REQUEST_PARAMETERS, RESPONSE_PARAMETERS
-            @parser.typed.parse_property(property, property_schema)
+            @parser.typed(polymorph_if_empty: true).parse_property(property, property_schema)
           else
             @parser.plain.parse_property(property, property_schema)
           end

data/lib/lurker/json/schema/attribute.rb

@@ -44,15 +44,22 @@ module Lurker
 
       private
 
+      def initialize_default_properties
+        @schema[Json::DESCRIPTION] ||= ''
+        @schema[Json::TYPE] ||= ''
+        @schema[Json::EXAMPLE] = '' if @schema[Json::EXAMPLE].nil?
+      end
+
       def parse_schema(schema)
         @schema = {}
-        initialize_properties
 
         if schema.is_a?(Hash)
           @schema.merge!(schema)
         else
           @schema = attributify(schema)
         end
+
+        initialize_default_properties
       end
 
       def attributify(schema)
@@ -71,12 +78,6 @@ module Lurker
         attribute
       end
 
-      def initialize_properties
-        @schema[Json::DESCRIPTION] ||= ''
-        @schema[Json::TYPE] ||= ''
-        @schema[Json::EXAMPLE] ||= ''
-      end
-
       def serialize_example(data)
         if data.is_a?(ActionDispatch::Http::UploadedFile)
           data.headers

data/lib/lurker/json/schema/list.rb

@@ -19,28 +19,35 @@ module Lurker
 
       private
 
+      def initialize_default_properties(empty_items = {})
+        @schema[Json::TYPE] ||= Json::ARRAY
+        @schema[Json::ITEMS] ||= polymorph_items(empty_items)
+      end
+
       def parse_schema(schema)
         @schema = {}
-        initialize_properties
+        schema.is_a?(Array) ? parse_array(schema.dup) : parse_hash(schema.dup)
+      end
 
+      def parse_array(schema)
+        initialize_default_properties([])
         return if schema.empty?
 
-        schema = schema.dup
-        if schema.is_a?(Array)
-          @schema[Json::ITEMS] = @parser.typed.parse(schema.shift)
+        @schema[Json::ITEMS] = @parser.typed.parse(schema.shift)
+        schema.each { |payload| @schema[Json::ITEMS].merge!(payload) }
+      end
 
-          schema.each { |payload| @schema[Json::ITEMS].merge!(payload) }
-        else
-          @schema[Json::ITEMS] = @parser.typed.parse(schema.delete Json::ITEMS) if schema.key?(Json::ITEMS)
-          @schema.merge!(schema)
-        end
+      def parse_hash(schema)
+        @schema.merge!(schema)
+        @schema[Json::ITEMS] = @parser.typed(polymorph_if_empty: true)
+          .parse(schema.delete(Json::ITEMS) || schema)
 
-        @schema
+        initialize_default_properties
       end
 
-      def initialize_properties
-        @schema[Json::TYPE] ||= Json::ARRAY
-        @schema[Json::ITEMS] ||= []
+      def polymorph_items(schema)
+        options = subschema_options.merge!(parent_property: Json::ITEMS)
+        Lurker::Json::Polymorph.new(schema, options)
       end
     end
   end

data/lib/lurker/json/schema/object.rb

@@ -3,8 +3,6 @@ module Lurker
     class Object < Schema
       def merge!(schema)
         unless schema.is_a?(Hash)
-          return replace_with_new_type(schema) if @schema[Json::PROPERTIES].blank?
-
           raise TypeError, "Unable to merge #{schema.class} into JSON object"
         end
 
@@ -25,35 +23,28 @@ module Lurker
 
       private
 
+      def initialize_default_properties
+        @schema[Json::DESCRIPTION] ||= ''
+        @schema[Json::TYPE] ||= Json::OBJECT
+        @schema[Json::ADDITIONAL_PROPERTIES] = !!@schema[Json::ADDITIONAL_PROPERTIES]
+        @schema[Json::REQUIRED] ||= []
+        @schema[Json::PROPERTIES] ||= {}
+      end
+
       def parse_schema(schema)
         @schema = {}
-        initialize_properties
 
         schema = schema.dup
-        merge_required = schema.key?(Json::PROPERTIES)
+        if schema.key?(Json::PROPERTIES)
+          @schema.merge!(schema)
+        end
+
+        initialize_default_properties
 
         (schema.delete(Json::PROPERTIES) || schema).each do |property, property_schema|
           @schema[Json::PROPERTIES][property] = @parser.typed.parse_property(
             property, property_schema)
         end
-
-        @schema.merge!(schema) if merge_required
-      end
-
-      def replace_with_new_type(schema)
-        replace_options = {root_schema: root_schema, parent_schema: parent_schema,
-                           parent_property: parent_property}
-
-        new_schema = Lurker::Json::Parser.typed(replace_options).parse(schema)
-        parent_schema.replace!(parent_property, new_schema)
-      end
-
-      def initialize_properties
-        @schema[Json::DESCRIPTION] ||= ''
-        @schema[Json::TYPE] ||= Json::OBJECT
-        @schema[Json::ADDITIONAL_PROPERTIES] = !!@schema[Json::ADDITIONAL_PROPERTIES]
-        @schema[Json::REQUIRED] ||= []
-        @schema[Json::PROPERTIES] ||= {}
       end
     end
   end

data/lib/lurker/json/schema/polymorph.rb

@@ -0,0 +1,54 @@
+module Lurker
+  module Json
+    class Polymorph < Schema
+      def merge!(schema)
+        case parent_schema
+        when Lurker::Json::Object
+          parent_schema[Json::PROPERTIES][parent_property] = @parser.typed.parse(schema)
+        when Lurker::Json::List
+          if schema.is_a?(Array)
+            return if schema.empty?
+
+            schema = schema.dup
+            parent_schema[Json::ITEMS] = @parser.typed.parse(schema.shift)
+            parent_schema.merge!(schema)
+          else
+            parent_schema[Json::ITEMS] = @parser.typed.parse(schema)
+          end
+        else
+          parent_schema[parent_property] = @parser.typed.parse(schema)
+        end
+      end
+
+      def replace!(property, schema)
+        morph = Lurker::Json::Object.new({}, subschema_options)
+
+        case parent_schema
+        when Lurker::Json::Object
+          parent_schema[Json::PROPERTIES][parent_property] = morph
+          parent_schema.replace!(property, schema)
+        when Lurker::Json::List
+          parent_schema[Json::ITEMS] = morph
+          parent_schema.replace!(property, schema)
+        else
+          parent_schema[parent_property] = morph
+          parent_schema.replace!(property, schema)
+        end
+      end
+
+      private
+
+      def parse_schema(schema)
+        @schema = schema
+      end
+
+      # NOTE : The parser will ref to parent_schema instead
+      def subschema_options
+        {uri: parent_schema.uri,
+         root_schema: parent_schema.root? ? parent_schema : parent_schema.root_schema,
+         parent_schema: parent_schema,
+         parent_property: parent_property}
+      end
+    end
+  end
+end

data/lib/lurker/version.rb

@@ -1,3 +1,3 @@
 module Lurker
-  VERSION = "0.6.4"
+  VERSION = "0.6.5"
 end

data/spec/lurker/json/attribute_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Lurker::Json::Attribute do
+  let(:klass) { described_class }
+
+  describe '#parse_schema' do
+    context 'when schema is boolean attribute' do
+      let(:attribute) do
+        klass.new(
+          'description' => '',
+          'type' => 'boolean',
+          'example' => false
+        )
+      end
+      let(:expected) do
+        {
+          'description' => '',
+          'type' => 'boolean',
+          'example' => false
+        }
+      end
+
+      it { expect(attribute.to_hash).to eq expected }
+    end
+
+    context 'when default attributes order are broken by user' do
+      let(:attribute) do
+        klass.new(
+          'example' => 'razum2um',
+          'description' => '',
+          'type' => 'string'
+        )
+      end
+      let(:expected) do
+        {
+          'example' => 'razum2um',
+          'description' => '',
+          'type' => 'string'
+        }.to_json
+      end
+
+      it { expect(attribute.to_json).to eq expected }
+    end
+  end
+end

data/spec/lurker/json/list_spec.rb

@@ -3,7 +3,146 @@ require 'spec_helper'
 describe Lurker::Json::List do
   let(:klass) { described_class }
 
+  describe '#parse_schema' do
+    context 'when schema is empty array' do
+      let(:list) { klass.new([]) }
+      let(:expected) do
+        {
+          'type' => 'array',
+          'items' => []
+        }
+      end
+
+      it { expect(list.to_hash).to eq expected }
+    end
+
+    context 'when schema is empty hash' do
+      let(:list) { klass.new({}) }
+      let(:expected) do
+        {
+          'type' => 'array',
+          'items' => {}
+        }
+      end
+
+      it { expect(list.to_hash).to eq expected }
+    end
+
+    context 'when default attributes order are broken by user' do
+      let(:list) { klass.new('items' => {}, 'type' => 'array') }
+      let(:expected) do
+        {
+          'items' => {},
+          'type' => 'array'
+        }.to_json
+      end
+
+      it { expect(list.to_json).to eq expected }
+    end
+  end
+
   describe '#merge!' do
+    context 'when list is not specify concrete type' do
+      let(:list) { klass.new([]) }
+
+      context 'when merge an array' do
+        let(:expected) do
+          {
+            'type' => 'array',
+            'items' => {
+              'description' => '',
+              'type' => 'integer',
+              'example' => 42
+            }
+          }
+        end
+        before { list.merge!([42]) }
+
+        it { expect(list.to_hash).to eq expected }
+      end
+
+      context 'when merge an array of different types' do
+        let(:expected) do
+          {
+            'type' => 'array',
+            'items' => {
+              'anyOf' => [
+                {
+                  'description' => '',
+                  'type' => 'integer',
+                  'example' => 42
+                },
+                {
+                  'description' => '',
+                  'type' => 'string',
+                  'example' => 'razum2um'
+                }
+              ]
+            }
+          }
+        end
+        before { list.merge!([42, 'razum2um']) }
+
+        it { expect(list.to_hash).to eq expected }
+      end
+
+      context 'when merge a fixnum' do
+        let(:expected) do
+          {
+            'type' => 'array',
+            'items' => {
+              'description' => '',
+              'type' => 'integer',
+              'example' => 999
+            }
+          }
+        end
+        before { list.merge!(999) }
+
+        it { expect(list.to_hash).to eq expected }
+      end
+
+      context 'when merge a string' do
+        let(:expected) do
+          {
+            'type' => 'array',
+            'items' => {
+              'description' => '',
+              'type' => 'string',
+              'example' => 'razum2um'
+            }
+          }
+        end
+        before { list.merge!('razum2um') }
+
+        it { expect(list.to_hash).to eq expected }
+      end
+
+      context 'when merge a hash' do
+        let(:expected) do
+          {
+            'type' => 'array',
+            'items' => {
+              'description' => '',
+              'type' => 'object',
+              'additionalProperties' => false,
+              'required' => [],
+              'properties' => {
+                'name' => {
+                  'description' => '',
+                  'type' => 'string',
+                  'example' => 'razum2um'
+                }
+              }
+            }
+          }
+        end
+        before { list.merge!('name' => 'razum2um') }
+
+        it { expect(list.to_hash).to eq expected }
+      end
+    end
+
     context 'when list is an array of attributes' do
       let(:list) { klass.new([1, 2, 3]) }
 

data/spec/lurker/json/object_spec.rb

@@ -3,7 +3,76 @@ require 'spec_helper'
 describe Lurker::Json::Object do
   let(:klass) { described_class }
 
+  describe '#parse_schema' do
+    context 'when schema is empty hash' do
+      let(:object) { klass.new({}) }
+      let(:expected) do
+        {
+          'description' => '',
+          'type' => 'object',
+          'additionalProperties' => false,
+          'required' => [],
+          'properties' => {}
+        }
+      end
+
+      it { expect(object.to_hash).to eq expected }
+    end
+
+    context 'when default attributes order are broken by user' do
+      let(:object) do
+        klass.new(
+          'type' => 'object',
+          'additionalProperties' => true,
+          'description' => '',
+          'properties' => {},
+          'required' => []
+        )
+      end
+      let(:expected) do
+        {
+          'type' => 'object',
+          'additionalProperties' => true,
+          'description' => '',
+          'properties' => {},
+          'required' => []
+        }.to_json
+      end
+
+      it { expect(object.to_json).to eq expected }
+    end
+  end
+
   describe '#merge!' do
+    context 'when merge a hash with properties containing empty hash' do
+      let(:object) { klass.new({}) }
+      let(:expected) do
+        {
+          'description' => '',
+          'type' => 'object',
+          'additionalProperties' => false,
+          'required' => [],
+          'properties' => {
+            'name' => {
+              'description' => '',
+              'type' => 'string',
+              'example' => 'razum2um'
+            },
+            'repo' => {
+              'description' => '',
+              'type' => 'object',
+              'additionalProperties' => false,
+              'required' => [],
+              'properties' => {}
+            }
+          }
+        }
+      end
+
+      before { object.merge!('name' => 'razum2um', 'repo' => {}) }
+
+      it { expect(object.to_hash).to eq expected }
+    end
     context 'when merge a hash with keywords' do
       let(:object) { klass.new('name' => 'razum2um') }
       let(:expected) do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lurker
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.6.5
 platform: ruby
 authors:
 - Vlad Bokov
@@ -30,7 +30,7 @@ cert_chain:
   vzKbYclpJ7gENr/xiTjGqA/Md3zJMzmsFrzUXt4RVmo5SaCyZjC6gFfhSr+PODc7
   ZaSbckvH/+m4boAsg0JkGGFcS3j5fgNmdwgA1A==
   -----END CERTIFICATE-----
-date: 2014-08-18 00:00:00.000000000 Z
+date: 2014-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -500,6 +500,7 @@ files:
 - lib/lurker/json/schema/extensions.rb
 - lib/lurker/json/schema/list.rb
 - lib/lurker/json/schema/object.rb
+- lib/lurker/json/schema/polymorph.rb
 - lib/lurker/json/schema/reference.rb
 - lib/lurker/json/schema/response_codes.rb
 - lib/lurker/json/schema/tuple.rb
@@ -574,6 +575,7 @@ files:
 - lib/lurker/version.rb
 - lurker.gemspec
 - spec/lurker/endpoint_spec.rb
+- spec/lurker/json/attribute_spec.rb
 - spec/lurker/json/list_spec.rb
 - spec/lurker/json/object_spec.rb
 - spec/lurker/json/schema_spec.rb
@@ -631,6 +633,7 @@ test_files:
 - features/support/files_helper.rb
 - features/test_endpoint.feature
 - spec/lurker/endpoint_spec.rb
+- spec/lurker/json/attribute_spec.rb
 - spec/lurker/json/list_spec.rb
 - spec/lurker/json/object_spec.rb
 - spec/lurker/json/schema_spec.rb
@@ -638,4 +641,3 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/matchers/json_attribute.rb
 - spec/support/matchers/json_object.rb
-has_rdoc: