solargraph 0.59.0.dev.1 → 0.59.0.dev.2

data/lib/solargraph/pin/method.rb

@@ -23,6 +23,7 @@ module Solargraph
       # @param signatures [::Array<Signature>, nil]
       # @param anon_splat [Boolean]
       # @param context [ComplexType, ComplexType::UniqueType, nil]
+      # @param [Hash{Symbol => Object}] splat
       def initialize visibility: :public, explicit: true, block: :undefined, node: nil, attribute: false, signatures: nil, anon_splat: false,
                      context: nil, **splat
         super(**splat)
@@ -38,7 +39,7 @@ module Solargraph
 
       # @param other [Pin::Method]
       # @return [::Symbol]
-      def combine_visibility(other)
+      def combine_visibility other
         if dodgy_visibility_source? && !other.dodgy_visibility_source?
           other.visibility
         elsif other.dodgy_visibility_source? && !dodgy_visibility_source?
@@ -48,16 +49,16 @@ module Solargraph
         end
       end
 
-      def combine_with(other, attrs = {})
+      def combine_with other, attrs = {}
         priority_choice = choose_priority(other)
         return priority_choice unless priority_choice.nil?
 
         sigs = combine_signatures(other)
-        parameters = if sigs.length > 0
-          [].freeze
-        else
-          choose(other, :parameters).clone.freeze
-        end
+        parameters = if sigs.length.positive?
+                       [].freeze
+                     else
+                       choose(other, :parameters).clone.freeze
+                     end
         new_attrs = {
           visibility: combine_visibility(other),
           explicit: explicit? || other.explicit?,
@@ -77,7 +78,7 @@ module Solargraph
         super && other.node == node
       end
 
-      def transform_types(&transform)
+      def transform_types &transform
         # @todo 'super' alone should work here I think, but doesn't typecheck at level typed
         m = super(&transform)
         m.signatures = m.signatures.map do |sig|
@@ -92,14 +93,12 @@ module Solargraph
       def reset_generated!
         super
         unless signatures.empty?
-          return_type = nil
           @block = :undefined
-          parameters = []
+          []
         end
         block&.reset_generated!
         @signatures&.each(&:reset_generated!)
-        signature_help = nil
-        documentation = nil
+        nil
       end
 
       def all_rooted?
@@ -108,7 +107,7 @@ module Solargraph
 
       # @param signature [Pin::Signature]
       # @return [Pin::Method]
-      def with_single_signature(signature)
+      def with_single_signature signature
         m = proxy signature.return_type
         m.reset_generated!
         # @todo populating the single parameters/return_type/block
@@ -150,7 +149,7 @@ module Solargraph
       # @param parameters [::Array<Parameter>]
       # @param return_type [ComplexType, nil]
       # @return [Signature]
-      def generate_signature(parameters, return_type)
+      def generate_signature parameters, return_type
         # @type [Pin::Signature, nil]
         block = nil
         yieldparam_tags = docstring.tags(:yieldparam)
@@ -172,8 +171,7 @@ module Solargraph
               comments: p.text,
               name: name,
               decl: decl,
-              # @sg-ignore flow sensitive typing needs to handle attrs
-              presence: location ? location.range : nil,
+              presence: location&.range,
               return_type: ComplexType.try_parse(*p.types),
               source: source
             )
@@ -194,7 +192,11 @@ module Solargraph
           top_type = generate_complex_type
           result = []
           result.push generate_signature(parameters, top_type) if top_type.defined?
-          result.concat(overloads.map { |meth| generate_signature(meth.parameters, meth.return_type) }) unless overloads.empty?
+          unless overloads.empty?
+            result.concat(overloads.map do |meth|
+              generate_signature(meth.parameters, meth.return_type)
+            end)
+          end
           result.push generate_signature(parameters, @return_type || ComplexType::UNDEFINED) if result.empty?
           result
         end
@@ -214,12 +216,18 @@ module Solargraph
         # change when pins get proxied.
         detail = String.new
         detail += if signatures.length > 1
-          "(*) "
-        else
-          "(#{signatures.first.parameters.map(&:full).join(', ')}) " unless signatures.first.parameters.empty?
-        end.to_s
+                    '(*) '
+                  else
+                    "(#{signatures.first.parameters.map(&:full).join(', ')}) " unless signatures.first.parameters.empty?
+                  end.to_s
         # @sg-ignore Need to add nil check here
-        detail += "=#{probed? ? '~' : (proxied? ? '^' : '>')} #{return_type.to_s}" unless return_type.undefined?
+        unless return_type.undefined?
+          detail += "=#{if probed?
+                          '~'
+                        else
+                          (proxied? ? '^' : '>')
+                        end} #{return_type}"
+        end
         detail.strip!
         return nil if detail.empty?
         detail
@@ -229,7 +237,7 @@ module Solargraph
       def signature_help
         @signature_help ||= signatures.map do |sig|
           {
-            label: name + '(' + sig.parameters.map(&:full).join(', ') + ')',
+            label: "#{name}(#{sig.parameters.map(&:full).join(', ')})",
             documentation: documentation
           }
         end
@@ -258,7 +266,7 @@ module Solargraph
       end
 
       def path
-        @path ||= "#{namespace}#{(scope == :instance ? '#' : '.')}#{name}"
+        @path ||= "#{namespace}#{scope == :instance ? '#' : '.'}#{name}"
       end
 
       # @return [String]
@@ -267,11 +275,15 @@ module Solargraph
       end
 
       def typify api_map
-        # @sg-ignore Need to add nil check here
-        logger.debug { "Method#typify(self=#{self}, binder=#{binder}, closure=#{closure}, context=#{context.rooted_tags}, return_type=#{return_type.rooted_tags}) - starting" }
+        logger.debug do
+          # @sg-ignore Need to add nil check here
+          "Method#typify(self=#{self}, binder=#{binder}, closure=#{closure}, context=#{context.rooted_tags}, return_type=#{return_type.rooted_tags}) - starting"
+        end
         decl = super
         unless decl.undefined?
-          logger.debug { "Method#typify(self=#{self}, binder=#{binder}, closure=#{closure}, context=#{context}) => #{decl.rooted_tags.inspect} - decl found" }
+          logger.debug do
+            "Method#typify(self=#{self}, binder=#{binder}, closure=#{closure}, context=#{context}) => #{decl.rooted_tags.inspect} - decl found"
+          end
           return decl
         end
         type = see_reference(api_map) || typify_from_super(api_map)
@@ -289,26 +301,26 @@ module Solargraph
         if @documentation.nil?
           method_docs ||= super || ''
           param_tags = docstring.tags(:param)
-          unless param_tags.nil? or param_tags.empty?
+          unless param_tags.nil? || param_tags.empty?
             method_docs += "\n\n" unless method_docs.empty?
             method_docs += "Params:\n"
             lines = []
             param_tags.each do |p|
               l = "* #{p.name}"
-              l += " [#{escape_brackets(p.types.join(', '))}]" unless p.types.nil? or p.types.empty?
+              l += " [#{escape_brackets(p.types.join(', '))}]" unless p.types.nil? || p.types.empty?
               l += " #{p.text}"
               lines.push l
             end
             method_docs += lines.join("\n")
           end
           yieldparam_tags = docstring.tags(:yieldparam)
-          unless yieldparam_tags.nil? or yieldparam_tags.empty?
+          unless yieldparam_tags.nil? || yieldparam_tags.empty?
             method_docs += "\n\n" unless method_docs.empty?
             method_docs += "Block Params:\n"
             lines = []
             yieldparam_tags.each do |p|
               l = "* #{p.name}"
-              l += " [#{escape_brackets(p.types.join(', '))}]" unless p.types.nil? or p.types.empty?
+              l += " [#{escape_brackets(p.types.join(', '))}]" unless p.types.nil? || p.types.empty?
               l += " #{p.text}"
               lines.push l
             end
@@ -320,8 +332,8 @@ module Solargraph
             method_docs += "Block Returns:\n"
             lines = []
             yieldreturn_tags.each do |r|
-              l = "*"
-              l += " [#{escape_brackets(r.types.join(', '))}]" unless r.types.nil? or r.types.empty?
+              l = '*'
+              l += " [#{escape_brackets(r.types.join(', '))}]" unless r.types.nil? || r.types.empty?
               l += " #{r.text}"
               lines.push l
             end
@@ -333,8 +345,8 @@ module Solargraph
             method_docs += "Returns:\n"
             lines = []
             return_tags.each do |r|
-              l = "*"
-              l += " [#{escape_brackets(r.types.join(', '))}]" unless r.types.nil? or r.types.empty?
+              l = '*'
+              l += " [#{escape_brackets(r.types.join(', '))}]" unless r.types.nil? || r.types.empty?
               l += " #{r.text}"
               lines.push l
             end
@@ -389,15 +401,14 @@ module Solargraph
                 comments: tag.docstring.all.to_s,
                 name: name,
                 decl: decl,
-                # @sg-ignore flow sensitive typing needs to handle attrs
-                presence: location ? location.range : nil,
+                presence: location&.range,
                 return_type: param_type_from_name(tag, src.first),
                 source: :overloads
               )
             end,
             closure: self,
             return_type: ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types)),
-            source: :overloads,
+            source: :overloads
           )
         end
         @overloads
@@ -416,13 +427,13 @@ module Solargraph
         return self unless docstring.ref_tags.any?
         docstring.ref_tags.each do |tag|
           ref = if tag.owner.to_s.start_with?(/[#.]/)
-            api_map.get_methods(namespace)
-                   .select { |pin| pin.path.end_with?(tag.owner.to_s) }
-                   .first
-          else
-            # @todo Resolve relative namespaces
-            api_map.get_path_pins(tag.owner.to_s).first
-          end
+                  api_map.get_methods(namespace)
+                         .select { |pin| pin.path.end_with?(tag.owner.to_s) }
+                         .first
+                else
+                  # @todo Resolve relative namespaces
+                  api_map.get_path_pins(tag.owner.to_s).first
+                end
           next unless ref
 
           docstring.add_tag(*ref.docstring.tags(:param))
@@ -438,11 +449,7 @@ module Solargraph
 
       protected
 
-      attr_writer :block
-
-      attr_writer :signature_help
-
-      attr_writer :documentation
+      attr_writer :block, :signature_help, :documentation, :return_type
 
       # @sg-ignore Need to add nil check here
       def dodgy_visibility_source?
@@ -450,22 +457,22 @@ module Solargraph
         # e.g. activesupport did not understand 'private' markings
         # inside 'class << self' blocks, but YARD did OK at it
         # @sg-ignore Need to add nil check here
-        source == :rbs && scope == :class && type_location&.filename&.include?('generated') && return_type.undefined? ||
+        (source == :rbs && scope == :class && type_location&.filename&.include?('generated') && return_type.undefined?) ||
           # YARD's RBS generator seems to miss a lot of should-be protected instance methods
-          source == :rbs && scope == :instance && namespace.start_with?('YARD::') ||
+          (source == :rbs && scope == :instance && namespace.start_with?('YARD::')) ||
           # private on attr_readers seems to be broken in Prism's auto-generator script
-          source == :rbs && scope == :instance && namespace.start_with?('Prism::') ||
+          (source == :rbs && scope == :instance && namespace.start_with?('Prism::')) ||
           # The RBS for the RBS gem itself seems to use private as a
           # 'is this a public API' concept, more aggressively than the
           # actual code.  Let's respect that and ignore the actual .rb file.
-          source == :yardoc && scope == :instance && namespace.start_with?('RBS::')
+          (source == :yardoc && scope == :instance && namespace.start_with?('RBS::'))
       end
 
       private
 
       # @param other [Pin::Method]
       # @return [Array<Pin::Signature>]
-      def combine_signatures(other)
+      def combine_signatures other
         all_undefined = signatures.all? { |sig| !sig.return_type&.defined? }
         other_all_undefined = other.signatures.all? { |sig| !sig.return_type&.defined? }
         if all_undefined && !other_all_undefined
@@ -497,16 +504,14 @@ module Solargraph
       # @param same_type_arity_signatures [Array<Pin::Signature>]
       #
       # @return [Array<Pin::Signature>]
-      def combine_same_type_arity_signatures(same_type_arity_signatures)
+      def combine_same_type_arity_signatures same_type_arity_signatures
         # This is an O(n^2) operation, so bail out if n is not small
         return same_type_arity_signatures if same_type_arity_signatures.length > 10
 
         # @param old_signatures [Array<Pin::Signature>]
         # @param new_signature [Pin::Signature]
         same_type_arity_signatures.reduce([]) do |old_signatures, new_signature|
-          next [new_signature] if old_signatures.empty?
-
-          found_merge = false
+          next old_signatures + [new_signature] if old_signatures.empty?
           old_signatures.flat_map do |old_signature|
             potential_new_signature = old_signature.combine_with(new_signature)
 
@@ -560,7 +565,7 @@ module Solargraph
       # @param name [String]
       #
       # @return [ComplexType]
-      def param_type_from_name(tag, name)
+      def param_type_from_name tag, name
         # @param t [YARD::Tags::Tag]
         param = tag.tags(:param).select { |t| t.name == name }.first
         return ComplexType::UNDEFINED unless param
@@ -571,7 +576,7 @@ module Solargraph
       def generate_complex_type
         tags = docstring.tags(:return).map(&:types).flatten.compact
         return ComplexType::UNDEFINED if tags.empty?
-        ComplexType.try_parse *tags
+        ComplexType.try_parse(*tags)
       end
 
       # @param api_map [ApiMap]
@@ -635,7 +640,7 @@ module Solargraph
         return nil if node.nil?
         return node.children[1].children.last if node.type == :DEFN
         return node.children[2].children.last if node.type == :DEFS
-        return node.children[2] if node.type == :def || node.type == :DEFS
+        return node.children[2] if %i[def DEFS].include?(node.type)
         return node.children[3] if node.type == :defs
         nil
       end
@@ -648,7 +653,7 @@ module Solargraph
         has_nil = false
         return ComplexType::NIL if method_body_node.nil?
         returns_from_method_body(method_body_node).each do |n|
-          if n.nil? || [:NIL, :nil].include?(n.type)
+          if n.nil? || %i[NIL nil].include?(n.type)
             has_nil = true
             next
           end
@@ -688,12 +693,12 @@ module Solargraph
       #
       # @param name [String]
       # @return [::Array(String, ::Symbol)]
-      def parse_overload_param(name)
+      def parse_overload_param name
         # @todo this needs to handle mandatory vs not args, kwargs, blocks, etc
         if name.start_with?('**')
-          [name[2..-1], :kwrestarg]
+          [name[2..], :kwrestarg]
         elsif name.start_with?('*')
-          [name[1..-1], :restarg]
+          [name[1..], :restarg]
         else
           [name, :arg]
         end
@@ -711,10 +716,6 @@ module Solargraph
         .join("\n")
         .concat("```\n")
       end
-
-      protected
-
-      attr_writer :return_type
     end
   end
 end

data/lib/solargraph/pin/namespace.rb

@@ -20,13 +20,14 @@ module Solargraph
       # @param visibility [::Symbol] :public or :private
       # @param gates [::Array<String>]
       # @param name [String]
+      # @param [Hash{Symbol => Object}] splat
       def initialize type: :class, visibility: :public, gates: [''], name: '', **splat
         # super(location, namespace, name, comments)
         super(**splat, name: name)
         @type = type
         @visibility = visibility
         if name.start_with?('::')
-          name = name[2..-1] || ''
+          name = name[2..] || ''
           @closure = Solargraph::Pin::ROOT_PIN
         end
         @open_gates = gates
@@ -36,11 +37,11 @@ module Solargraph
           parts = name.split('::')
           name = parts.pop
           closure_name = if [Solargraph::Pin::ROOT_PIN, nil].include?(closure)
-            ''
-          else
-            # @sg-ignore Need to add nil check here
-            closure.full_context.namespace + '::'
-          end
+                           ''
+                         else
+                           # @sg-ignore Need to add nil check here
+                           "#{closure.full_context.namespace}::"
+                         end
           closure_name += parts.join('::')
           @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')], source: :namespace)
           @context = nil
@@ -55,7 +56,7 @@ module Solargraph
       end
 
       def to_rbs
-        "#{@type.to_s} #{return_type.all_params.first.to_rbs}#{rbs_generics}".strip
+        "#{@type} #{return_type.all_params.first.to_rbs}#{rbs_generics}".strip
       end
 
       def inner_desc
@@ -97,7 +98,7 @@ module Solargraph
       end
 
       def return_type
-        @return_type ||= ComplexType.try_parse( (type == :class ? '::Class' : '::Module') + "<::#{path}>")
+        @return_type ||= ComplexType.try_parse((type == :class ? '::Class' : '::Module') + "<::#{path}>")
       end
 
       # @return [Array<String>]
@@ -111,10 +112,10 @@ module Solargraph
 
       def gates
         @gates ||= if path.empty?
-          @open_gates
-        else
-          [path] + @open_gates
-        end
+                     @open_gates
+                   else
+                     [path] + @open_gates
+                   end
       end
     end
   end

data/lib/solargraph/pin/parameter.rb

@@ -15,6 +15,7 @@ module Solargraph
 
       # @param decl [::Symbol] :arg, :optarg, :kwarg, :kwoptarg, :restarg, :kwrestarg, :block, :blockarg
       # @param asgn_code [String, nil]
+      # @param [Hash{Symbol => Object}] splat
       def initialize decl: :arg, asgn_code: nil, **splat
         super(**splat)
         @asgn_code = asgn_code
@@ -29,7 +30,7 @@ module Solargraph
         super || closure&.type_location
       end
 
-      def combine_with(other, attrs={})
+      def combine_with other, attrs = {}
         # Parameters can be combined with local variables
         new_attrs = if other.is_a?(Parameter)
                       {
@@ -45,7 +46,7 @@ module Solargraph
         super(other, new_attrs.merge(attrs))
       end
 
-      def combine_return_type(other)
+      def combine_return_type other
         out = super
         if out&.undefined?
           # allow our return_type method to provide a better type
@@ -56,12 +57,12 @@ module Solargraph
       end
 
       def keyword?
-        [:kwarg, :kwoptarg].include?(decl)
+        %i[kwarg kwoptarg].include?(decl)
       end
 
       def kwrestarg?
         # @sg-ignore flow sensitive typing needs to handle attrs
-        decl == :kwrestarg || (assignment && [:HASH, :hash].include?(assignment.type))
+        decl == :kwrestarg || (assignment && %i[HASH hash].include?(assignment.type))
       end
 
       def needs_consistent_name?
@@ -70,21 +71,21 @@ module Solargraph
 
       # @return [String]
       def arity_decl
-        name = (self.name || '(anon)')
-        type = (return_type&.to_rbs || 'untyped')
+        name = self.name || '(anon)'
+        return_type&.to_rbs || 'untyped'
         case decl
         when :arg
-          ""
+          ''
         when :optarg
-          "?"
+          '?'
         when :kwarg
           "#{name}:"
         when :kwoptarg
           "?#{name}:"
         when :restarg
-          "*"
+          '*'
         when :kwrestarg
-          "**"
+          '**'
         else
           "(unknown decl: #{decl})"
         end
@@ -112,11 +113,11 @@ module Solargraph
       end
 
       def rest?
-        decl == :restarg || decl == :kwrestarg
+        %i[restarg kwrestarg].include?(decl)
       end
 
       def block?
-        [:block, :blockarg].include?(decl)
+        %i[block blockarg].include?(decl)
       end
 
       def to_rbs
@@ -177,14 +178,15 @@ module Solargraph
         if @return_type.nil?
           @return_type = ComplexType::UNDEFINED
           found = param_tag
-          @return_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
+          @return_type = ComplexType.try_parse(*found.types) unless found.nil? || found.types.nil?
           # @sg-ignore flow sensitive typing should be able to handle redefinition
           if @return_type.undefined?
-            if decl == :restarg
+            case decl
+            when :restarg
               @return_type = ComplexType.try_parse('::Array')
-            elsif decl == :kwrestarg
+            when :kwrestarg
               @return_type = ComplexType.try_parse('::Hash')
-            elsif decl == :blockarg
+            when :blockarg
               @return_type = ComplexType.try_parse('::Proc')
             end
           end
@@ -217,7 +219,7 @@ module Solargraph
 
       # @param atype [ComplexType]
       # @param api_map [ApiMap]
-      def compatible_arg?(atype, api_map)
+      def compatible_arg? atype, api_map
         # make sure we get types from up the method
         # inheritance chain if we don't have them on this pin
         ptype = typify api_map
@@ -226,7 +228,7 @@ module Solargraph
         return true if atype.conforms_to?(api_map,
                                           ptype,
                                           :method_call,
-                                          [:allow_empty_params, :allow_undefined])
+                                          %i[allow_empty_params allow_undefined])
         ptype.generic?
       end
 
@@ -259,9 +261,7 @@ module Solargraph
       # @return [ComplexType]
       def typify_block_param api_map
         block_pin = closure
-        if block_pin.is_a?(Pin::Block) && block_pin.receiver && index
-          return block_pin.typify_parameters(api_map)[index]
-        end
+        return block_pin.typify_parameters(api_map)[index] if block_pin.is_a?(Pin::Block) && block_pin.receiver && index
         ComplexType::UNDEFINED
       end
 
@@ -279,11 +279,14 @@ module Solargraph
             found = p
             break
           end
-          if found.nil? and !index.nil?
-            found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
+          if found.nil? && !index.nil? && params[index] && (params[index].name.nil? || params[index].name.empty?)
+            found = params[index]
+          end
+          unless found.nil? || found.types.nil?
+            return ComplexType.try_parse(*found.types).qualify(api_map,
+                                                               # @sg-ignore Need to add nil check here
+                                                               *meth.closure.gates)
           end
-          # @sg-ignore Need to add nil check here
-          return ComplexType.try_parse(*found.types).qualify(api_map, *meth.closure.gates) unless found.nil? || found.types.nil?
         end
         ComplexType::UNDEFINED
       end
@@ -326,8 +329,6 @@ module Solargraph
         pins.each do |pin|
           params = pin.docstring.tags(:param)
           return params unless params.empty?
-        end
-        pins.each do |pin|
           params = see_reference(pin.docstring, api_map, skip)
           return params unless params.empty?
         end

data/lib/solargraph/pin/proxy_type.rb

@@ -7,6 +7,7 @@ module Solargraph
       # @param gates [Array<String>, nil] Namespaces to try while resolving non-rooted types
       # @param binder [ComplexType, ComplexType::UniqueType, nil]
       # @param gates [Array<String>, nil]
+      # @param [Hash{Symbol => Object}] splat
       def initialize return_type: ComplexType::UNDEFINED, binder: nil, gates: nil, **splat
         super(**splat)
         @gates = gates
@@ -22,6 +23,7 @@ module Solargraph
       # @param closure [Pin::Namespace, nil] Used as the closure for this pin
       # @param binder [ComplexType, ComplexType::UniqueType, nil]
       # @return [ProxyType]
+      # @param [Hash{Symbol => Object}] kwargs
       def self.anonymous context, closure: nil, binder: nil, **kwargs
         unless closure
           parts = context.namespace.split('::')

data/lib/solargraph/pin/reference.rb

@@ -12,7 +12,24 @@ module Solargraph
 
       attr_reader :generic_values
 
+      # A Reference is a pin that associates a type with another type.
+      # The existing type is marked as the closure.  The name of the
+      # type we're associating with it is the 'name' field, and
+      # subtypes are in the 'generic_values' field.
+      #
+      # These pins are a little different - the name is a rooted name,
+      # which may be relative or absolute, preceded with ::, not a
+      # fully qualified namespace, which is implicitly in the root
+      # namespace and is never preceded by ::.
+      #
+      # @todo can the above be represented in a less subtle way?
+      # @todo consider refactoring so that we can replicate more
+      # complex types like Hash{String => Integer} and has both key
+      # types and subtypes.
+      #
+      # @param name [String] rooted name of the referenced type
       # @param generic_values [Array<String>]
+      # @param [Hash{Symbol => Object}] splat
       def initialize generic_values: [], **splat
         super(**splat)
         @generic_values = generic_values

data/lib/solargraph/pin/search.rb

@@ -46,7 +46,7 @@ module Solargraph
           # @param b [self]
           # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           .sort { |a, b| b.match <=> a.match }
-          .map(&:pin)
+             .map(&:pin)
       end
 
       # @param str1 [String]
@@ -54,7 +54,7 @@ module Solargraph
       #
       # @return [Float]
       def fuzzy_string_match str1, str2
-        return 1.0 + (str2.length.to_f / str1.length.to_f) if str1.downcase.include?(str2.downcase)
+        return 1.0 + (str2.length.to_f / str1.length) if str1.downcase.include?(str2.downcase)
         JaroWinkler.similarity(str1, str2, ignore_case: true)
       end
     end