lacerda 0.12.5 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb103cbaef02d7242cb5e6fca4394709496aa9b4
-  data.tar.gz: 133a8e88e4f034ddf4b1026355e240010a3f687c
+  metadata.gz: cf9cdcab9b0b20b1febda478e06f431a48250ec8
+  data.tar.gz: 12499578a02c7c5e57c6393d93312a3a21284e9d
 SHA512:
-  metadata.gz: 3fa4c39961f7ffc8f39011661fbd2096e994c01e9a072e0a45c56bade9341fa90d725bd60adc41a78b986672eb0cab157fd6339b4d62f7469b590c1ed22b5ef3
-  data.tar.gz: 31b516bbad9d48abf2e61decb50f719a1faf46da940431369ba297f50adcc345be21e0dfdadab5823593f8c157e837a29f7e07412367c8649cc60cc903fd65f0
+  metadata.gz: fbcffea2beb291540f0fe39203f1e50fabbe76ba8ec1021e98b39dd335224dfd9accf4a2457fd49403b63371a99caf945ef6d5ba86c03fda3438093ff9c4dec9
+  data.tar.gz: f0e514af65dea7e6b16ea849ff0bfc3d1539eeb1a79fbf943142749829c01d32806fbb228adad90803c384e6737995021bb9437da60b63f274a099712aabd16c

data/CHANGELOG.markdown

@@ -1,3 +1,7 @@
+# 0.13.0
+- enhance some error messages (invalid object types)
+- make non required properties nullable https://github.com/moviepilot/lacerda/pull/21
+
 # 0.12.5
 - fix https://github.com/moviepilot/zeta/issues/18 (infinite loops
   for some cases where json pointers are used)

data/lacerda.gemspec

@@ -21,8 +21,11 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "activesupport"
   spec.add_runtime_dependency "rake",          ["~> 10.2"]
-  spec.add_runtime_dependency "json-schema",   ["~> 2.5"]
-  spec.add_runtime_dependency "redsnow",       ["~> 0.4"]
+
+  # json-schema 2.6.0 validates differently than 2.5.1
+  spec.add_runtime_dependency "json-schema",   ["~> 2.5.1"]
+
+  spec.add_runtime_dependency "redsnow",       ["~> 0.4.3"]
   spec.add_runtime_dependency "colorize"
   spec.add_runtime_dependency "blumquist",     ["~> 0.3"]
 
@@ -37,6 +40,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "coveralls",           ["~> 0.8"]
   spec.add_development_dependency "codeclimate-test-reporter"
   spec.add_development_dependency 'pry'
-  spec.add_development_dependency 'pry-rescue'
-  spec.add_development_dependency 'pry-stack_explorer'
+  # spec.add_development_dependency 'pry-byebug'
+  # spec.add_development_dependency 'pry-rescue'
+  # spec.add_development_dependency 'pry-stack_explorer'
 end

data/lib/lacerda/compare/json_schema.rb

@@ -25,36 +25,10 @@ module Lacerda
         properties_contained?
       end
 
-      private
-
-      def properties_contained?
-        @contained_schema['properties'].each do |property, contained_property|
-          resolved_contained_property = data_for_pointer(property, @contained_schema)
-          containing_property = @containing_schema['properties'][property]
-          if !containing_property
-            _e(:ERR_MISSING_DEFINITION, [@initial_location, property]) 
-          else
-            resolved_containing_property = data_for_pointer(
-              containing_property,
-              @containing_schema
-            )
-            schema_contains?(
-              resolved_containing_property,
-              resolved_contained_property,
-              [property]
-            )
-          end
-        end
-        @errors.empty?
-      end
-
-      def _e(error, location, extra = nil)
-        message = [ERRORS[error], extra].compact.join(": ")
-        @errors.push(error: error, message: message, location: location.compact.join("/"))
-        false
-      end
-
-      def schema_contains?(publish, consume, location = [])
+      def schema_contains?(options)
+        publish      = options[:publish]
+        consume      = options[:consume]
+        location     = options[:location] || []
 
         # We can only compare types and $refs, so let's make
         # sure they're there
@@ -76,31 +50,33 @@ module Lacerda
         # Let's go:
 
         # 1)
-        if (consume['type'] and publish['type'])
-          if consume['type'] != publish['type']
-            return _e(:ERR_TYPE_MISMATCH, location, "#{consume['type']} != #{publish['type']}")
+        if consume['type'] and publish['type']
+          consume_types = ([consume['type']].flatten - ["null"]).sort
+          publish_types = [publish['type']].flatten.sort
+          if consume_types != publish_types
+            return _e(:ERR_TYPE_MISMATCH, location, "Consume types #{consume_types.to_json} not compatible with publish types #{publish_types.to_json}")
           end
 
         # 2)
-        elsif(consume['$ref'] and publish['$ref'])
+        elsif consume['$ref'] and publish['$ref']
          resolved_consume = resolve_pointer(consume['$ref'], @contained_schema)
          resolved_publish = resolve_pointer(publish['$ref'], @containing_schema)
 
          return _e(:ERR_MISSING_POINTER, location, consume['$ref']) unless resolved_consume
          return _e(:ERR_MISSING_POINTER, location, publish['$ref']) unless resolved_publish
-         return schema_contains?(resolved_publish, resolved_consume, location)
+         return schema_contains?(publish: resolved_publish, consume: resolved_consume, location: location)
 
         # 3)
-        elsif(consume['type'] and publish['$ref'])
+        elsif consume['type'] and publish['$ref']
           if resolved_ref = resolve_pointer(publish['$ref'], @containing_schema)
-            return schema_contains?(resolved_ref, consume, location)
+            return schema_contains?(publish: resolved_ref, consume: consume, location: location)
           else
             return _e(:ERR_MISSING_POINTER, location, publish['$ref'])
           end
 
         # 4)
-        elsif(consume['$ref'] and publish['type'])
-          return _e(:ERR_NOT_SUPPORTED, location)
+        elsif consume['$ref'] and publish['type']
+          return _e(:ERR_NOT_SUPPORTED, location, nil)
         end
 
         # Make sure required properties in consume are required in publish
@@ -111,24 +87,126 @@ module Lacerda
 
         # We already know that publish and consume's type are equal
         # but if they're objects, we need to do some recursion
-        if consume['type'] == 'object'
-          consume['properties'].each do |property, schema|
-            return _e(:ERR_MISSING_PROPERTY, location, property) unless publish['properties'][property]
-            return false unless schema_contains?(publish['properties'][property], schema, location + [property])
+        if [consume['type']].flatten.include?('object')
+
+          # An object can either be described by its properties
+          # like this:
+          #
+          # (1) { "type": "object", "properties": { "active": { "type": "boolean" } }
+          #
+          # or by allowing a bunch of other types like this:
+          #
+          # (2) { "type": "object", "oneOf": [ {"$ref": "#/definitions/foo"}, {"type": "null"} ]
+          #
+          # So we need to take care of both cases for both "sides"
+          # (publish and consume), so 4 cases in total.
+          #
+          # First, the easy case:
+          if consume['properties'] and publish['properties']
+            consume['properties'].each do |property, schema|
+              return _e(:ERR_MISSING_PROPERTY, location, property) unless publish['properties'][property]
+              return false unless schema_contains?(publish: publish['properties'][property], consume: schema, location: location + [property])
+            end
+
+          # Now on to the trickier case, both have 'oneOf's:
+          #
+          # For each possible object type from the publish schema we have
+          # to check if we find a compatible type in the consume schema.
+          #
+          # It's not sufficient to just compare the names of the objects,
+          # because they might be different in the publish and consume
+          # schemas.
+          elsif publish['oneOf'] and consume['oneOf']
+            publish_types = publish['oneOf']
+            consume_types = [consume['oneOf']].flatten.compact
+
+            # Check all publish types for a compatible consume type
+            publish_types.each do |publish_type|
+              original_errors = @errors
+              @errors = []
+              compatible_consume_type_found = false
+              consume_types.each do |consume_type|
+                next unless publish_type == consume_type or # Because null types are stripped in schema_contains
+                            schema_contains?(publish: publish_type, consume: consume_type, location: location + [publish_type])
+                compatible_consume_type_found = true
+              end
+              @errors = original_errors
+              return _e(:ERR_MISSING_MULTI_PUBLISH_MULTI_CONSUME, location, publish_type) unless compatible_consume_type_found
+            end
+
+          # Mixed case 1/2:
+          elsif consume['oneOf'] and publish['properties']
+            consume_types = ([consume['oneOf']].flatten - [{"type" => "null"}]).sort
+            compatible_consume_type_found = false
+            original_errors = @errors
+            @errors = []
+            consume_types.each do |consume_type|
+              next unless schema_contains?(publish: publish, consume: consume_type, location: location)
+              compatible_consume_type_found = true
+            end
+            @errors = original_errors
+            return _e(:ERR_MISSING_SINGLE_PUBLISH_MULTI_CONSUME, location, publish['type']) unless compatible_consume_type_found
+
+          # Mixed case 2/2:
+          elsif consume['properties'] and publish['oneOf']
+            publish_types = ([publish['oneOf']].flatten - [{"type" => "null"}]).sort
+            incompatible_publish_type= nil
+            original_errors = @errors
+            @errors = []
+            publish_types.each do |publish_type|
+              next if schema_contains?(publish: publish_type, consume: consume, location: location)
+              incompatible_publish_type = publish_type
+            end
+            @errors = original_errors
+            return _e(:ERR_MISSING_MULTI_PUBLISH_SINGLE_CONSUME, location, incompatible_publish_type) if incompatible_publish_type
+
+          # We don't know how to handle this 😳
+          # an object can either have "properties" or "oneOf", if the schema has anything else, we break
+          else
+            return _e(:ERR_NOT_SUPPORTED, location, "Consume schema didn't have properties defined and publish schema no oneOf")
           end
         end
 
         if consume['type'] == 'array'
           sorted_publish = publish['items'].sort
           consume['items'].sort.each_with_index do |item, i|
-            next if schema_contains?(sorted_publish[i], item)
-            return _e(:ERR_ARRAY_ITEM_MISMATCH, location)
+            next if schema_contains?(publish: sorted_publish[i], consume: item)
+            return _e(:ERR_ARRAY_ITEM_MISMATCH, location, nil)
           end
         end
 
         true
       end
 
+      private
+
+      def properties_contained?
+        @contained_schema['properties'].each do |property, contained_property|
+          resolved_contained_property = data_for_pointer(property, @contained_schema)
+          containing_property = @containing_schema['properties'][property]
+          if !containing_property
+            _e(:ERR_MISSING_DEFINITION, [@initial_location, property], "(in publish.mson)")
+          else
+            resolved_containing_property = data_for_pointer(
+              containing_property,
+              @containing_schema
+            )
+            schema_contains?(
+              publish: resolved_containing_property,
+              consume: resolved_contained_property,
+              location: [property]
+            )
+          end
+        end
+        @errors.empty?
+      end
+
+      def _e(error, location, extra = nil)
+        message = [ERRORS[error], extra].compact.join(": ")
+        @errors.push(error: error, message: message, location: location.compact.join("/"))
+        false
+      end
+
       # Resolve pointer data idempotent(ally?). It will resolve
       #
       #     "foobar"

data/lib/lacerda/consume_specification.rb

@@ -56,7 +56,7 @@ module Lacerda
       # or else the json validator gem will go into an endless loop
       object_schema =schema_dup['definitions'].delete underscored_name.to_s
 
-      raise Lacerda::Service::InvalidObjectTypeError.new("Invalid object type: #{underscored_name.to_s.to_json}") unless object_schema
+      raise Lacerda::Service::InvalidObjectTypeError.new("Unknown object type: #{underscored_name.to_s.to_json} - did you specify it in consume.mson?") unless object_schema
 
       # Copy the definitions of our schema into the schema for the
       # object in case its properties include json pointers

data/lib/lacerda/conversion/data_structure.rb

@@ -57,16 +57,23 @@ module Lacerda
         return unless @data['sections']
         return unless @data['sections'].length > 0
         members = @data['sections'].select{|d| d['class'] == 'memberType' }.first['content'].select{|d| d['class'] == 'property' }
+
+        # Iterate over each property
         members.each do |s|
+
+          # Pluck some things out of the AST
           content = s['content']
           type_definition = content['valueDefinition']['typeDefinition']
           type = type_definition['typeSpecification']['name']
+          attributes = type_definition['attributes'] || []
+          is_required = attributes.include?('required')
 
+          # Prepare the json schema fragment
           spec = {}
           name = Lacerda.underscore(content['name']['literal'])
 
           # This is either type: primimtive or $ref: reference_name
-          spec.merge!(primitive_or_reference(type))
+          spec.merge!(primitive_or_reference(type, is_required))
 
           # We might have a description
           spec['description'] = content['description']
@@ -74,7 +81,7 @@ module Lacerda
           # If it's an array, we need to pluck out the item types
           if type == 'array'
             nestedTypes = type_definition['typeSpecification']['nestedTypes']
-            spec['items'] = nestedTypes.map{|t| primitive_or_reference(t) }
+            spec['items'] = nestedTypes.map{|t| primitive_or_reference(t, is_required) }
 
           # If it's an object, we need recursion
           elsif type == 'object'
@@ -85,20 +92,28 @@ module Lacerda
             end
           end
 
+          # Add the specification of this property to the schema
           @schema['properties'][name] = spec
-          if attributes = type_definition['attributes']
-            @schema['required'] << name if attributes.include?('required')
-          end
+
+          # Mark the property as required
+          @schema['required'] << name if is_required
         end
       end
 
-      def primitive_or_reference(type)
-	return { 'type' => 'object' } if type.blank?
+      def primitive_or_reference(type, is_required)
+      	return { 'type' => 'object' } if type.blank?
 
         if PRIMITIVES.include?(type)
-          { 'type' => type }
+          types = [type]
+          types << 'null' unless is_required
+          { 'type' => types }
         else
-          { '$ref' => "#/definitions/#{self.class.scope(@scope, type['literal'])}" }
+          types = [{'$ref' => "#/definitions/#{self.class.scope(@scope, type['literal'])}" }]
+          types << { 'type' => 'null' } unless is_required
+          {
+            'type' => 'object',
+            'oneOf' => types
+          }
         end
       end
 

data/lib/lacerda/publish_specification.rb

@@ -32,7 +32,11 @@ module Lacerda
       # It's critical to delete this object from the definitions
       # or else the json validator gem will go into an endless loop
       object_schema = schema_dup['definitions'].delete scoped_name.to_s
-      raise Lacerda::Service::InvalidObjectTypeError.new(scoped_name) unless object_schema
+
+      unless object_schema
+        msg = "Unknown object type: #{scoped_name.to_s.to_json} - did you specify it in publish.mson?"
+        raise Lacerda::Service::InvalidObjectTypeError.new(msg)
+      end
 
       # Copy the definitions of our schema into the schema for the
       # object in case its properties include json pointers

data/lib/lacerda/version.rb

@@ -1,3 +1,3 @@
 module Lacerda
-  VERSION = '0.12.5'
+  VERSION = '0.13.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lacerda
 version: !ruby/object:Gem::Version
-  version: 0.12.5
+  version: 0.13.0
 platform: ruby
 authors:
 - Jannis Hermanns
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-09 00:00:00.000000000 Z
+date: 2016-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -44,28 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: 2.5.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: 2.5.1
 - !ruby/object:Gem::Dependency
   name: redsnow
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.4.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.4.3
 - !ruby/object:Gem::Dependency
   name: colorize
   requirement: !ruby/object:Gem::Requirement
@@ -220,34 +220,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry-rescue
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry-stack_explorer
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Specify which objects your services publish or consume in MSON (markdown)
   and let this gem validate these contracts.
 email: