ms_rest 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edb23269524d72595eea5bf57e7296344cd013ec
-  data.tar.gz: e9b039be71e5b171d22b2fbd07b8600e781d53ac
+  metadata.gz: 0a076ad1f650d77705233430c3ab8a8bff76d568
+  data.tar.gz: 4cc31d2b65c4e22720ec440cf401da166456f156
 SHA512:
-  metadata.gz: ad5055678904d0874bf5edb051b3829b070884a3c18ea78491422f6441fd95609612f02b10fe03f596295c8b3d9c35779c7153d5fa901bba7d9a27a49de9ed7f
-  data.tar.gz: 31caa6ef155fbf6427a0a27df21c9180a6be097da214aaa7fafb933d3fff4d45cefc861b15dcd884489eceaa3741387f7c418ec46bf43c5130ae8ee80d238109
+  metadata.gz: 02968944245aca783affdf02d4ad74daaaf43f24b2650b31fce9422de7bfcb9ce41a1db510e0f96a0d8f3e389d6b0aaadc91eed67d75c86fd56b1191fa2d6c01
+  data.tar.gz: 00a25077f3f286751de7b557f1d8e5bb77c8ba316f78cf25c02e349157a02444a546ee9444aa7558b47fe3bf837ae7f13530b9956d7870c93ab94d56bb7e73f5

data/ChangeLog.md

@@ -0,0 +1,2 @@
+##2016.07.14 ms_rest version 0.3.0
+* Moving serialization/deserializaiton code from sdk models to client runtime. [#1106](https://github.com/Azure/autorest/pull/1106)

data/README.md

@@ -38,7 +38,7 @@ To start working on the gem the only additional dev dependecy is required - rspe
 Reference it in the gemfile and also add this line to your client's gemspec file:
 
 ```ruby
-spec.add_runtime_dependency 'ms_rest', '~> 0.1.0'
+spec.add_runtime_dependency 'ms_rest', '~> 0.3.0'
 ```
 
 Don't forget to correct the version.

data/lib/ms_rest.rb

@@ -24,4 +24,5 @@ require 'ms_rest/http_operation_error'
 require 'ms_rest/retry_policy_middleware'
 require 'ms_rest/service_client'
 
-module MsRest; end
+module MsRest end
+module MsRest::Serialization end

data/lib/ms_rest/http_operation_request.rb

@@ -68,8 +68,8 @@ module MsRest
     # @return [URI] body the HTTP response body.
     def run_promise(&block)
       Concurrent::Promise.new do
-        connection = Faraday.new(:url => base_uri) do |faraday|
-          middlewares.each{ |args| faraday.use(*args) }
+        @connection ||= Faraday.new(:url => base_uri) do |faraday|
+          middlewares.each{ |args| faraday.use(*args) } unless middlewares.nil?
           faraday.adapter Faraday.default_adapter
           logging = ENV['AZURE_HTTP_LOGGING'] || log
           if logging
@@ -77,7 +77,7 @@ module MsRest
           end
         end
         
-        connection.run_request(:"#{method}", build_path, body, {'User-Agent' => user_agent}.merge(headers)) do |req|
+        @connection.run_request(:"#{method}", build_path, body, {'User-Agent' => user_agent}.merge(headers)) do |req|
           req.params = query_params.reject{|_, v| v.nil?} unless query_params.nil?
           yield(req) if block_given?
         end

data/lib/ms_rest/serialization.rb

@@ -3,20 +3,420 @@
 # Licensed under the MIT License. See License.txt in the project root for license information.
 
 module MsRest
+  # Base module for Ruby serialization and deserialization.
   #
-  # Class which keeps the auxiliary for (de)serializing JSON requests and responses from server.
-  #
-  class Serialization
+  # Provides methods to serialize Ruby object into Ruby Hash and
+  # to deserialize Ruby Hash into Ruby object.
+  module Serialization
+    #
+    # Deserialize the response from the server using the mapper.
+    #
+    # @param mapper [Hash] Ruby Hash object to represent expected structure of the response_body.
+    # @param response_body [Hash] Ruby Hash object to deserialize.
+    # @param object_name [String] Name of the deserialized object.
+    #
+    def deserialize(mapper, response_body, object_name)
+      serialization = Serialization.new(self)
+      serialization.deserialize(mapper, response_body, object_name)
+    end
 
     #
-    # Deserializes given string value into Ruby Date object.
-    # @param [String] string_value string value to deserialize.
+    # Serialize the Ruby object into Ruby Hash to send it to the server using the mapper.
+    #
+    # @param mapper [Hash] Ruby Hash object to represent expected structure of the object.
+    # @param object [Object] Ruby object to serialize.
+    # @param object_name [String] Name of the serialized object.
     #
-    # @return [Date] deserialized Date object.
-    def self.deserialize_date(string_value)
-      result = Timeliness.parse(string_value, :strict => true)
-      fail DeserializationError.new('Error occured in deserializing the response', nil, nil, string_value) if result.nil?
-      return ::Date.parse(result.to_s)
+    def serialize(mapper, object, object_name)
+      serialization = Serialization.new(self)
+      serialization.serialize(mapper, object, object_name)
+    end
+
+    #
+    # Class to handle serialization & deserialization.
+    #
+    class Serialization
+      def initialize(context)
+        @context = context
+      end
+
+      #
+      # Deserialize the response from the server using the mapper.
+      #
+      # @param mapper [Hash] Ruby Hash object to represent expected structure of the response_body.
+      # @param response_body [Hash] Ruby Hash object to deserialize.
+      # @param object_name [String] Name of the deserialized object.
+      #
+      def deserialize(mapper, response_body, object_name)
+        return response_body if response_body.nil?
+
+        object_name = mapper[:serialized_name] unless object_name.nil?
+        mapper_type = mapper[:type][:name]
+
+        if !mapper_type.match(/^(Number|Double|ByteArray|Boolean|Date|DateTime|DateTimeRfc1123|UnixTime|Enum|String|Object|Stream)$/i).nil?
+          payload = deserialize_primary_type(mapper, response_body)
+        elsif !mapper_type.match(/^Dictionary$/i).nil?
+          payload = deserialize_dictionary_type(mapper, response_body, object_name)
+        elsif !mapper_type.match(/^Composite$/i).nil?
+          payload = deserialize_composite_type(mapper, response_body, object_name)
+        elsif !mapper_type.match(/^Sequence$/i).nil?
+          payload = deserialize_sequence_type(mapper, response_body, object_name)
+        else
+          payload = ""
+        end
+
+        payload = mapper[:default_value] if mapper[:is_constant]
+
+        payload
+      end
+
+      #
+      # Deserialize the response of known primary type from the server using the mapper.
+      #
+      # @param mapper [Hash] Ruby Hash object to represent expected structure of the response_body.
+      # @param response_body [Hash] Ruby Hash object to deserialize.
+      #
+      def deserialize_primary_type(mapper, response_body)
+        result = ""
+        case mapper[:type][:name]
+          when 'Number'
+            result = Integer(response_body) unless response_body.to_s.empty?
+          when 'Double'
+            result = Float(response_body) unless response_body.to_s.empty?
+          when 'ByteArray'
+            result = Base64.strict_decode64(response_body).unpack('C*') unless response_body.to_s.empty?
+          when 'String', 'Boolean', 'Object', 'Stream'
+            result = response_body
+          when 'Enum'
+            unless response_body.nil? || response_body.empty?
+              unless enum_is_valid(mapper, response_body)
+                warn "Enum #{model} does not contain #{response_body.downcase}, but was received from the server."
+              end
+            end
+            result = response_body
+          when 'Date'
+            unless response_body.to_s.empty?
+              result = Timeliness.parse(response_body, :strict => true)
+              fail DeserializationError.new('Error occured in deserializing the response_body', nil, nil, response_body) if result.nil?
+              result = ::Date.parse(result.to_s)
+            end
+          when 'DateTime', 'DateTimeRfc1123'
+            result = DateTime.parse(response_body) unless response_body.to_s.empty?
+          when 'UnixTime'
+            result = DateTime.strptime(response_body.to_s, '%s') unless response_body.to_s.empty?
+          else
+            result
+        end
+        result
+      end
+
+      #
+      # Deserialize the response of dictionary type from the server using the mapper.
+      #
+      # @param mapper [Hash] Ruby Hash object to represent expected structure of the response_body.
+      # @param response_body [Hash] Ruby Hash object to deserialize.
+      # @param object_name [String] Name of the deserialized object.
+      #
+      def deserialize_dictionary_type(mapper, response_body, object_name)
+        if mapper[:type][:value].nil? || !mapper[:type][:value].is_a?(Hash)
+          fail DeserializationError.new("'value' metadata for a dictionary type must be defined in the mapper and it must be of type Hash in #{object_name}", nil, nil, response_body)
+        end
+
+        result = Hash.new
+        response_body.each do |key, val|
+          result[key] = deserialize(mapper[:type][:value], val, object_name)
+        end
+        result
+      end
+
+      #
+      # Deserialize the response of composite type from the server using the mapper.
+      #
+      # @param mapper [Hash] Ruby Hash object to represent expected structure of the response_body.
+      # @param response_body [Hash] Ruby Hash object to deserialize.
+      # @param object_name [String] Name of the deserialized object.
+      #
+      def deserialize_composite_type(mapper, response_body, object_name)
+        if mapper[:type][:class_name].nil?
+          fail DeserializationError.new("'class_name' metadata for a composite type must be defined in the mapper and it must be of type Hash in #{object_name}", nil, nil, response_body)
+        end
+
+        if !mapper[:type][:polymorphic_discriminator].nil?
+          # Handle polymorphic types
+          parent_class = get_model(mapper[:type][:class_name])
+          discriminator = parent_class.class_eval("@@discriminatorMap")
+          model_name = response_body["#{mapper[:type][:polymorphic_discriminator]}"]
+          model_class = get_model(discriminator[model_name])
+        else
+          model_class = get_model(mapper[:type][:class_name])
+        end
+
+        result = model_class.new
+
+        model_mapper = model_class.mapper()
+        model_props = model_mapper[:type][:model_properties]
+
+        unless model_props.nil?
+          model_props.each do |key, val|
+            sub_response_body = nil
+            unless val[:serialized_name].to_s.include? '.'
+              sub_response_body = response_body[val[:serialized_name].to_s]
+            else
+              # Flattened properties will be dicovered at deeper level in payload but must be deserialized to higher levels in model class
+              sub_response_body = response_body
+              levels = split_serialized_name(val[:serialized_name].to_s)
+              levels.each { |level| sub_response_body = sub_response_body.nil? ? nil : sub_response_body[level.to_s] }
+            end
+
+            result.instance_variable_set("@#{key}", deserialize(val, sub_response_body, object_name)) unless sub_response_body.nil?
+          end
+        end
+        result
+      end
+
+      #
+      # Deserialize the response of sequence type from the server using the mapper.
+      #
+      # @param mapper [Hash] Ruby Hash object to represent expected structure of the response_body.
+      # @param response_body [Hash] Ruby Hash object to deserialize.
+      # @param object_name [String] Name of the deserialized object.
+      #
+      def deserialize_sequence_type(mapper, response_body, object_name)
+        if mapper[:type][:element].nil? || !mapper[:type][:element].is_a?(Hash)
+          fail DeserializationError.new("'element' metadata for a sequence type must be defined in the mapper and it must be of type Hash in #{object_name}", nil, nil, response_body)
+        end
+
+        return response_body if response_body.nil?
+
+        result = []
+        response_body.each do |element|
+          result.push(deserialize(mapper[:type][:element], element, object_name))
+        end
+
+        result
+      end
+
+      #
+      # Serialize the Ruby object into Ruby Hash to send it to the server using the mapper.
+      #
+      # @param mapper [Hash] Ruby Hash object to represent expected structure of the object.
+      # @param object [Object] Ruby object to serialize.
+      # @param object_name [String] Name of the serialized object.
+      #
+      def serialize(mapper, object, object_name)
+        object_name = mapper[:serialized_name] unless object_name.nil?
+
+        # Set defaults
+        unless mapper[:default_value].nil?
+          object = mapper[:default_value] if object.nil?
+        end
+        object = mapper[:default_value] if mapper[:is_constant]
+
+        # Throw if required & non-constant object is nil
+        if mapper[:required] && object.nil? && !mapper[:is_constant]
+          fail ValidationError, "#{object_name} is required and cannot be nil"
+        end
+
+        if !mapper[:required] && object.nil?
+          return object
+        end
+
+        payload = Hash.new
+        mapper_type = mapper[:type][:name]
+        if !mapper_type.match(/^(Number|Double|ByteArray|Boolean|Date|DateTime|DateTimeRfc1123|UnixTime|Enum|String|Object|Stream)$/i).nil?
+          payload = serialize_primary_type(mapper, object)
+        elsif !mapper_type.match(/^Dictionary$/i).nil?
+          payload = serialize_dictionary_type(mapper, object, object_name)
+        elsif !mapper_type.match(/^Composite$/i).nil?
+          payload = serialize_composite_type(mapper, object, object_name)
+        elsif !mapper_type.match(/^Sequence$/i).nil?
+          payload = serialize_sequence_type(mapper, object, object_name)
+        end
+        payload
+      end
+
+      #
+      # Serialize the Ruby object of known primary type into Ruby Hash to send it to the server using the mapper.
+      #
+      # @param mapper [Hash] Ruby Hash object to represent expected structure of the object.
+      # @param object [Object] Ruby object to serialize.
+      #
+      def serialize_primary_type(mapper, object)
+        mapper_type = mapper[:type][:name]
+        payload = nil
+        case mapper_type
+          when 'Number', 'Double', 'String', 'Date', 'Boolean', 'Object', 'Stream'
+            payload = object != nil ? object : nil
+          when  'Enum'
+            unless object.nil? || object.empty?
+              unless enum_is_valid(mapper, object)
+                fail ValidationError, "Enum #{mapper[:type][:module]} does not contain #{object.to_s}, but trying to send it to the server."
+              end
+            end
+            payload = object != nil ? object : nil
+          when 'ByteArray'
+            payload = Base64.strict_encode64(object.pack('c*'))
+          when 'DateTime'
+            payload = object.new_offset(0).strftime('%FT%TZ')
+          when 'DateTimeRfc1123'
+            payload = object.new_offset(0).strftime('%a, %d %b %Y %H:%M:%S GMT')
+          when 'UnixTime'
+            payload = object.new_offset(0).strftime('%s') unless object.nil?
+        end
+        payload
+      end
+
+      #
+      # Serialize the Ruby object of dictionary type into Ruby Hash to send it to the server using the mapper.
+      #
+      # @param mapper [Hash] Ruby Hash object to represent expected structure of the object.
+      # @param object [Object] Ruby object to serialize.
+      # @param object_name [String] Name of the serialized object.
+      #
+      def serialize_dictionary_type(mapper, object, object_name)
+        unless object.is_a?(Hash)
+          fail DeserializationError.new("#{object_name} must be of type Hash", nil, nil, object)
+        end
+
+        unless mapper[:type][:value].nil? || mapper[:type][:value].is_a?(Hash)
+          fail DeserializationError.new("'value' metadata for a dictionary type must be defined in the mapper and it must be of type Hash in #{object_name}", nil, nil, object)
+        end
+
+        payload = Hash.new
+        object.each do |key, value|
+          if !value.nil? && value.respond_to?(:validate)
+            value.validate
+          end
+
+          payload[key] = serialize(mapper[:type][:value], value, object_name)
+        end
+        payload
+      end
+
+      #
+      # Serialize the Ruby object of composite type into Ruby Hash to send it to the server using the mapper.
+      #
+      # @param mapper [Hash] Ruby Hash object to represent expected structure of the object.
+      # @param object [Object] Ruby object to serialize.
+      # @param object_name [String] Name of the serialized object.
+      #
+      def serialize_composite_type(mapper, object, object_name)
+        if !mapper[:type][:polymorphic_discriminator].nil?
+          # Handle polymorphic types
+          model_name = object.class.to_s.split('::')[-1]
+          model_class = get_model(model_name)
+        else
+          model_class = get_model(mapper[:type][:class_name])
+        end
+
+        payload = Hash.new
+        model_mapper = model_class.mapper()
+        model_props = model_mapper[:type][:model_properties]
+
+        unless model_props.nil?
+          model_props.each do |key, value|
+            begin
+              instance_variable = object.instance_variable_get("@#{key}")
+            rescue NameError
+              warn("Instance variable '#{key}' is expected on '#{object.class}'.")
+            end
+
+            if !instance_variable.nil? && instance_variable.respond_to?(:validate)
+              instance_variable.validate
+            end
+
+            # Read only properties should not be sent on wire
+            if !model_props[key][:read_only].nil? && model_props[key][:read_only]
+              next
+            end
+
+            sub_payload = serialize(value, instance_variable, object_name)
+
+            unless value[:serialized_name].to_s.include? '.'
+              payload[value[:serialized_name].to_s] = sub_payload unless sub_payload.nil?
+            else
+              # Flattened properties will be discovered at higher levels in model class but must be serialized to deeper level in payload
+              levels = split_serialized_name(value[:serialized_name].to_s)
+              last_level = levels.pop
+              temp_payload = payload
+              levels.each do |level|
+                temp_payload[level] = Hash.new unless temp_payload.key?(level)
+                temp_payload = temp_payload[level]
+              end
+              temp_payload[last_level] = sub_payload unless sub_payload.nil?
+            end
+          end
+        end
+        payload
+      end
+
+      #
+      # Serialize the Ruby object of sequence type into Ruby Hash to send it to the server using the mapper.
+      #
+      # @param mapper [Hash] Ruby Hash object to represent expected structure of the object.
+      # @param object [Object] Ruby object to serialize.
+      # @param object_name [String] Name of the serialized object.
+      #
+      def serialize_sequence_type(mapper, object, object_name)
+        unless object.is_a?(Array)
+          fail DeserializationError.new("#{object_name} must be of type of Array", nil, nil, object)
+        end
+
+        unless mapper[:type][:element].nil? || mapper[:type][:element].is_a?(Hash)
+          fail DeserializationError.new("'element' metadata for a sequence type must be defined in the mapper and it must be of type Hash in #{object_name}", nil, nil, object)
+        end
+
+        payload = Array.new
+        object.each do |element|
+          if !element.nil? && element.respond_to?(:validate)
+            element.validate
+          end
+          payload.push(serialize(mapper[:type][:element], element, object_name))
+        end
+        payload
+      end
+
+      #
+      # Retrieves model of the model_name
+      #
+      # @param model_name [String] Name of the model to retrieve.
+      #
+      def get_model(model_name)
+        Object.const_get(@context.class.to_s.split('::')[0...-1].join('::') + "::Models::#{model_name}")
+      end
+
+      #
+      # Checks whether given enum_value is valid for the mapper or not
+      #
+      # @param mapper [Hash] Ruby Hash object containing meta data
+      # @param enum_value [String] Enum value to validate
+      #
+      def enum_is_valid(mapper, enum_value)
+        model = get_model(mapper[:type][:module])
+        model.constants.any? { |e| model.const_get(e).to_s.downcase == enum_value.downcase }
+      end
+
+      # Splits serialized_name with '.' to compute levels of object hierarchy
+      #
+      # @param serialized_name [String] Name to split
+      #
+      def split_serialized_name(serialized_name)
+        result = Array.new
+        element = ''
+
+        levels = serialized_name.to_s.split('.')
+        levels.each do |level|
+          unless level.match(/.*\\$/).nil?
+            # Flattened properties will be discovered at different levels in model class and response body
+            element = "#{element}#{level.gsub!('\\','')}."
+          else
+            element = "#{element}#{level}"
+            result.push(element) unless element.empty?
+            element = ''
+          end
+        end
+        result
+      end
     end
   end
 end

data/lib/ms_rest/version.rb

@@ -3,5 +3,5 @@
 # Licensed under the MIT License. See License.txt in the project root for license information.
 
 module MsRest
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ms_rest
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Microsoft Corporation
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-07 00:00:00.000000000 Z
+date: 2016-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -116,6 +116,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- ChangeLog.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -162,4 +163,3 @@ signing_key:
 specification_version: 4
 summary: Azure Client Library for Ruby.
 test_files: []
-has_rdoc: