oci 2.1.0 → 2.1.1

data/lib/oci/load_balancer/models/path_match_type.rb

@@ -1,34 +1,58 @@
 # Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
 
 require 'date'
+require 'logger'
 
+# rubocop:disable Lint/UnneededCopDisableDirective
 module OCI
   # The type of matching to apply to incoming URIs.
-  class LoadBalancer::Models::PathMatchType
-
-    MATCH_TYPE_ENUM = [MATCH_TYPE_EXACT_MATCH = 'EXACT_MATCH',
-                MATCH_TYPE_FORCE_LONGEST_PREFIX_MATCH = 'FORCE_LONGEST_PREFIX_MATCH',
-                MATCH_TYPE_PREFIX_MATCH = 'PREFIX_MATCH',
-                MATCH_TYPE_SUFFIX_MATCH = 'SUFFIX_MATCH',
-                MATCH_TYPE_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE']
+  class LoadBalancer::Models::PathMatchType # rubocop:disable Metrics/LineLength
+    MATCH_TYPE_ENUM = [
+      MATCH_TYPE_EXACT_MATCH = 'EXACT_MATCH'.freeze,
+      MATCH_TYPE_FORCE_LONGEST_PREFIX_MATCH = 'FORCE_LONGEST_PREFIX_MATCH'.freeze,
+      MATCH_TYPE_PREFIX_MATCH = 'PREFIX_MATCH'.freeze,
+      MATCH_TYPE_SUFFIX_MATCH = 'SUFFIX_MATCH'.freeze,
+      MATCH_TYPE_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE'.freeze
+    ].freeze
 
     # **[Required]** Specifies how the load balancing service compares a {#path_route path_route}
     # object's `path` string against the incoming URI.
-    # 
+    #
     # *  **EXACT_MATCH** - Looks for a `path` string that exactly matches the incoming URI path.
-    # 
+    #
     # *  **FORCE_LONGEST_PREFIX_MATCH** - Looks for the `path` string with the best, longest match of the beginning
     #    portion of the incoming URI path.
-    # 
+    #
     # *  **PREFIX_MATCH** - Looks for a `path` string that matches the beginning portion of the incoming URI path.
-    # 
+    #
     # *  **SUFFIX_MATCH** - Looks for a `path` string that matches the ending portion of the incoming URI path.
-    # 
+    #
     # For a full description of how the system handles `matchType` in a path route set containing multiple rules, see
     # [Managing Request Routing](https://docs.us-phoenix-1.oraclecloud.com/Content/Balance/Tasks/managingrequest.htm).
-    # 
+    #
     # @return [String]
-    attr_accessor :match_type
+    attr_reader :match_type
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'match_type': :'matchType'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'match_type': :'String'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
 
 
     # Initializes the object
@@ -38,49 +62,62 @@ module OCI
       return unless attributes.is_a?(Hash)
 
       # convert string to symbol for hash key
-      attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
 
-      if attributes[:'matchType']
-        self.match_type = attributes[:'matchType']
-      end
+      self.match_type = attributes[:'matchType'] if attributes[:'matchType']
 
       raise 'You cannot provide both :matchType and :match_type' if attributes.key?(:'matchType') && attributes.key?(:'match_type')
 
-      if attributes[:'match_type']
-        self.match_type = attributes[:'match_type']
-      end
-
+      self.match_type = attributes[:'match_type'] if attributes[:'match_type']
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
 
     # Custom attribute writer method checking allowed values (enum).
     # @param [Object] match_type Object to be assigned
     def match_type=(match_type)
+      # rubocop:disable Style/ConditionalAssignment
       if match_type && !MATCH_TYPE_ENUM.include?(match_type)
+        # rubocop: disable Metrics/LineLength
+        OCI.logger.debug("Unknown value for 'match_type' [" + match_type + "]. Mapping to 'MATCH_TYPE_UNKNOWN_ENUM_VALUE'") if OCI.logger
+        # rubocop: enable Metrics/LineLength
         @match_type = MATCH_TYPE_UNKNOWN_ENUM_VALUE
       else
         @match_type = match_type
       end
+      # rubocop:enable Style/ConditionalAssignment
     end
 
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
+
+
     # Checks equality by comparing each attribute.
-    # @param [Object] other_object to be compared
-    def ==(other_object)
-      return true if self.equal?(other_object)
-      self.class == other_object.class &&
-          match_type == other_object.match_type
+    # @param [Object] other the other object to be compared
+    def ==(other)
+      return true if equal?(other)
+      self.class == other.class &&
+        match_type == other.match_type
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
 
     # @see the `==` method
-    # @param [Object] other_object to be compared
-    def eql?(other_object)
-      self == other_object
+    # @param [Object] other the other object to be compared
+    def eql?(other)
+      self == other
     end
 
+    # rubocop:disable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
       [match_type].hash
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
 
     # Builds the object from hash
     # @param [Hash] attributes Model attributes in the form of hash
@@ -92,15 +129,22 @@ module OCI
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.public_method("#{key}=").call(attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            public_method("#{key}=").call(
+              attributes[self.class.attribute_map[key]]
+                .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
+            )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.public_method("#{key}=").call(OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
-        end # or else data not found in attributes(hash), not an issue as the data can be optional
+          public_method("#{key}=").call(
+            OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
+          )
+        end
+        # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
       self
     end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
 
     # Returns the string representation of the object
     # @return [String] String presentation of the object
@@ -124,11 +168,11 @@ module OCI
 
     # Outputs non-array value in the form of hash
     # For object, use to_hash. Otherwise, just return the value
-    # @param [Object] value Any valid value 
+    # @param [Object] value Any valid value
     # @return [Hash] Returns the value in the form of hash
     def _to_hash(value)
       if value.is_a?(Array)
-        value.compact.map{ |v| _to_hash(v) }
+        value.compact.map { |v| _to_hash(v) }
       elsif value.is_a?(Hash)
         {}.tap do |hash|
           value.each { |k, v| hash[k] = _to_hash(v) }
@@ -139,21 +183,6 @@ module OCI
         value
       end
     end
-
-
-
-    # Attribute mapping from ruby-style variable name to JSON key.
-    def self.attribute_map
-      { 
-        :'match_type' => :'matchType'
-      }
-    end
-
-    # Attribute type mapping.
-    def self.swagger_types
-      { 
-        :'match_type' => :'String'
-      }
-    end
   end
 end
+# rubocop:enable Lint/UnneededCopDisableDirective

data/lib/oci/load_balancer/models/path_route.rb

@@ -2,29 +2,30 @@
 
 require 'date'
 
+# rubocop:disable Lint/UnneededCopDisableDirective
 module OCI
   # A \"path route rule\" to evaluate an incoming URI path, and then route a matching request to the specified backend set.
   #
   # Path route rules apply only to HTTP and HTTPS requests. They have no effect on TCP requests.
   #
-  class LoadBalancer::Models::PathRoute
+  class LoadBalancer::Models::PathRoute # rubocop:disable Metrics/LineLength
     # **[Required]** The name of the target backend set for requests where the incoming URI matches the specified path.
-    # 
+    #
     # Example: `My_backend_set`
-    # 
+    #
     # @return [String]
     attr_accessor :backend_set_name
 
     # **[Required]** The path string to match against the incoming URI path.
-    # 
+    #
     # *  Path strings are case-insensitive.
-    # 
+    #
     # *  Asterisk (*) wildcards are not supported.
-    # 
+    #
     # *  Regular expressions are not supported.
-    # 
+    #
     # Example: `/example/video/123`
-    # 
+    #
     # @return [String]
     attr_accessor :path
 
@@ -32,6 +33,31 @@ module OCI
     # @return [OCI::LoadBalancer::Models::PathMatchType]
     attr_accessor :path_match_type
 
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'backend_set_name': :'backendSetName',
+        'path': :'path',
+        'path_match_type': :'pathMatchType'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'backend_set_name': :'String',
+        'path': :'String',
+        'path_match_type': :'OCI::LoadBalancer::Models::PathMatchType'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
 
     # Initializes the object
     # @param [Hash] attributes Model attributes in the form of hash
@@ -42,55 +68,57 @@ module OCI
       return unless attributes.is_a?(Hash)
 
       # convert string to symbol for hash key
-      attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
 
-      if attributes[:'backendSetName']
-        self.backend_set_name = attributes[:'backendSetName']
-      end
+      self.backend_set_name = attributes[:'backendSetName'] if attributes[:'backendSetName']
 
       raise 'You cannot provide both :backendSetName and :backend_set_name' if attributes.key?(:'backendSetName') && attributes.key?(:'backend_set_name')
 
-      if attributes[:'backend_set_name']
-        self.backend_set_name = attributes[:'backend_set_name']
-      end
+      self.backend_set_name = attributes[:'backend_set_name'] if attributes[:'backend_set_name']
 
-      if attributes[:'path']
-        self.path = attributes[:'path']
-      end
+      self.path = attributes[:'path'] if attributes[:'path']
 
-      if attributes[:'pathMatchType']
-        self.path_match_type = attributes[:'pathMatchType']
-      end
+      self.path_match_type = attributes[:'pathMatchType'] if attributes[:'pathMatchType']
 
       raise 'You cannot provide both :pathMatchType and :path_match_type' if attributes.key?(:'pathMatchType') && attributes.key?(:'path_match_type')
 
-      if attributes[:'path_match_type']
-        self.path_match_type = attributes[:'path_match_type']
-      end
-
+      self.path_match_type = attributes[:'path_match_type'] if attributes[:'path_match_type']
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
+
 
     # Checks equality by comparing each attribute.
-    # @param [Object] other_object to be compared
-    def ==(other_object)
-      return true if self.equal?(other_object)
-      self.class == other_object.class &&
-          backend_set_name == other_object.backend_set_name &&
-          path == other_object.path &&
-          path_match_type == other_object.path_match_type
+    # @param [Object] other the other object to be compared
+    def ==(other)
+      return true if equal?(other)
+      self.class == other.class &&
+        backend_set_name == other.backend_set_name &&
+        path == other.path &&
+        path_match_type == other.path_match_type
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
 
     # @see the `==` method
-    # @param [Object] other_object to be compared
-    def eql?(other_object)
-      self == other_object
+    # @param [Object] other the other object to be compared
+    def eql?(other)
+      self == other
     end
 
+    # rubocop:disable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
       [backend_set_name, path, path_match_type].hash
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
 
     # Builds the object from hash
     # @param [Hash] attributes Model attributes in the form of hash
@@ -102,15 +130,22 @@ module OCI
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.public_method("#{key}=").call(attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            public_method("#{key}=").call(
+              attributes[self.class.attribute_map[key]]
+                .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
+            )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.public_method("#{key}=").call(OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
-        end # or else data not found in attributes(hash), not an issue as the data can be optional
+          public_method("#{key}=").call(
+            OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
+          )
+        end
+        # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
       self
     end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
 
     # Returns the string representation of the object
     # @return [String] String presentation of the object
@@ -134,11 +169,11 @@ module OCI
 
     # Outputs non-array value in the form of hash
     # For object, use to_hash. Otherwise, just return the value
-    # @param [Object] value Any valid value 
+    # @param [Object] value Any valid value
     # @return [Hash] Returns the value in the form of hash
     def _to_hash(value)
       if value.is_a?(Array)
-        value.compact.map{ |v| _to_hash(v) }
+        value.compact.map { |v| _to_hash(v) }
       elsif value.is_a?(Hash)
         {}.tap do |hash|
           value.each { |k, v| hash[k] = _to_hash(v) }
@@ -149,25 +184,6 @@ module OCI
         value
       end
     end
-
-
-
-    # Attribute mapping from ruby-style variable name to JSON key.
-    def self.attribute_map
-      { 
-        :'backend_set_name' => :'backendSetName',
-        :'path' => :'path',
-        :'path_match_type' => :'pathMatchType'
-      }
-    end
-
-    # Attribute type mapping.
-    def self.swagger_types
-      { 
-        :'backend_set_name' => :'String',
-        :'path' => :'String',
-        :'path_match_type' => :'OCI::LoadBalancer::Models::PathMatchType'
-      }
-    end
   end
 end
+# rubocop:enable Lint/UnneededCopDisableDirective

data/lib/oci/load_balancer/models/path_route_set.rb

@@ -2,15 +2,16 @@
 
 require 'date'
 
+# rubocop:disable Lint/UnneededCopDisableDirective
 module OCI
   # A named set of path route rules. For more information, see
   # [Managing Request Routing](https://docs.us-phoenix-1.oraclecloud.com/Content/Balance/Tasks/managingrequest.htm).
   #
-  class LoadBalancer::Models::PathRouteSet
+  class LoadBalancer::Models::PathRouteSet # rubocop:disable Metrics/LineLength
     # **[Required]** The unique name for this set of path route rules. Avoid entering confidential information.
-    # 
+    #
     # Example: `path-route-set-001`
-    # 
+    #
     # @return [String]
     attr_accessor :name
 
@@ -18,6 +19,29 @@ module OCI
     # @return [Array<OCI::LoadBalancer::Models::PathRoute>]
     attr_accessor :path_routes
 
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'name': :'name',
+        'path_routes': :'pathRoutes'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'name': :'String',
+        'path_routes': :'Array<OCI::LoadBalancer::Models::PathRoute>'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
 
     # Initializes the object
     # @param [Hash] attributes Model attributes in the form of hash
@@ -27,44 +51,50 @@ module OCI
       return unless attributes.is_a?(Hash)
 
       # convert string to symbol for hash key
-      attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
 
-      if attributes[:'name']
-        self.name = attributes[:'name']
-      end
+      self.name = attributes[:'name'] if attributes[:'name']
 
-      if attributes[:'pathRoutes']
-        self.path_routes = attributes[:'pathRoutes']
-      end
+      self.path_routes = attributes[:'pathRoutes'] if attributes[:'pathRoutes']
 
       raise 'You cannot provide both :pathRoutes and :path_routes' if attributes.key?(:'pathRoutes') && attributes.key?(:'path_routes')
 
-      if attributes[:'path_routes']
-        self.path_routes = attributes[:'path_routes']
-      end
-
+      self.path_routes = attributes[:'path_routes'] if attributes[:'path_routes']
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
+
 
     # Checks equality by comparing each attribute.
-    # @param [Object] other_object to be compared
-    def ==(other_object)
-      return true if self.equal?(other_object)
-      self.class == other_object.class &&
-          name == other_object.name &&
-          path_routes == other_object.path_routes
+    # @param [Object] other the other object to be compared
+    def ==(other)
+      return true if equal?(other)
+      self.class == other.class &&
+        name == other.name &&
+        path_routes == other.path_routes
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
 
     # @see the `==` method
-    # @param [Object] other_object to be compared
-    def eql?(other_object)
-      self == other_object
+    # @param [Object] other the other object to be compared
+    def eql?(other)
+      self == other
     end
 
+    # rubocop:disable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
       [name, path_routes].hash
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
 
     # Builds the object from hash
     # @param [Hash] attributes Model attributes in the form of hash
@@ -76,15 +106,22 @@ module OCI
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.public_method("#{key}=").call(attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            public_method("#{key}=").call(
+              attributes[self.class.attribute_map[key]]
+                .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
+            )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.public_method("#{key}=").call(OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
-        end # or else data not found in attributes(hash), not an issue as the data can be optional
+          public_method("#{key}=").call(
+            OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
+          )
+        end
+        # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
       self
     end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
 
     # Returns the string representation of the object
     # @return [String] String presentation of the object
@@ -108,11 +145,11 @@ module OCI
 
     # Outputs non-array value in the form of hash
     # For object, use to_hash. Otherwise, just return the value
-    # @param [Object] value Any valid value 
+    # @param [Object] value Any valid value
     # @return [Hash] Returns the value in the form of hash
     def _to_hash(value)
       if value.is_a?(Array)
-        value.compact.map{ |v| _to_hash(v) }
+        value.compact.map { |v| _to_hash(v) }
       elsif value.is_a?(Hash)
         {}.tap do |hash|
           value.each { |k, v| hash[k] = _to_hash(v) }
@@ -123,23 +160,6 @@ module OCI
         value
       end
     end
-
-
-
-    # Attribute mapping from ruby-style variable name to JSON key.
-    def self.attribute_map
-      { 
-        :'name' => :'name',
-        :'path_routes' => :'pathRoutes'
-      }
-    end
-
-    # Attribute type mapping.
-    def self.swagger_types
-      { 
-        :'name' => :'String',
-        :'path_routes' => :'Array<OCI::LoadBalancer::Models::PathRoute>'
-      }
-    end
   end
 end
+# rubocop:enable Lint/UnneededCopDisableDirective