rookout 0.1.28 → 0.1.50

data/lib/rookout/processor/namespace_serializer2.rb

@@ -0,0 +1,331 @@
+module Rookout
+  module Processor
+    class NamespaceSerializer2
+      require_relative "../logger"
+
+      require_relative "../protobuf/variant_pb"
+      require_relative "../protobuf/variant2_pb"
+      require_relative "../user_warnings"
+      require_relative "./namespaces/container_namespace"
+      require_relative "./namespaces/traceback_namespace"
+
+      begin
+        require "hashie/mash"
+        MASH = ::Hashie::Mash
+      rescue LoadError
+        MASH = nil
+      end
+
+      begin
+        require "active_support/core_ext/hash/indifferent_access"
+        HASH_WITH_INDIFFERENT_ACCESS = ActiveSupport::HashWithIndifferentAccess
+      rescue LoadError
+        HASH_WITH_INDIFFERENT_ACCESS = nil
+      end
+
+      def initialize
+        @string_cache = {}
+        @estimated_pending_bytes = 0
+      end
+
+      attr_reader :string_cache
+      attr_reader :estimated_pending_bytes
+
+      def get_string_index_in_cache str
+        if @string_cache.key? str
+          @string_cache[str]
+        else
+          @estimated_pending_bytes += str.length + 5
+          current_size = @string_cache.size
+          @string_cache.store str, current_size
+          current_size
+        end
+      end
+
+      def dump_variant_type variant, type
+        variant.variant_type_max_depth = type << 1
+        @estimated_pending_bytes += 2 # Field header + short number
+      end
+
+      def dump_variant_type_max_depth variant, type
+        variant.variant_type_max_depth = (type << 1) | 1
+        @estimated_pending_bytes += 2 # Field header + short number
+      end
+
+      def dump namespace, log_errors
+        case namespace
+        when Namespaces::RubyObjectNamespace
+          dump_ruby_object_namespace namespace, log_errors
+        when Namespaces::ContainerNamespace
+          dump_container_namespace namespace, log_errors
+        when Namespaces::TracebackNamespace
+          dump_traceback_namespace namespace
+        else
+          raise NotImplementedError
+        end
+      rescue StandardError => e
+        message = "Failed to serialize namespace"
+        variant = Com::Rookout::Variant2.new
+        @estimated_pending_bytes = 0
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_ERROR
+
+        if log_errors
+          Logger.instance.exception message, e
+
+          error = RookError.new e, message
+          UserWarnings.notify_warning error
+        end
+        variant
+      end
+
+      def dump_ruby_object_namespace namespace, log_errors
+        dump_raw_object namespace.obj, 0, namespace.dump_config, log_errors
+      end
+
+      def dump_raw_object obj, current_depth, config, log_object_errors
+        unsafe_dump_object obj, current_depth, config, log_object_errors
+      rescue StandardError => e
+        message = "Failed to serialize object"
+        variant = Com::Rookout::Variant2.new
+        @estimated_pending_bytes = 0
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_ERROR
+
+        if log_object_errors
+          Logger.instance.exception message, e
+
+          error = RookError.new e, message
+          UserWarnings.notify_warning error
+        end
+        variant
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Style/ClassEqualityComparison
+      def unsafe_dump_object obj, current_depth, config, log_object_errors
+        variant = Com::Rookout::Variant2.new original_type_index_in_cache: get_string_index_in_cache(obj.class.to_s)
+
+        if obj.nil?
+          dump_nil variant
+        elsif obj.is_a?(Numeric) || obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
+          dump_numeric obj, variant, config
+        elsif obj.is_a?(String) || obj.is_a?(Symbol)
+          dump_string obj, variant, config
+        elsif obj.is_a? Time
+          dump_time obj, variant
+        elsif obj.class == Array
+          dump_array obj, variant, current_depth, config, log_object_errors
+        elsif obj.class == Hash || (!MASH.nil? && obj.is_a?(MASH)) ||
+              (!HASH_WITH_INDIFFERENT_ACCESS.nil? && obj.is_a?(HASH_WITH_INDIFFERENT_ACCESS))
+          dump_hash obj, variant, current_depth, config, log_object_errors
+        elsif obj.is_a? Exception
+          dump_exception obj, variant, current_depth, config, log_object_errors
+        elsif obj.is_a?(Method) || obj.is_a?(Proc) || obj.is_a?(Class) || obj.is_a?(Module)
+          dump_code_object obj, variant
+        else
+          dump_user_class variant, obj, current_depth, config, log_object_errors
+        end
+
+        variant
+      end
+      # rubocop:enable Style/ClassEqualityComparison
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def dump_nil variant
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_NONE
+      end
+
+      # Based off protobuf for Python
+      INT32_MIN = -2147483648
+      INT32_MAX = 2147483647
+      INT64_MIN = -(1 << 63)
+      INT64_MAX = (1 << 63) - 1
+
+      def dump_numeric obj, variant, config
+        case obj
+        when true
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LONG
+          variant.long_value = 1
+          @estimated_pending_bytes += 2 # Header + short number
+        when false
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LONG
+          variant.long_value = 0
+          @estimated_pending_bytes += 2 # Header + short number
+        when Integer
+          dump_integer obj, variant
+        when Float
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_DOUBLE
+          variant.double_value = obj.to_f
+          @estimated_pending_bytes += 7 # Header + 64 bit float
+        when BigDecimal
+          dump_string obj.to_s, variant, config # TODO: NS: This might cut the decimal value, is that ok?
+        when Complex
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_COMPLEX
+          variant.complex_value = Com::Rookout::Variant::Complex.new real: obj.real.to_f,
+                                                                     imaginary: obj.imaginary.to_f
+          @estimated_pending_bytes += 8 # Large header + size + (header + 64 bit float) * 2
+        else
+          raise Exceptions::RookClassCannotBeSerialized.new(obj.class, "Unknown Numeric Type")
+        end
+        # TODO: ADD SUPPORT FOR RATIONALS
+      end
+
+      def dump_integer obj, variant
+        if obj > INT32_MIN && obj < INT64_MAX
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LONG
+          variant.long_value = obj
+        else
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LARGE_INT
+          variant.bytes_index_in_cache = get_string_index_in_cache obj.to_s
+        end
+        @estimated_pending_bytes += 3 # Header + number
+      end
+
+      def dump_string obj, variant, config
+        obj = obj.to_s
+        if obj.length > config.max_string
+          final_obj = obj[0...config.max_string]
+        else
+          final_obj = obj
+        end
+
+        variant.original_size = obj.length
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_STRING
+        variant.bytes_index_in_cache = get_string_index_in_cache final_obj
+        @estimated_pending_bytes += 6 # Header + number + header + number
+      end
+
+      def dump_time obj, variant
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_TIME
+        variant.time_value = Google::Protobuf::Timestamp.new
+        variant.time_value.from_time obj
+
+        @estimated_pending_bytes += 16 # Header + size + (header + 32 bit number + header + 64 bit number)
+      end
+
+      def dump_array obj, variant, current_depth, config, log_object_errors
+        variant.original_size = obj.length
+        @estimated_pending_bytes += 3 # Header + number
+
+        weighted_children_depth = current_depth + 1
+        if weighted_children_depth <= config.max_collection_depth
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LIST
+          obj.each_with_index do |value, index|
+            break if index >= config.max_width
+            variant.collection_values << dump_raw_object(value, weighted_children_depth, config, log_object_errors)
+            @estimated_pending_bytes += 3 # Header + size
+          end
+        else
+          dump_variant_type_max_depth variant, Com::Rookout::Variant::Type::VARIANT_LIST
+        end
+      end
+
+      def dump_hash obj, variant, current_depth, config, log_object_errors
+        variant.original_size = obj.length
+
+        weighted_children_depth = current_depth + 1
+        if current_depth <= config.max_collection_depth
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_MAP
+          obj.each_with_index do |(key, value), index|
+            break if index >= config.max_width
+            variant.collection_keys << dump_raw_object(key, weighted_children_depth, config, log_object_errors)
+            variant.collection_values << dump_raw_object(value, weighted_children_depth, config, log_object_errors)
+            @estimated_pending_bytes += 6 # Header + size + header + size
+          end
+        else
+          dump_variant_type_max_depth variant, Com::Rookout::Variant::Type::VARIANT_MAP
+        end
+      end
+
+      def dump_exception obj, variant, current_depth, config, log_object_errors
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_OBJECT
+        variant.attribute_names_in_cache << get_string_index_in_cache("message")
+        variant.attribute_values << dump_raw_object(obj.message, current_depth + 1, config, log_object_errors)
+        @estimated_pending_bytes += 6 # Header + number + header + size
+
+        variant.attribute_names_in_cache << get_string_index_in_cache("cause")
+        variant.attribute_values << dump_raw_object(obj.cause, current_depth + 1, config, log_object_errors)
+        @estimated_pending_bytes += 6 # Header + number + header + size
+
+        variant.attribute_names_in_cache << get_string_index_in_cache("backtrace")
+        variant.attribute_values << dump_raw_object(obj.backtrace, current_depth + 1, config, log_object_errors)
+        @estimated_pending_bytes += 6 # Header + number + header + size
+      end
+
+      def dump_code_object obj, variant
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_CODE_OBJECT
+
+        if obj.is_a?(Proc) || obj.is_a?(Method)
+          source_location = obj.source_location
+        else
+          source_location = [nil, nil]
+        end
+
+        if obj.is_a? Proc
+          name = ""
+        else
+          name = obj.name
+        end
+
+        variant.code_values << Com::Rookout::Variant::CodeObject.new(name: name,
+                                                                     filename: source_location[0],
+                                                                     lineno: source_location[1])
+        # NOTE: This size is probably less, in Python we use the optional fields of CodeObject and in Ruby we don't,
+        # but it is better to estimate more
+        @estimated_pending_bytes += 14 # Header + size + (header + number) * 4
+      end
+
+      def dump_user_class variant, obj, current_depth, config, log_object_errors
+        weighted_children_depth = current_depth + 1
+        if weighted_children_depth <= config.max_collection_depth
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_OBJECT
+
+          obj.instance_variables.each do |name|
+            raw_value = obj.instance_variable_get name
+            variant.attribute_names_in_cache << get_string_index_in_cache(name.to_s)
+            variant.attribute_values << dump_raw_object(raw_value, weighted_children_depth, config, log_object_errors)
+            @estimated_pending_bytes += 6 # Header + number + header + number
+          end
+        else
+          dump_variant_type_max_depth variant, Com::Rookout::Variant::Type::VARIANT_OBJECT
+        end
+      end
+
+      def dump_container_namespace namespace, log_errors
+        variant = Com::Rookout::Variant2.new
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_NAMESPACE
+
+        namespace.hash.each do |key, value|
+          variant.attribute_names_in_cache << get_string_index_in_cache(key.to_s)
+          variant.attribute_values << dump(value, log_errors)
+        end
+
+        @estimated_pending_bytes += 4 # One number (packed field), One header + length
+
+        variant
+      end
+
+      def dump_traceback_namespace namespace
+        variant = Com::Rookout::Variant2.new
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_TRACEBACK
+
+        namespace.depth.times do |i|
+          position = i + namespace.offset
+          break if position >= namespace.backtrace.length
+          frame = namespace.backtrace[position]
+
+          code_object = Com::Rookout::Variant::CodeObject.new filename: frame.source_location[0],
+                                                              lineno: frame.source_location[1],
+                                                              name: frame.eval("__method__").to_s
+          variant.code_values << code_object
+          # See dump_code_object
+          @estimated_pending_bytes += 14 # Header + size + (header + number) * 4
+        end
+        variant
+      end
+    end
+  end
+end

data/lib/rookout/processor/namespaces/container_namespace.rb

@@ -8,11 +8,16 @@ module Rookout
 
       require_relative "../../protobuf/variant_pb"
 
+
       class ContainerNamespace < Namespace
         def initialize hash = {}
+          super()
           @hash = hash
         end
 
+        attr_reader :hash
+
+
         def call_method name, args
           return RubyObjectNamespace.new @hash.length if name == "size"
           super

data/lib/rookout/processor/namespaces/frame_namespace.rb

@@ -8,6 +8,7 @@ module Rookout
 
       class FrameNamespace < Namespace
         def initialize binding
+          super()
           @binding = binding
         end
 
@@ -19,14 +20,12 @@ module Rookout
 
         def call_method name, args
           case name
-          when "filename"
+          when "filename", "module"
             RubyObjectNamespace.new @binding.source_location[0]
           when "line"
             RubyObjectNamespace.new @binding.source_location[1]
           when "function"
             RubyObjectNamespace.new @binding.eval("__method__").to_s
-          when "module"
-            RubyObjectNamespace.new @binding.source_location[0]
           when "locals"
             locals args
           when "dump"

data/lib/rookout/processor/namespaces/namespace.rb

@@ -3,6 +3,7 @@ module Rookout
     module Namespaces
       class Namespace
         require_relative "../../exceptions"
+
         def call_method name, _args
           raise Exceptions::RookMethodNotFound.new(self.class.to_s, name)
         end

data/lib/rookout/processor/namespaces/noop_namespace.rb

@@ -7,10 +7,6 @@ module Rookout
       require_relative "../../protobuf/variant_pb"
 
       class NoopNamespace < Namespace
-        def initialize
-          super
-        end
-
         def call_method _name, _args
           Rookout::Processor::Namespaces::RubyObjectNamespace.new nil
         end

data/lib/rookout/processor/namespaces/ruby_object_namespace.rb

@@ -17,15 +17,18 @@ module Rookout
           @max_string = max_string
         end
 
-        attr_reader :max_depth, :max_width, :max_collection_depth, :max_string
+        attr_reader :max_depth
+        attr_reader :max_width
+        attr_reader :max_collection_depth
+        attr_reader :max_string
       end
 
-      OBJECT_DUMP_CONFIG_STRICT = ObjectDumpConfig.new 2, 10, 1, 128
-      OBJECT_DUMP_CONFIG_DEFAULT = ObjectDumpConfig.new 4, 20, 2, 512
-      OBJECT_DUMP_CONFIG_TOLERANT = ObjectDumpConfig.new 5, 50, 4, 4 * 1024
+      OBJECT_DUMP_CONFIG_STRICT = ObjectDumpConfig.new 2, 10, 2, 128
+      OBJECT_DUMP_CONFIG_DEFAULT = ObjectDumpConfig.new 4, 15, 4, 512
+      OBJECT_DUMP_CONFIG_TOLERANT = ObjectDumpConfig.new 5, 20, 5, 4 * 1024
 
       OBJECT_DUMP_CONFIG_STRING = ObjectDumpConfig.new 1, 0, 0, 64 * 1024
-      OBJECT_DUMP_CONFIG_COLLECTION = ObjectDumpConfig.new 4, 100, 2, 512
+      OBJECT_DUMP_CONFIG_COLLECTION = ObjectDumpConfig.new 4, 100, 4, 512
 
       OBJECT_DUMP_TABLE = {
         "" => OBJECT_DUMP_CONFIG_DEFAULT,
@@ -37,17 +40,19 @@ module Rookout
       class RubyObjectNamespace < Namespace
         include RubyObjectSerializer
 
-        def initialize obj, dump_config = OBJECT_DUMP_CONFIG_DEFAULT
+        def initialize obj, dump_config = nil
+          super()
           @obj = obj
-          @dump_config = dump_config
+          @dump_config = dump_config || OBJECT_DUMP_CONFIG_DEFAULT
         end
 
-        attr_reader :obj, :dump_config
+        attr_reader :obj
+        attr_reader :dump_config
 
         def tailor_limits!
           if @obj.is_a? String
             @dump_config = OBJECT_DUMP_CONFIG_STRING
-          elsif @obj.is_a?(Hash) || @obj.is_a?(Array)
+          elsif (@obj.is_a?(Hash) || @obj.is_a?(Array)) && @obj.length > OBJECT_DUMP_CONFIG_TOLERANT.max_width
             @dump_config = OBJECT_DUMP_CONFIG_COLLECTION
           else
             @dump_config = OBJECT_DUMP_CONFIG_TOLERANT
@@ -62,20 +67,13 @@ module Rookout
         end
 
         def read_key key
-          if @obj.is_a? Array
-            key_int = key.to_i
-            return RubyObjectNamespace.new @obj[key_int] if key_int >= 0 && key_int < @obj.length
-            raise Exceptions::RookKeyNotFound, key
-
-          elsif @obj.is_a? Hash
-            return RubyObjectNamespace.new @obj[key] if @obj.key? key
-            return RubyObjectNamespace.new @obj[key.to_sym] if key.is_a?(String) && @obj.key?(key.to_sym)
-
-            @obj.each { |it, value| return RubyObjectNamespace.new value if it.to_s == key }
-
-            raise Exceptions::RookKeyNotFound, key
+          case @obj
+          when Array, String
+            read_key_as_int key
+          when Hash
+            read_key_from_hash key
           else
-            raise Exceptions::RookInvalidObjectForAccess.new(obj.class.to_s, "ReadKey")
+            raise Exceptions::RookInvalidObjectForAccess.new(@obj.class.to_s, "ReadKey")
           end
         end
 
@@ -93,6 +91,23 @@ module Rookout
         def dump log_object_errors
           dump_raw_object @obj, 0, @dump_config, log_object_errors
         end
+
+        private
+
+        def read_key_as_int key
+          key_int = key.to_i
+          return RubyObjectNamespace.new @obj[key_int] if key_int >= 0 && key_int < @obj.length
+          raise Exceptions::RookKeyNotFound, key
+        end
+
+        def read_key_from_hash key
+          return RubyObjectNamespace.new @obj[key] if @obj.key? key
+          return RubyObjectNamespace.new @obj[key.to_sym] if @obj.key? key.to_s.to_sym
+
+          @obj.each { |it, value| return RubyObjectNamespace.new value if it.to_s == key }
+
+          raise Exceptions::RookKeyNotFound, key
+        end
       end
     end
   end

data/lib/rookout/processor/namespaces/ruby_object_serializer.rb

@@ -24,6 +24,7 @@ module Rookout
 
         # rubocop:disable Metrics/PerceivedComplexity
         # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Style/ClassEqualityComparison
         def unsafe_dump_object obj, current_depth, config, log_object_errors
           variant = create_base_variant obj, current_depth, config, log_object_errors
 
@@ -49,7 +50,7 @@ module Rookout
 
           variant
         end
-
+        # rubocop:enable Style/ClassEqualityComparison
         # rubocop:enable Metrics/CyclomaticComplexity
         # rubocop:enable Metrics/PerceivedComplexity
 
@@ -83,23 +84,24 @@ module Rookout
         INT64_MAX = (1 << 63) - 1
 
         def dump_numeric obj, variant
-          if obj == true
+          case obj
+          when true
             variant.variant_type = :VARIANT_INT
             variant.int_value = 1
-          elsif obj == false
+          when false
             variant.variant_type = :VARIANT_INT
             variant.int_value = 0
-          elsif obj.is_a? Integer
+          when Integer
             dump_integer obj, variant
-          elsif obj.is_a? Float
+          when Float
             variant.variant_type = :VARIANT_DOUBLE
             variant.double_value = obj.to_f
-          elsif obj.is_a? BigDecimal
+          when BigDecimal
             serialized_decimal = obj.to_s
             variant.variant_type = :VARIANT_STRING
             variant.string_value = Com::Rookout::Variant::String.new value: serialized_decimal,
                                                                      original_size: serialized_decimal.length
-          elsif obj.is_a? Complex
+          when Complex
             variant.variant_type = :VARIANT_COMPLEX
             variant.complex_value = Com::Rookout::Variant::Complex.new real: obj.real.to_f,
                                                                        imaginary: obj.imaginary.to_f

data/lib/rookout/processor/namespaces/ruby_utils_namespace.rb

@@ -9,10 +9,6 @@ module Rookout
       require_relative "ruby_object_namespace"
 
       class RubyUtilsNamespace < Namespace
-        def initialize
-          super
-        end
-
         def call_method name, args
           case name
           when "exception"

data/lib/rookout/processor/namespaces/stack_namespace.rb

@@ -7,6 +7,7 @@ module Rookout
 
       class StackNamespace < Namespace
         def initialize backtrace, offset = 0
+          super()
           @backtrace = backtrace
           @offset = offset
         end

data/lib/rookout/processor/namespaces/traceback_namespace.rb

@@ -8,11 +8,16 @@ module Rookout
 
       class TracebackNamespace < Namespace
         def initialize backtrace, offset, depth
+          super()
           @backtrace = backtrace
           @offset = offset
           @depth = depth
         end
 
+        attr_reader :backtrace
+        attr_reader :offset
+        attr_reader :depth
+
         def read_key key
           FrameNamespace.new @backtrace[key + @offset]
         end

data/lib/rookout/processor/operations/set_operation.rb

@@ -11,6 +11,8 @@ module Rookout
 
       class SetOperation < Operation
         def initialize configuration, factory
+          super()
+
           @paths = []
 
           configuration["paths"].each do |key, value|

data/lib/rookout/processor/paths/arithmetic_path.rb

@@ -13,6 +13,8 @@ module Rookout
 
       class ArithmeticPath < Path
         def initialize path
+          super()
+
           if path.is_a? Hash
             path = path["path"] || path[:path]
           end
@@ -20,7 +22,7 @@ module Rookout
           @raw_path = path
 
           if path.start_with?("NOT(") && path.end_with?(")")
-            @path = path["NOT(".length..-2]
+            @path = path[("NOT(".length)..-2]
             @negation = true
           else
             @path = path
@@ -33,7 +35,7 @@ module Rookout
         def read_from namespace
           begin
             result = Maps.parse @path, actions: Canopy::Actions.new(namespace)
-          rescue Maps::ParseError => e
+          rescue Maps::ParseError, NameError => e
             raise RookInvalidArithmeticPath.new(@path, e)
           end
 

data/lib/rookout/processor/paths/canopy/actions.rb

@@ -79,6 +79,8 @@ module Rookout
           end
 
           # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/CyclomaticComplexity
+          # rubocop:disable Metrics/PerceivedComplexity
           def make_comp_exp _input, _start, _finish, elements
             # We can assume the following: atom ( opt_ atom )*
             # the first (which must be) will be simple atom
@@ -108,7 +110,7 @@ module Rookout
                 flat_elements.each_with_index do |e, index|
                   if e.is_a?(Opt) && e.level == level
                     result = e.execute_operation flat_elements[index - 1], flat_elements[index + 1]
-                    flat_elements = flat_elements[0...index - 1] + [result] + flat_elements[index + 2..-1]
+                    flat_elements = flat_elements[0...index - 1] + [result] + flat_elements[index + 2..]
                     restart_scan = true
                     break
                   end
@@ -122,6 +124,8 @@ module Rookout
 
             flat_elements[0]
           end
+          # rubocop:enable Metrics/PerceivedComplexity
+          # rubocop:enable Metrics/CyclomaticComplexity
           # rubocop:enable Metrics/AbcSize
 
           def make_opt _input, _start, _finish, elements

data/lib/rookout/processor/paths/canopy/consts.rb

@@ -50,9 +50,10 @@ module Rookout
             # If it's a dict, scan the keys, compensating for additional abstraction
             if b.is_a? Hash
               b.each_key do |key|
-                if key.is_a? ObjectMarker
+                case key
+                when ObjectMarker
                   return true if key.obj == a
-                elsif key == a
+                when a
                   return true
                 end
               end
@@ -62,9 +63,10 @@ module Rookout
             # If it's an array, scan the value, compensating for additional abstraction
             if b.is_a? Array
               b.each do |value|
-                if value.is_a? ObjectMarker
+                case value
+                when ObjectMarker
                   return true if value.obj == a
-                elsif value == a
+                when a
                   return true
                 end
               end