lacerda 1.1.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c72c775cac5fa6c427773de8b002da68b01cead
-  data.tar.gz: 1b6adc7418567927bddd5ac87a7af26e859bd335
+  metadata.gz: 9e13fe3981ad5e7dc33070f0343f43745d032269
+  data.tar.gz: 527ce7ff8b9e0a89a5d4e0d1f8c50a506b9b4cb5
 SHA512:
-  metadata.gz: c0d3f4a41eb11d90c348d73f5295830461ee32c31f30cf14e84831acc453f99b0112081707abb4305c7aeda9a766947065e67eab60eeb2404185d116df3a39e6
-  data.tar.gz: aeace94ffb4d71e354124fd1d0a58b9563e8c55b8ad2baccf6a11559fa924980b9597c24930a335de42f6920c106c8adf189c5fc7f80d4c101b44ae7ecabc5a1
+  metadata.gz: 4ac94e6e2c6681138aa1dc83d6beb03d234ca0b8325e4c4aa5deb37967814ced69b38c866a77f98bbaed1051438a30a8ece9d59ae193d98740bc9a6b22ca515c
+  data.tar.gz: cc41f55260d38599b36e4403f567c9ba09483452d3890b99fa722f75211b638603631aa653ab9f328e0ea3c5f2e4ab937cc8f3a027ee2e136c8016a4ba512f57

data/CHANGELOG.markdown

@@ -1,3 +1,10 @@
+# 2.0.1
+- Merge (for real) add enum support to master
+
+# 2.0.0
+- [Breaking] Raise parsing errors, instead of silently returning an empty contract
+- Add enum support
+
 # 1.1.0
 - Update blumquist to show prettier errors
 

data/README.md

@@ -62,10 +62,10 @@ conversion ourselves. These features from the MSON specification are currently s
 - [x] primitive properties: `string`, `number`, `boolean`, `null`
 - [x] `object` properties
 - [x] `array` properties with items of one type
-- [ ] `array` properties of mixed types
+- [x] `array` properties of mixed types
 - [ ] `array` properties of arrays
-- [ ] `enum` properties
-- [ ] `One of` properties mutually exclusive properties
+- [x] `enum` properties
+- [x] `One of` properties mutually exclusive properties
 - [x] `Referencing`
 - [ ] `Mixins` 
 - [ ] Variable property names

data/lib/lacerda/conversion.rb

@@ -99,8 +99,8 @@ module Lacerda
       true
     end
 
-    def self.raise_parsing_errors(mson_file, ast_file)
-      parsing_errors = ast_parsing_errors(ast_file)
+    def self.raise_parsing_errors(mson_file, elements)
+      parsing_errors = ast_parsing_errors(elements)
       return if parsing_errors.empty? 
       raise Error, parsing_errors.prepend("The following errors were found in #{mson_file}:").join("\n")
     end
@@ -122,6 +122,8 @@ module Lacerda
       # The content of the ast parsing
       elements = parse_result_contents_from_ast_file(filename)
 
+      raise_parsing_errors(filename, elements)
+
       # We keep the content of the categories only, they could be annotations otherwise
       result_categories = elements.select do |element|
         element['element'] == 'category'
@@ -141,12 +143,10 @@ module Lacerda
       end
     end
 
-    def self.ast_parsing_annotation_messages(filename, type)
-      annotations = annotations_from_blueprint_ast(filename).select do |annotation|
-        annotation['meta']['classes'].include?(type)
-      end
-      return [] if annotations.empty?
-      annotations.map do |annotation|
+    def self.ast_parsing_annotation_messages(elements, type)
+      elements.select do |element|
+        element['element'] == 'annotation' && element['meta']['classes'].include?(type)
+      end.map do |annotation|
         "#{type.capitalize} code #{annotation['attributes']['code']}: #{annotation['content']}"
       end
     end
@@ -176,10 +176,5 @@ module Lacerda
       json = JSON.parse(open(filename).read)
       json&.dig('content') || []
     end
-
-    private_class_method def self.annotations_from_blueprint_ast(filename)
-      elements = parse_result_contents_from_ast_file(filename)
-      elements.select { |element| element['element'] == 'annotation' }
-    end
   end
 end

data/lib/lacerda/conversion/apiary_to_json_schema.rb

@@ -1,4 +1,6 @@
 require 'lacerda/conversion/data_structure'
+require 'lacerda/conversion/data_structure/member'
+require 'lacerda/conversion/data_structure/member/type'
 
 module Lacerda
   module Conversion

data/lib/lacerda/conversion/data_structure.rb

@@ -53,112 +53,16 @@ module Lacerda
       end
 
       def add_properties_to_json_schema
-        possible_members  = @data&.first&.dig('content')
-        return unless possible_members
-        # In the case that you create a nested data structure when type == 'object', 
-        # the possible_members can be just a Hash, instead of an array
-        possible_members = [possible_members] if possible_members.is_a?(Hash)
-        members = possible_members.select { |d| d['element'] == 'member' }
+        members = Member.from_data_structure_content(@data&.first&.dig('content'), @scope)
         # Iterate over each property
-        members.each do |s|
-
-          # Pluck some things out of the AST
-          content = s['content']
-          type_definition = content['value']
-          type = type_definition['element']
-          attributes = s.dig('attributes', 'typeAttributes') || []
-          is_required = attributes.include?('required')
-
-          # Prepare the json schema fragment
-          spec = {}
-          name = Lacerda.underscore(content['key']['content'])
-
-          # This is either type: primimtive or a oneOf { $ref: reference_name }
-          spec.merge!(primitive_or_oneOf(type, is_required))
-
-          # We might have a description
-          spec['description'] = s.dig('meta', 'description')
-
-          # If it's an array, we need to pluck out the item types
-          if type == 'array'
-            nestedTypes = type_definition['content'].map{|vc| vc['element'] }.uniq
-            spec['items'] = array_items(nestedTypes)
-
-          # If it's an object, we need recursion
-          elsif type == 'object'
-            spec['properties'] = {}
-            # The object has a value that will represent a data structure. the data
-            # passed to DataStructure normally is an array, but in this case if wouldn't
-            # So we have to wrap it if it's not an Array.
-            data = [content['value']] unless content['value'].is_a?(Array)
-            data_structure = DataStructure.new('tmp', [content['value']], @scope).to_json
-            spec['properties'].merge!(data_structure['properties'])
-          end
-
+        members.each do |member|
           # Add the specification of this property to the schema
-          @schema['properties'][name] = spec
-
+          @schema['properties'][member.name] = member.spec
           # Mark the property as required
-          @schema['required'] << name if is_required
-        end
-      end
-
-      # returns the type of an array, given its specified type(s). This will be
-      # either exactly one basic type, or a oneOf in case there are 1+ types 
-      # or exactly 1 non-basic type. 
-      # As there are specied types in the array, `nil` should not be a valid value
-      # and therefore required should be true.
-      def array_items(types)
-        if types.size == 1 && PRIMITIVES.include?(types.first)
-          primitive(types.first, true) 
-        else
-          oneOf(types, true)
-        end
-      end
-
-      def primitive_or_oneOf(type, is_required)
-      	return { 'type' => 'object' } if type.blank?
-        if PRIMITIVES.include?(type)
-          primitive(type, is_required)
-        else
-          oneOf([type], is_required)
-        end
-      end
-
-      # A basic type is either a primitive type with exactly 1 primitive type
-      #   {'type' => [boolean] }
-      # a reference
-      #   { '$ref' => "#/definitions/name" }
-      # or an object if the type in not there
-      #   { 'type' => object }
-      # Basic types don't care about being required or not.
-      def basic_type(type)
-        return { 'type' => 'object' } if type.blank?
-        if PRIMITIVES.include?(type)
-          primitive(type, true)
-        else
-          reference(type)
+          @schema['required'] << member.name if member.required?
         end
       end
 
-      def oneOf(types, is_required)
-        types = types.map { |type| basic_type(type) }
-        types << { 'type' => 'null' } unless is_required
-        {
-          'oneOf' => types.uniq
-        }
-      end
-
-      def primitive(type, is_required) 
-        types = [type]
-        types << 'null' unless is_required
-        { 'type' => types }
-      end
-
-      def reference(type)
-        {'$ref' => "#/definitions/#{self.class.scope(@scope, type)}" }
-      end
-
       def json_schema_blueprint
         {
           "type" => "object",
@@ -166,7 +70,6 @@ module Lacerda
           "required" => []
         }
       end
-
     end
   end
 end

data/lib/lacerda/conversion/data_structure/member.rb

@@ -0,0 +1,53 @@
+# Represents a DataStructure AST member and 
+# helps transforming it into a json schema.
+module Lacerda
+  module Conversion
+    class DataStructure
+      class Member
+        attr_reader :name
+
+        def self.from_data_structure_content(data_structure_content, scope)
+          return [] if data_structure_content.nil?
+          # In the case that you create a nested data structure when type == 'object', 
+          # the possible_members can be just a Hash, instead of an array
+          if data_structure_content.is_a?(Hash)
+            data_structure_content = [data_structure_content] 
+          end
+          members = data_structure_content.select do |d|
+            d['element'] == 'member'
+          end
+          members.map { |member| Member.new(member, scope) }
+        end
+
+        def initialize(member, scope)
+          @description = member.dig('meta', 'description')
+          @content = member['content']
+          @name = Lacerda.underscore(@content['key']['content'])
+          @attributes = member.dig('attributes', 'typeAttributes') || []
+          @is_required = @attributes.include?('required')
+          @type = Type.new(@content['value'], @is_required, @scope)
+          @scope = scope
+        end
+
+        def required?
+          @is_required
+        end
+
+        def spec
+            spec = {}
+            # We might have a description
+            spec['description'] = @description
+            spec.merge!(@type.to_hash)
+            # Add the type of the array objects (if it is an array)
+            spec['items'] = @type.array_type
+              # If it's an object, we need recursion
+            if @type.object?
+              data_structure = DataStructure.new('tmp', [@content['value']], @scope).to_json
+              spec['properties'] = data_structure['properties']
+            end
+            spec
+        end
+      end
+    end
+  end
+end

data/lib/lacerda/conversion/data_structure/member/type.rb

@@ -0,0 +1,100 @@
+module Lacerda
+  module Conversion
+    class DataStructure
+      class Member
+        class Type
+          def initialize(type_definition, is_required, scope)
+            @type_definition = type_definition
+            @scope = scope
+            @type_name = type_definition['element']
+            @is_required = is_required
+          end
+
+          def object?
+            @type_name == 'object'
+          end
+
+          # A type is transformed to json schema either as a primitive:
+          #     { "type" => ["string"] }
+          #     { "type" => ["string", "null"] }
+          # Or as a oneOf. $ref are always within a oneOf
+          #     {"oneOf"=>[{"$ref"=>"#/definitions/tag"}, {"type"=>"null"}]}
+          def to_hash
+            if PRIMITIVES.include?(@type_name)
+              primitive(@type_name, required?)
+            else
+              oneOf([@type_name], required?)
+            end
+          end
+
+          # bui
+          # As there are specied types in the array, `nil` should not be a valid value
+          # and therefore required should be true.
+          def array_type
+            return unless array?
+            if nested_types.size == 1 && PRIMITIVES.include?(nested_types.first)
+              primitive(nested_types.first, true) 
+            else
+              oneOf(nested_types, true)
+            end
+          end
+
+          private
+
+          def array?
+            @type_name == 'array'
+          end
+
+          # A basic type is either a primitive type with exactly 1 primitive type
+          #   {'type' => [boolean] }
+          # a reference
+          #   { '$ref' => "#/definitions/name" }
+          # or an object if the type in not there
+          #   { 'type' => object }
+          # Basic types don't care about being required or not.
+          def basic_type(type_name, is_required = required?)
+            if PRIMITIVES.include?(type_name)
+              primitive(type_name, is_required)
+            else
+              reference(type_name)
+            end
+          end
+
+          def oneOf(types, is_required)
+            types = types.map { |type_name| basic_type(type_name,is_required) }
+            types << { 'type' => 'null' } unless is_required
+            {
+              'oneOf' => types.uniq
+            }
+          end
+
+          def reference(type_name)
+            {'$ref' => "#/definitions/#{Lacerda::Conversion::DataStructure.scope(@scope, type_name)}" }
+          end
+
+          def primitive(type_name, is_required) 
+            types = [type_name]
+            types << 'null' unless is_required
+            if type_name == 'enum'
+              enum_values = @type_definition['content'].map { |i| i['content'] }
+              { 'type' => types, 'enum' => enum_values }
+            else
+              { 'type' => types }
+            end
+          end
+
+          def required?
+            @is_required
+          end
+
+          def nested_types
+            error_msg = "This DataStructure::Member is a #{@type_name}, not "\
+              'an array, so it cannot have nested types'
+            raise error_msg unless array?
+            @type_definition['content'].map{|vc| vc['element'] }.uniq
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lacerda/version.rb

@@ -1,3 +1,3 @@
 module Lacerda
-  VERSION = '1.1.0'
+  VERSION = '2.0.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lacerda
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Jannis Hermanns
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-18 00:00:00.000000000 Z
+date: 2017-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -252,6 +252,8 @@ files:
 - lib/lacerda/conversion.rb
 - lib/lacerda/conversion/apiary_to_json_schema.rb
 - lib/lacerda/conversion/data_structure.rb
+- lib/lacerda/conversion/data_structure/member.rb
+- lib/lacerda/conversion/data_structure/member/type.rb
 - lib/lacerda/conversion/error.rb
 - lib/lacerda/infrastructure.rb
 - lib/lacerda/object_description.rb