offense_to_corrector 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3aa29d338b6fbe90a8b026e2a5a7008e4772bfe52b988a26856b6cd4c585a1b
-  data.tar.gz: 63a528f40daa7da31df15a872d66fc0181a72fb457b1e5c23885deb752dbe6f1
+  metadata.gz: 633ca47b27f11bd775d9fd27182d22586603b950b3e3c8ce6e3976162ead1fb1
+  data.tar.gz: 43e72f100670136da7907c3ea63d3298242974b40b2cf1f330cae73f5f366d60
 SHA512:
-  metadata.gz: b565e890a4a449467882d5ed53787990342fa5515c38e50f71653480594f4113bb564c1f353be2bdf879ca6cb9263dd9dbf5a58bef4b048e3106febaa303026b
-  data.tar.gz: 23de46b53c06aa98dfc0c4342cce5e4344c955187dbc7d65c5161e96271a7268a89f0fe09939a46a34e7b7f524ed37e24958eeddb647bf69e0a08170be13f41d
+  metadata.gz: cb3b1ebad0fb6a238d839cca290065d806ada04fbb9a03858e663befbf1994f5bb5bda222a9cd7bca5a3b0b299733f179fb1f5ce0a201be261101e3a908e0972
+  data.tar.gz: 7608dfcd7d6d04a8c4e53f3fc1f448ba5c89585f67a4c15ab25fe87cb0992ed731fdc3ee9590fb1f01b6145ef48f47f4c16f813d894cac91982cab1276ee6f2c

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
-## [0.1.0] - 2022-02-20
+## [0.0.2] - 2022-02-21
 
-- Initial release
+- Refined underlying algorithms for computing nearest nodes
+  - Range intersection dropped for string overlaps.
+  - Closest node implemented on length of overlap and percentage of node source
+    overlap to prevent matching higher-up parent nodes, but also avoid matching
+    entire small child nodes that aren't as relevant.
+- Fixed errors with unfindable atom nodes.
+- Broke apart mono-file into related subdirectories, added basic specs
+
+## [0.0.1] - 2022-02-20
+
+- Initial release.

data/Gemfile.lock

@@ -8,12 +8,44 @@ GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
+    coderay (1.1.3)
     diff-lcs (1.5.0)
+    ffi (1.15.5)
+    formatador (1.1.0)
+    guard (2.18.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (>= 1.0.12, < 2.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.13.0)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    listen (3.7.1)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    lumberjack (1.2.8)
+    method_source (1.0.0)
+    nenv (0.3.0)
+    notiffany (0.1.3)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
     parallel (1.21.0)
     parser (3.1.0.0)
       ast (~> 2.4.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
     rainbow (3.1.1)
     rake (13.0.6)
+    rb-fsevent (0.11.1)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
     regexp_parser (2.2.1)
     rexml (3.2.5)
     rspec (3.11.0)
@@ -41,12 +73,15 @@ GEM
     rubocop-ast (1.15.2)
       parser (>= 3.0.1.1)
     ruby-progressbar (1.11.0)
+    shellany (0.0.1)
+    thor (1.2.1)
     unicode-display_width (2.1.0)
 
 PLATFORMS
   x86_64-darwin-20
 
 DEPENDENCIES
+  guard-rspec
   offense_to_corrector!
   rake (~> 13.0)
   rspec (~> 3.0)

data/Guardfile

@@ -0,0 +1,14 @@
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/lib/offense_to_corrector/ast_tools.rb

@@ -0,0 +1,93 @@
+module OffenseToCorrector
+  module AstTools
+    def atom?(value)
+      !value.is_a?(RuboCop::AST::Node)
+    end
+
+    # I may have to work on getting this one later to try and
+    # narrow the band of `AtomNode`
+    # def childless?(node)
+    #   false # TODO
+    # end
+
+    def string_intersection(a, b)
+      # Smaller string inside larger string
+      target, search_string = a.size < b.size ? [a, b] : [b, a]
+
+      last_char_index = target.size.downto(1).find do |i|
+        search_string.include?(target[0..i])
+      end or return ""
+
+      target[0..last_char_index]
+    end
+
+    # How much do two ranges overlap? Used to see how well a node
+    # matches with the associated underline
+    def range_overlap_count(a, b)
+      return [a.end, b.end].min - b.begin if a.cover?(b.begin)
+      return [a.end, b.end].min - a.begin if b.cover?(a.begin)
+
+      0
+    end
+
+    # See if a range overlaps another one, bidirectional
+    def range_overlap?(a, b)
+      a.cover?(b.begin) || b.cover?(a.begin)
+    end
+
+    # To get an AST we need the processed source of a string
+    def processed_source_from(string)
+      RuboCop::ProcessedSource.new(string, RUBY_VERSION.to_f)
+    end
+
+    # So why bother with the above then? If we end up into correctors
+    # and tree-rewrites we need that original processed source to be
+    # the basis of the AST, otherwise we get object ID mismatches.
+    def ast_from(value)
+      case value
+      when RuboCop::ProcessedSource
+        value.ast
+      else
+        processed_source_from(value).ast
+      end
+    end
+
+    # Not needed quite yet, but could very potentially be used to verify
+    # how accurate generated cops are.
+    def get_corrector(value)
+      RuboCop::Cop::Corrector.new(value.buffer)
+    end
+
+    # Descendants leaves out a _lot_ of detail potentially. There has to
+    # be a better way to deal with this, but not thinking of one right now.
+    def get_children(source_node)
+      recurse = -> parent do
+        collected_children = []
+        parent.children.each do |child|
+          next if child.nil?
+
+          # If it's a regular parent carry on as you were
+          unless atom?(child) # || childless?(child)
+            collected_children.concat([child, *recurse[child]])
+            next
+          end
+
+          # Otherwise we want to find where that parent is in the source code,
+          # and the range it exists in, to create an `AtomNode`
+          source = child.to_s
+
+          parent_begin = parent.location.expression.to_range.begin
+          range_begin  = source_node.source.index(source, parent_begin)
+          range_end    = range_begin + source.size
+          range        = range_begin..range_end
+
+          collected_children << AtomNode.new(parent:, source:, range:)
+        end
+
+        collected_children
+      end
+
+      [source_node, *recurse[source_node]]
+    end
+  end
+end

data/lib/offense_to_corrector/atom_node.rb

@@ -0,0 +1,36 @@
+module OffenseToCorrector
+  # The annoying thing is that `RuboCop::AST::Node` 's children / descendant
+  # methods don't capture all the relevant data, so we have to cheat a bit
+  # by wrapping atoms (String, Symbol, Int, etc) in a class to get around that.
+  class AtomNode
+    attr_reader :source, :range, :parent
+
+    def initialize(source:, range:, parent:)
+      @source = source
+      @range = range
+      @parent = parent
+    end
+
+    def to_s
+      relevant_children = @parent.children.map do |child|
+        next "..." unless child.to_s == self.source.to_s # Wildcard
+
+        case child
+        when String then %("#{child}") # Literal string
+        when Symbol then ":#{child}"   # Literal symbol
+        when nil    then "nil?"
+        else child
+        end
+      end
+
+      # The trick here is that these aren't nodes, but we do care about
+      # what the "parent" is that contains it to get something we can
+      # work with. All other children are replaced with wildcards.
+      "(#{self.parent.type} #{relevant_children.join(' ')})"
+    end
+
+    def deconstruct_keys(keys)
+      { source:, range:, parent: }
+    end
+  end
+end

data/lib/offense_to_corrector/offense.rb

@@ -0,0 +1,35 @@
+module OffenseToCorrector
+  class Offense
+    # How many underline carots (^), and potentially an error after
+    OFFENSE_MATCH = /^ *?(?<underline>\^+) *?(?<error>.*)?$/
+
+    attr_reader :error, :range, :source
+
+    def initialize(error:, range:, source:)
+      @error = error
+      @range = range
+      @source = source
+    end
+
+    def deconstruct_keys(keys)
+      { error:, range:, source: }
+    end
+
+    # See if there's an underline, if so get how long it is and
+    # the error message after it
+    #
+    def self.parse(line:, previous_line:)
+      match_data = OFFENSE_MATCH.match(line) or return nil
+      underline  = match_data[:underline]
+      error      = match_data[:error].lstrip
+
+      underline_start = line.index(underline)
+      underline_end   = underline_start + underline.size
+      range           = underline_start...underline_end
+
+      source = previous_line.slice(range).chomp
+
+      new(error:, range:, source:)
+    end
+  end
+end

data/lib/offense_to_corrector/offense_parser.rb

@@ -0,0 +1,86 @@
+module OffenseToCorrector
+  class OffenseParser
+    include AstTools
+
+    attr_reader :ast, :source, :offense, :ast_nodes
+
+    def initialize(string)
+      @ast_lines,  @offense = parse_string(string)
+      @source = processed_source_from(@ast_lines.join("\n"))
+      @ast = ast_from(@source)
+      @ast_nodes = get_children(@ast)
+      @template = OffenseTemplate.new
+    end
+
+    # Render that into the cop skeleton. Perhaps having too much
+    # fun here with rightward assignment.
+    def render
+      call => {
+        offense: { error: },
+        node_offense_info: { offending_node:, offending_node_matcher: }
+      }
+
+      @template.render(
+        class_name: "TODO",
+        match_pattern: offending_node_matcher,
+        error_message: error,
+        node_type: offending_node.type,
+        cop_type: "Lint",
+        node_location: "selector",
+        offense_severity: "warning"
+      )
+    end
+
+    # Quick info on what all is being worked on and what info we got
+    def deconstruct_keys(keys)
+      { ast:, source:, offense:, node_offense_info: }
+    end
+
+    def node_offense_info
+      return @node_offense_info if defined?(@node_offense_info)
+
+      # Find the node, or atom, with the most overlap with the offense
+      # range defined by that underline. That's defined as a pair of
+      # the length of the intersection as well as what percentage that
+      # intersection makes of the full node source.
+      offending_node = @ast_nodes.max_by do |node|
+        intersection = string_intersection(node.source, @offense.source)
+        [intersection.size, intersection.size.fdiv(node.source.size)]
+      end
+
+      @node_offense_info ||= {
+        offending_node:,
+        offending_node_matcher: offending_node.to_s
+      }
+    end
+
+    private def node_range(node)
+      if node.is_a?(AtomNode)
+        node.range
+      else
+        node.location.expression.to_range
+      end
+    end
+
+    # Figure which part of the passed in code string is AST vs offense
+    private def parse_string(string)
+      ast_lines = []
+      offense = nil
+      lines = string.lines
+
+      lines.each_with_index do |line, i|
+        # No sense of a meta-line being above every other line
+        meta_info = i > 0 && Offense.parse(line:, previous_line: lines[i - 1])
+
+        if meta_info
+          raise "Cannot have multiple offenses" unless offense.nil?
+          offense = meta_info
+        else
+          ast_lines << line
+        end
+      end
+
+      [ast_lines, offense]
+    end
+  end
+end

data/lib/offense_to_corrector/offense_template.rb

@@ -0,0 +1,30 @@
+module OffenseToCorrector
+  # ERB template for rendering a cop skeleton, may make this more useful
+  # later, but mostly quick templating for now.
+  class OffenseTemplate
+    def initialize(name: "autocorrector_template.erb")
+      @template = File.read(OffenseToCorrector.load_template(name))
+      @erb = ERB.new(@template)
+    end
+
+    def render(
+      class_name: "TODO",
+      match_pattern:,
+      error_message: "",
+      node_type:,
+      cop_type: "Lint",
+      node_location: "selector",
+      offense_severity: "warning"
+    )
+      @erb.result_with_hash(
+        class_name:,
+        match_pattern:,
+        error_message:,
+        node_type:,
+        cop_type:,
+        node_location:,
+        offense_severity:
+      )
+    end
+  end
+end

data/lib/offense_to_corrector/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OffenseToCorrector
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/offense_to_corrector.rb

@@ -5,6 +5,12 @@ require_relative "offense_to_corrector/version"
 require "rubocop"
 require "erb"
 
+require "offense_to_corrector/atom_node"
+require "offense_to_corrector/ast_tools"
+require "offense_to_corrector/offense"
+require "offense_to_corrector/offense_parser"
+require "offense_to_corrector/offense_template"
+
 module OffenseToCorrector
   module_function def load_template(name)
     File.join(File.dirname(__FILE__), "offense_to_corrector/templates", name)
@@ -17,242 +23,4 @@ module OffenseToCorrector
   module_function def offense_to_cop(code)
     OffenseParser.new(code).render
   end
-
-  # The annoying thing is that `RuboCop::AST::Node` 's children / descendant
-  # methods don't capture all the relevant data, so we have to cheat a bit
-  # by wrapping atoms (String, Symbol, Int, etc) in a class to get around that.
-  AtomNode = Struct.new(:source, :range, :parent, keyword_init: true) do
-    def type
-      self.parent.type
-    end
-
-    def to_s
-      relevant_children = self.parent.children.map do |c|
-        next "..." unless c.to_s == self.source.to_s # Wildcard
-
-        case c
-        when String then %("#{c}") # Literal string
-        when Symbol then ":#{c}"   # Literal symbol
-        else c
-        end
-      end
-
-      # The trick here is that these aren't nodes, but we do care about
-      # what the "parent" is that contains it to get something we can
-      # work with. All other children are replaced with wildcards.
-      "(#{self.parent.type} #{relevant_children.join(' ')})"
-    end
-  end
-
-  module AstTools
-    def atom?(value)
-      !value.is_a?(RuboCop::AST::Node)
-    end
-
-    # I may have to work on getting this one later to try and
-    # narrow the band of `AtomNode`
-    # def childless?(node)
-    #   false # TODO
-    # end
-
-    # How much do two ranges overlap? Used to see how well a node
-    # matches with the associated underline
-    def range_overlap_count(a, b)
-      return (b.begin...[a.end, b.end].min).size if a.cover?(b.begin)
-      return (a.begin...[a.end, b.end].min).size if b.cover?(a.begin)
-
-      0
-    end
-
-    # See if a range overlaps another one, bidirectional
-    def range_overlap?(a, b)
-      a.cover?(b.begin) || b.cover?(a.begin)
-    end
-
-    # To get an AST we need the processed source of a string
-    def processed_source_from(string)
-      RuboCop::ProcessedSource.new(string, RUBY_VERSION.to_f)
-    end
-
-    # So why bother with the above then? If we end up into correctors
-    # and tree-rewrites we need that original processed source to be
-    # the basis of the AST, otherwise we get object ID mismatches.
-    def ast_from(value)
-      case value
-      when RuboCop::ProcessedSource
-        value.ast
-      else
-        processed_source_from(value).ast
-      end
-    end
-
-    # Not needed quite yet, but could very potentially be used to verify
-    # how accurate generated cops are.
-    def get_corrector(value)
-      RuboCop::Cop::Corrector.new(value.buffer)
-    end
-
-    # Descendants leaves out a _lot_ of detail potentially. There has to
-    # be a better way to deal with this, but not thinking of one right now.
-    def get_children(source_node)
-      recurse = -> node do
-        collected_children = []
-        node.children.each do |child|
-          next if child.nil?
-
-          # If it's a regular node carry on as you were
-          unless atom?(child) # || childless?(child)
-            collected_children.concat([child, *recurse[child]])
-            next
-          end
-
-          # Otherwise we want to find where that node is in the source code,
-          # and the range it exists in, to create an `AtomNode`
-          child_string = child.to_s
-          range_begin = source_node.source.index(/\b#{child_string}\b/)
-          range_end   = range_begin + child_string.size
-
-          collected_children << AtomNode.new(
-            parent: node,
-            source: child_string,
-            range: range_begin..range_end
-          )
-        end
-
-        collected_children
-      end
-
-      [source_node, *recurse[source_node]]
-    end
-  end
-
-  # ERB template for rendering a cop skeleton, may make this more useful
-  # later, but mostly quick templating for now.
-  class OffenseTemplate
-    def initialize(name: "autocorrector_template.erb")
-      @template = File.read(OffenseToCorrector.load_template(name))
-      @erb = ERB.new(@template)
-    end
-
-    def render(
-      class_name: "TODO",
-      match_pattern:,
-      error_message: "",
-      node_type:,
-      cop_type: "Lint",
-      node_location: "selector",
-      offense_severity: "warning"
-    )
-      @erb.result_with_hash(
-        class_name:,
-        match_pattern:,
-        error_message:,
-        node_type:,
-        cop_type:,
-        node_location:,
-        offense_severity:
-      )
-    end
-  end
-
-  # Bit more of a structured container for an offense (the underline)
-  Offense = Struct.new(:line, :error, :range, keyword_init: true)
-
-  class OffenseParser
-    include AstTools
-
-    # How many underline carots (^), and potentially an error after
-    OFFENSE_MATCH = /^ *?(?<underline>\^+) *?(?<error>.*)?$/
-
-    attr_reader :ast, :source, :offense
-
-    def initialize(string)
-      @ast_lines,  @offense = parse_string(string)
-      @source = processed_source_from(@ast_lines.join("\n"))
-      @ast = ast_from(@source)
-      @ast_nodes = get_children(@ast)
-      @template = OffenseTemplate.new
-    end
-
-    # Render that into the cop skeleton. Perhaps having too much
-    # fun here with rightward assignment.
-    def render
-      call => {
-        offense: { error: },
-        node_offense_info: { offending_node:, offending_node_matcher: }
-      }
-
-      @template.render(
-        class_name: "TODO",
-        match_pattern: offending_node_matcher,
-        error_message: error,
-        node_type: offending_node.type,
-        cop_type: "Lint",
-        node_location: "selector",
-        offense_severity: "warning"
-      )
-    end
-
-    # Quick info on what all is being worked on and what info we got
-    def call
-      { ast:, offense:, node_offense_info: }
-    end
-
-    def node_offense_info
-      return @node_offense_info if defined?(@node_offense_info)
-
-      # Find the node, or atom, with the most overlap with the offense
-      # range defined by that underline.
-      offending_node = @ast_nodes.max do |node|
-        node_range = if node.is_a?(AtomNode)
-          node.range
-        else
-          node.location.expression.to_range
-        end
-
-        # Except we're doing it as a percentage, otherwise parent nodes
-        # will dominate that count potentially. The closer to 100% overlap
-        # the better.
-        overlap_count = range_overlap_count(node_range, @offense[:range])
-        overlap_count.fdiv(node.source.size)
-      end
-
-      @node_offense_info ||= {
-        offending_node:,
-        offending_node_matcher: offending_node.to_s
-      }
-    end
-
-    # See if there's an underline, if so get how long it is and
-    # the error message after it
-    private def offending_meta_from(line)
-      match_data = OFFENSE_MATCH.match(line) or return nil
-      underline  = match_data[:underline]
-      error      = match_data[:error].lstrip
-
-      underline_start = line.index(underline)
-      underline_end   = underline_start + underline.size
-
-      { match_data:, error:, range: underline_start..underline_end }
-    end
-
-    # Figure which part of the passed in code string is AST vs offense
-    private def parse_string(string)
-      ast_lines = []
-      offense = nil
-
-      string.lines.each_with_index do |line, i|
-        meta_info = offending_meta_from(line)
-
-        if meta_info
-          raise "Cannot have multiple offenses" unless offense.nil?
-          offense = Offense.new(line: i, **meta_info.slice(:error, :range))
-        else
-          ast_lines << line
-        end
-      end
-
-      [ast_lines, offense]
-    end
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: offense_to_corrector
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Brandon Weaver
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description:
 email:
 - keystonelemur@gmail.com
@@ -36,10 +50,16 @@ files:
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/offense_to_corrector.rb
+- lib/offense_to_corrector/ast_tools.rb
+- lib/offense_to_corrector/atom_node.rb
+- lib/offense_to_corrector/offense.rb
+- lib/offense_to_corrector/offense_parser.rb
+- lib/offense_to_corrector/offense_template.rb
 - lib/offense_to_corrector/templates/autocorrector_template.erb
 - lib/offense_to_corrector/version.rb
 - sig/offense_to_corrector.rbs