Optional parameters implementation

Added implementation to obtain the parameters optional value

* Added optional value accessors
* Added optional parameter in documentation

Author: josebauzan

lib/angus/definitions/representation_field.rb

@@ -1,7 +1,6 @@
 module Angus
   module SDoc
     class Definitions::RepresentationField
-
       # @!attribute [rw] name
       #   @return [String] the name of the representation field.
       attr_accessor :name
@@ -24,15 +23,21 @@ class Definitions::RepresentationField
       #     This attribute is used when the representation is a list of objects.
       attr_accessor :elements_type
 
+      # @!attribute [rw] optional
+      #   @return [Boolean] true if the element is optional
+      attr_accessor :optional
+
       # @note if the elements_type attribute is different from nil, it means that the
       #   representation field is a list of objects. In that case, the type parameter
       #   is not considered.
-      def initialize(name = nil, description = nil, required = nil, type = nil, elements_type = nil)
-        self.name= name
-        self.description= description
-        self.required= required
-        self.type= type
-        self.elements_type= elements_type
+      def initialize(name = nil, description = nil, required = nil, type = nil, elements_type = nil,
+                     optional = nil)
+        self.name = name
+        self.description = description
+        self.required = required
+        self.type = type
+        self.elements_type = elements_type
+        self.optional = optional
       end
 
       # Check if an object is equals to the current instance.
@@ -42,10 +47,10 @@ def initialize(name = nil, description = nil, required = nil, type = nil, elemen
       # @return [Boolean] true if all the attributes are equal and false otherwise.
       def ==(other)
         other.kind_of?(Definitions::RepresentationField) &&
-          self.name == other.name && self.description == other.description &&
-          self.required == other.required && self.type == other.type && self.elements_type == other.elements_type
+          name == other.name && description == other.description &&
+          required == other.required && type == other.type &&
+          elements_type == other.elements_type && optional == other.optional
       end
-
     end
   end
 end

lib/angus/definitions/request_element.rb

@@ -30,16 +30,21 @@ class Definitions::RequestElement
       #   @return [String] the elements type of the request element.
       attr_accessor :elements_type
 
+      # @!attribute [rw] optional
+      #   @return [Boolean] true if the element is optional
+      attr_accessor :optional
+
 
       def initialize(name = nil, description = nil, required = nil, type = nil,
-                     constraints = nil, valid_values = nil, elements_type = nil)
-        self.name= name if name
-        self.description= description if description
-        self.required= required if required
-        self.type= type if type
-        self.constraints= constraints if constraints
-        self.valid_values= valid_values if valid_values
-        self.elements_type= elements_type if elements_type
+                     constraints = nil, valid_values = nil, elements_type = nil, optional = nil)
+        self.name = name if name
+        self.description = description if description
+        self.required = required if required
+        self.type = type if type
+        self.constraints = constraints if constraints
+        self.valid_values = valid_values if valid_values
+        self.elements_type = elements_type if elements_type
+        self.optional = optional if optional
       end
 
       # Check if an object is equals to the current instance.
@@ -49,13 +54,12 @@ def initialize(name = nil, description = nil, required = nil, type = nil,
       # @return [Boolean] true if all the attributes are equal and false otherwise.
       def ==(other)
         other.instance_of?(Definitions::RequestElement) &&
-          self.name == other.name && self.description == other.description &&
-          self.required == other.required && self.type == other.type &&
-          self.constraints == other.constraints &&
-          self.valid_values == other.valid_values &&
-          self.elements_type == other.elements_type
+          name == other.name && description == other.description &&
+          required == other.required && type == other.type &&
+          constraints == other.constraints &&
+          valid_values == other.valid_values &&
+          elements_type == other.elements_type && optional == other.optional
       end
-
     end
   end
 end

lib/angus/definitions/response_element.rb

@@ -1,7 +1,6 @@
 module Angus
   module SDoc
     class Definitions::ResponseElement
-
       # @!attribute [rw] name
       #   @return [String] the name of the response element.
       attr_accessor :name
@@ -26,16 +25,20 @@ class Definitions::ResponseElement
       #   @return [String] the elements type of the response element.
       attr_accessor :elements_type
 
+      # @!attribute [rw] optional
+      #   @return [Boolean] true if the element is optional
+      attr_accessor :optional
+
       def initialize(name = nil, description = nil, required = nil, type = nil, default = nil,
-                     elements_type = nil)
+                     elements_type = nil, optional = nil)
         @name = name
         @description = description
         @required = required
         @type = type
         @default = default
         @elements_type = elements_type
+        @optional = optional
       end
-
     end
   end
 end

lib/angus/definitions_reader.rb

@@ -1,12 +1,11 @@
 module Angus
   module SDoc
     class DefinitionsReader
-
-      OPERATIONS = 'operations'
-      CONFIGURATIONS = %w{service proxy_operations representations glossary messages}
+      OPERATIONS = 'operations'.freeze
+      CONFIGURATIONS =
+        %w[service proxy_operations representations glossary messages optional].freeze
 
       class << self
-
         # Returns the tree of objects for the service.
         #
         # @param [String] base_path The base path of the YML files.
@@ -214,6 +213,7 @@ def build_representations(representations_hash)
               field.type = field_hash['type']
               field.required = field_hash['required']
               field.elements_type = field_hash['elements_type']
+              field.optional = field_hash['optional']
               field
             end
 
@@ -273,6 +273,7 @@ def build_operations(operations_hash, messages)
                 request_element.constraints = element_hash['constraints']
                 request_element.valid_values = element_hash['valid_values']
                 request_element.elements_type = element_hash['elements_type']
+                request_element.optional = element_hash['optional']
 
                 request_element
               end
@@ -306,6 +307,7 @@ def build_operations(operations_hash, messages)
                 response_element.type = element_hash['type']
                 response_element.default = element_hash['default']
                 response_element.elements_type = element_hash['elements_type']
+                response_element.optional = element_hash['optional']
 
                 response_element
               end
@@ -329,9 +331,7 @@ def build_glossary(glossary_hash)
           Angus::SDoc::Definitions::Glossary.new(glossary_hash)
         end
         private :build_glossary
-
       end
-
     end
   end
 end

lib/angus/sdoc/json_formatter.rb

@@ -48,8 +48,8 @@ def glossary_for_json(glossary_definition)
         # @option return [String] :description
         def glossary_term_for_json(glossary_term_definition)
           {
-            :long_name => glossary_term_definition.long_name,
-            :description => glossary_term_definition.description
+            long_name: glossary_term_definition.long_name,
+            description: glossary_term_definition.description
           }
         end
 
@@ -65,10 +65,10 @@ def glossary_term_for_json(glossary_term_definition)
         # @option return [Integer] :status_code
         def message_for_json(message_definition)
           {
-            :key => message_definition.key,
-            :description => message_definition.description,
-            :level => message_definition.level,
-            :status_code => message_definition.status_code
+            key: message_definition.key,
+            description: message_definition.description,
+            level: message_definition.level,
+            status_code: message_definition.status_code
           }
         end
 
@@ -88,41 +88,41 @@ def message_for_json(message_definition)
         # @option return [Array<(see .message_for_json)>] :messages
         def operation_for_json(operation_definition)
           data = {
-            :name => operation_definition.name,
-            :description => operation_definition.description,
-            :path => operation_definition.path,
-            :method => operation_definition.http_method
+            name: operation_definition.name,
+            description: operation_definition.description,
+            path: operation_definition.path,
+            method: operation_definition.http_method
           }
 
           if operation_definition.uri_elements && !operation_definition.uri_elements.empty?
             uri_elements = operation_definition.uri_elements.map do |uri_element|
               uri_element_for_json(uri_element)
             end
-            data.merge!({ :uri => uri_elements })
+            data.merge!({ uri: uri_elements })
           end
 
           if operation_definition.request_elements && !operation_definition.request_elements.empty?
             request_elements = operation_definition.request_elements.map do |request_element|
               request_element_for_json(request_element)
             end
 
-            data.merge!({ :request => request_elements })
+            data.merge!({ request: request_elements })
           end
 
           if operation_definition.response_elements && !operation_definition.response_elements.empty?
             response_elements = operation_definition.response_elements.map do |response_element|
               response_element_for_json(response_element)
             end
 
-            data.merge!({:response => response_elements})
+            data.merge!({ response: response_elements })
           end
 
           if operation_definition.messages && !operation_definition.messages.empty?
             messages = operation_definition.messages.map do |message|
               message_for_json(message)
             end
 
-            data.merge!({:messages => messages})
+            data.merge!({ messages: messages })
           end
 
           data
@@ -139,9 +139,9 @@ def operation_for_json(operation_definition)
         # @option return [String] :service
         def proxy_operation_for_json(proxy_operation_definition)
           {
-            :path => proxy_operation_definition.path,
-            :method => proxy_operation_definition.http_method,
-            :service => proxy_operation_definition.service_name
+            path: proxy_operation_definition.path,
+            method: proxy_operation_definition.http_method,
+            service: proxy_operation_definition.service_name
           }
         end
 
@@ -170,17 +170,18 @@ def representation_for_json(representation_definition)
         # @option return [String] :elements_type
         def representation_field_for_json(representation_field_definition)
           data = {
-            :field => representation_field_definition.name,
-            :description => representation_field_definition.description,
-            :required => representation_field_definition.required
+            field: representation_field_definition.name,
+            description: representation_field_definition.description,
+            required: representation_field_definition.required,
+            optional: representation_field_definition.optional
           }
 
           if representation_field_definition.type
-            data.merge!({:type => representation_field_definition.type})
+            data.merge!({ type: representation_field_definition.type })
           end
 
           if representation_field_definition.elements_type
-            data.merge!({:elements_type => representation_field_definition.elements_type})
+            data.merge!({ elements_type: representation_field_definition.elements_type })
           end
 
           data
@@ -199,17 +200,18 @@ def representation_field_for_json(representation_field_definition)
         # @option return [String] :elements_type
         def request_element_for_json(request_element_definition)
           data = {
-            :element => request_element_definition.name,
-            :description => request_element_definition.description,
-            :required => request_element_definition.required
+            element: request_element_definition.name,
+            description: request_element_definition.description,
+            required: request_element_definition.required,
+            optional: request_element_definition.optional
           }
 
           if request_element_definition.type
-            data.merge!({:type => request_element_definition.type})
+            data.merge!({ type: request_element_definition.type })
           end
 
           if request_element_definition.elements_type
-            data.merge!({:elements_type => request_element_definition.elements_type})
+            data.merge!({ elements_type: request_element_definition.elements_type })
           end
 
           data
@@ -228,17 +230,18 @@ def request_element_for_json(request_element_definition)
         # @option return [String] :elements_type
         def response_element_for_json(response_element_definition)
           data = {
-            :element => response_element_definition.name,
-            :description => response_element_definition.description,
-            :required => response_element_definition.required
+            element: response_element_definition.name,
+            description: response_element_definition.description,
+            required: response_element_definition.required,
+            optional: response_element_definition.optional
           }
 
           if response_element_definition.type
-            data.merge!({:type => response_element_definition.type})
+            data.merge!({ type: response_element_definition.type })
           end
 
           if response_element_definition.elements_type
-            data.merge!({:elements_type => response_element_definition.elements_type})
+            data.merge!({ elements_type: response_element_definition.elements_type })
           end
 
           data
@@ -282,16 +285,16 @@ def service_for_json(service_definition)
           end
 
           {
-            :service => {
-              :service => service_definition.name,
-              :code_name => service_definition.code_name,
-              :version => service_definition.version
+            service: {
+              service: service_definition.name,
+              code_name: service_definition.code_name,
+              version: service_definition.version
             },
-            :operations => operations,
-            :proxy_operations => proxy_operations,
-            :representations => representations,
-            :messages => messages,
-            :glossary => glossary_for_json(service_definition.glossary)
+            operations: operations,
+            proxy_operations: proxy_operations,
+            representations: representations,
+            messages: messages,
+            glossary: glossary_for_json(service_definition.glossary)
           }
         end
 
@@ -305,8 +308,8 @@ def service_for_json(service_definition)
         # @option return [String] :description
         def uri_element_for_json(uri_element_definition)
           {
-            :element => uri_element_definition.name,
-            :description => uri_element_definition.description
+            element: uri_element_definition.name,
+            description: uri_element_definition.description
           }
         end