dead_end 1.2.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7db29aed59a901a58a0b1ed50873b6f2c17692f7724ffad2736b99694b78ba0
-  data.tar.gz: e1cf2a11fa38af85df30d89a559b0c6e5a74beec2c0add8b6f67dd142d793de1
+  metadata.gz: 72373898d38363c0ea0c3cec7fe2747399724ce55dae4eca1ce57b8f59dfc767
+  data.tar.gz: 9e99a5fddb8a054b839aef4fe1c2b87792bc9b4161bf5a6689156f2999dca935
 SHA512:
-  metadata.gz: 444cfdfd7df93038d1714729a21a3b7a20f9000e9cf0541521d51a125d00be4968e83bbc8a51bf4c4689e2b99706cf5eb0032a318647ecb3fd4452a343798e7a
-  data.tar.gz: c532b87160ae6231776b72ff68f3c8f940064051e14c27da28fa22a15c1be0060d9b2afd600bb66dd4571cd39b9372b1956782565040a5e159776f9dac9f9e62
+  metadata.gz: 7312a010846453f222bbb8717738831f9a2e23572eace345ed7738f00429c126d1a4760548ad9e7552237aee057b5c5bae90b7a0fe197144c3a9dc9d3db2ab0b
+  data.tar.gz: 0db2b356ab237f01eda6dc5ebeac0156c317d94535c2b59d099f766e1716d5d6f6b429edcc65bf439dea1bc15e1866f4d66a41cd28d927a29a666f54f54ee804

data/.circleci/config.yml

@@ -13,6 +13,14 @@ references:
       command: bundle exec standardrb
 
 jobs:
+  "ruby-2-5":
+    docker:
+      - image: circleci/ruby:2.5
+    steps:
+      - checkout
+      - ruby/install-deps
+      - <<: *unit
+
   "ruby-2-6":
     docker:
       - image: circleci/ruby:2.6
@@ -49,6 +57,7 @@ workflows:
   version: 2
   build:
     jobs:
+      - "ruby-2-5"
       - "ruby-2-6"
       - "ruby-2-7"
       - "ruby-3-0"

data/.github/workflows/check_changelog.yml

@@ -1,13 +1,20 @@
 name: Check Changelog
 
 on:
- pull_request:
-  types: [opened, reopened, edited, synchronize]
+  pull_request:
+    types: [opened, reopened, edited, labeled, unlabeled, synchronize]
+
 jobs:
-  build:
+  check-changelog:
     runs-on: ubuntu-latest
+    if: |
+      !contains(github.event.pull_request.body, '[skip changelog]') &&
+      !contains(github.event.pull_request.body, '[changelog skip]') &&
+      !contains(github.event.pull_request.body, '[skip ci]') &&
+      !contains(github.event.pull_request.labels.*.name, 'skip changelog')
     steps:
-    - uses: actions/checkout@v1
-    - name: Check that CHANGELOG is touched
-      run: |
-        cat $GITHUB_EVENT_PATH | jq .pull_request.title |  grep -i '\[\(\(changelog skip\)\|\(ci skip\)\)\]' ||  git diff remotes/origin/${{ github.base_ref }} --name-only | grep CHANGELOG.md
+      - uses: actions/checkout@v2.3.5
+      - name: Check that CHANGELOG is touched
+        run: |
+          git fetch origin ${{ github.base_ref }} --depth 1 && \
+          git diff remotes/origin/${{ github.base_ref }} --name-only | grep CHANGELOG.md

data/.standard.yml

@@ -1 +1 @@
-ruby_version: 2.6.6
+ruby_version: 2.5.9

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 ## HEAD (unreleased)
 
+## 3.0.0
+
+- [Breaking] Remove previously deprecated `require "dead_end/fyi"` interface (https://github.com/zombocom/dead_end/pull/94)
+- Fix double output bug (https://github.com/zombocom/dead_end/pull/99)
+- Fix bug causing poor results (fix #95, fix #88) (https://github.com/zombocom/dead_end/pull/96)
+- DeadEnd is now fired on EVERY syntax error (https://github.com/zombocom/dead_end/pull/94)
+- Output format changes:
+  - Parse errors emitted per-block rather than for the whole document (https://github.com/zombocom/dead_end/pull/94)
+  - The "banner" is now based on lexical analysis rather than parser regex (fix #68, fix #87) (https://github.com/zombocom/dead_end/pull/96)
+
+## 2.0.2
+
+- Don't print terminal color codes when output is not tty (https://github.com/zombocom/dead_end/pull/91)
+
+## 2.0.1
+
+- Reintroduce Ruby 2.5 support (https://github.com/zombocom/dead_end/pull/90)
+- Support naked braces/brackets/parens, invert labels on banner (https://github.com/zombocom/dead_end/pull/89)
+- Handle mismatched end when using rescue without begin (https://github.com/zombocom/dead_end/pull/83)
+- CLI returns non-zero exit code when syntax error is found (https://github.com/zombocom/dead_end/pull/86)
+- Let -v respond with gem version instead of 'unknown' (https://github.com/zombocom/dead_end/pull/82)
+
+## 2.0.0
+
+- Support "endless" oneline method definitions for Ruby 3+ (https://github.com/zombocom/dead_end/pull/80)
+- Reduce timeout to 1 second (https://github.com/zombocom/dead_end/pull/79)
+- Logically consecutive lines (such as chained methods are now joined) (https://github.com/zombocom/dead_end/pull/78)
+- Output improvement for cases where the only line is an single `end` (https://github.com/zombocom/dead_end/pull/78)
+
 ## 1.2.0
 
 - Output improvements via less greedy unmatched kw capture https://github.com/zombocom/dead_end/pull/73

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dead_end (1.2.0)
+    dead_end (3.0.0)
 
 GEM
   remote: https://rubygems.org/
@@ -60,4 +60,4 @@ DEPENDENCIES
   standard
 
 BUNDLED WITH
-   2.2.27
+   2.2.29

data/README.md

@@ -2,19 +2,14 @@
 
 An error in your code forces you to stop. DeadEnd helps you find those errors to get you back on your way faster.
 
-    DeadEnd: Unmatched `end` detected
-
-    This code has an unmatched `end`. Ensure that all `end` lines
-    in your code have a matching syntax keyword  (`def`,  `do`, etc.)
-    and that you don't have any extra `end` lines.
-
-    file: path/to/dog.rb
-    simplified:
+```
+Unmatched `end', missing keyword (`do', `def`, `if`, etc.) ?
 
-       3  class Dog
-    ❯  5    defbark
-    ❯  7    end
-      12  end
+  1  class Dog
+❯ 2    defbark
+❯ 4    end
+  5  end
+```
 
 ## Installation in your codebase
 
@@ -52,34 +47,99 @@ This gives you the CLI command `$ dead_end` for more info run `$ dead_end --help
 
 ## What syntax errors does it handle?
 
+Dead end will fire against all syntax errors and can isolate any syntax error. In addition, dead_end attempts to produce human readable descriptions of what needs to be done to resolve the issue. For example:
+
 - Missing `end`:
 
+<!--
 ```ruby
 class Dog
   def bark
     puts "bark"
-
-  def woof
-    puts "woof"
-  end
 end
-# => scratch.rb:8: syntax error, unexpected end-of-input, expecting `end'
 ```
+-->
 
-- Unexpected `end`
+```
+Unmatched keyword, missing `end' ?
 
+❯ 1  class Dog
+❯ 2    def bark
+❯ 4  end
+```
+
+- Missing keyword
+<!--
 ```ruby
 class Dog
   def speak
-    @sounds.each |sound| # Note the missing `do` here
+    @sounds.each |sound|
       puts sound
     end
   end
 end
-# => scratch.rb:7: syntax error, unexpected `end', expecting end-of-input
 ```
+-->
 
-As well as unmatched `|` and unmatched `}`. These errors can be time consuming to debug because Ruby often only tells you the last line in the file. The command `ruby -wc path/to/file.rb` can narrow it down a little bit, but this library does a better job.
+```
+Unmatched `end', missing keyword (`do', `def`, `if`, etc.) ?
+
+  1  class Dog
+  2    def speak
+❯ 3      @sounds.each |sound|
+❯ 5      end
+  6    end
+  7  end
+```
+
+- Missing pair characters (like `{}`, `[]`, `()` , or `|<var>|`)
+<!--
+
+```ruby
+class Dog
+  def speak(sound
+    puts sound
+  end
+end
+```
+-->
+
+```
+Unmatched `(', missing `)' ?
+
+  1  class Dog
+❯ 2    def speak(sound
+❯ 4    end
+  5  end
+```
+
+- Any ambiguous or unknown errors will be annotated by the original ripper error output:
+
+<!--
+class Dog
+  def meals_last_month
+    puts 3 *
+  end
+end
+-->
+
+```
+syntax error, unexpected end-of-input
+
+  1  class Dog
+  2    def meals_last_month
+❯ 3      puts 3 *
+  4    end
+  5  end
+```
+
+## How is it better than `ruby -wc`?
+
+Ruby allows you to syntax check a file with warnings using `ruby -wc`. This emits a parser error instead of a human focused error. Ruby's parse errors attempt to narrow down the location and can tell you if there is a glaring indentation error involving `end`.
+
+The `dead_end` algorithm doesn't just guess at the location of syntax errors, it re-parses the document to prove that it captured them.
+
+This library focuses on the human side of syntax errors. It cares less about why the document could not be parsed (computer problem) and more on what the programmer needs (human problem) to fix the problem.
 
 ## Sounds cool, but why isn't this baked into Ruby directly?
 
@@ -105,6 +165,14 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+### How to debug changes to output display
+
+You can see changes to output against a variety of invalid code by running specs and using the `DEBUG_DISPLAY=1` environment variable. For example:
+
+```
+$ DEBUG_DISPLAY=1 be rspec spec/ --format=failures
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/zombocom/dead_end. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/zombocom/dead_end/blob/master/CODE_OF_CONDUCT.md).

data/exe/dead_end

@@ -1,70 +1,7 @@
 #!/usr/bin/env ruby
 
-require "pathname"
-require "optparse"
 require_relative "../lib/dead_end"
 
-options = {}
-options[:terminal] = true
-options[:record_dir] = ENV["DEAD_END_RECORD_DIR"]
-
-parser = OptionParser.new do |opts|
-  opts.banner = <<~EOM
-    Usage: dead_end <file> [options]
-
-    Parses a ruby source file and searches for syntax error(s) such as
-    unexpected `end', expecting end-of-input.
-
-    Example:
-
-      $ dead_end dog.rb
-
-      # ...
-
-        ❯ 10  defdog
-        ❯ 15  end
-        ❯ 16
-
-    Env options:
-
-      DEAD_END_RECORD_DIR=<dir>
-
-      When enabled, records the steps used to search for a syntax error to the
-      given directory
-
-    Options:
-  EOM
-
-  opts.on("--help", "Help - displays this message") do |v|
-    puts opts
-    exit
-  end
-
-  opts.on("--record <dir>", "When enabled, records the steps used to search for a syntax error to the given directory") do |v|
-    options[:record_dir] = v
-  end
-
-  opts.on("--no-terminal", "Disable terminal highlighting") do |v|
-    options[:terminal] = false
-  end
-end
-parser.parse!
-
-file = ARGV[0]
-
-if file.nil? || file.empty?
-  # Display help if raw command
-  parser.parse! %w[--help]
-end
-
-file = Pathname(file)
-options[:record_dir] = "tmp" if ENV["DEBUG"]
-
-warn "Record dir: #{options[:record_dir]}" if options[:record_dir]
-
-DeadEnd.call(
-  source: file.read,
-  filename: file.expand_path,
-  terminal: options[:terminal],
-  record_dir: options[:record_dir]
-)
+DeadEnd::Cli.new(
+  argv: ARGV
+).call

data/lib/dead_end/around_block_scan.rb

@@ -9,10 +9,10 @@ module DeadEnd
   #
   # Example:
   #
-  #   def dog
-  #     puts "bark"
-  #     puts "bark"
-  #   end
+  #   def dog         # 1
+  #     puts "bark"   # 2
+  #     puts "bark"   # 3
+  #   end             # 4
   #
   #   scan = AroundBlockScan.new(
   #     code_lines: code_lines
@@ -22,7 +22,7 @@ module DeadEnd
   #   scan.scan_while { true }
   #
   #   puts scan.before_index # => 0
-  #   puts scan.after_index # => 3
+  #   puts scan.after_index  # => 3
   #
   # Contents can also be filtered using AroundBlockScan#skip
   #
@@ -109,8 +109,6 @@ module DeadEnd
       kw_count = 0
       end_count = 0
       after_lines.each do |line|
-        # puts "line: #{line.number} #{line.original_line}, indent: #{line.indent}, #{line.empty?} #{line.indent == @orig_indent}"
-
         next if line.empty?
         break if line.indent < @orig_indent
         next if line.indent != @orig_indent
@@ -124,7 +122,6 @@ module DeadEnd
 
         lines << line
       end
-      lines.select! { |line| !line.is_comment? }
 
       lines
     end
@@ -197,7 +194,7 @@ module DeadEnd
     end
 
     private def after_lines
-      @code_lines[after_index.next..] || []
+      @code_lines[after_index.next..-1] || []
     end
   end
 end

data/lib/dead_end/auto.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../dead_end/internals"
+require_relative "../dead_end"
 
 # Monkey patch kernel to ensure that all `require` calls call the same
 # method
@@ -33,23 +33,3 @@ module Kernel
     DeadEnd.handle_error(e)
   end
 end
-
-# I honestly have no idea why this Object delegation is needed
-# I keep staring at bootsnap and it doesn't have to do this
-# is there a bug in their implementation they haven't caught or
-# am I doing something different?
-class Object
-  private
-
-  def load(path, wrap = false)
-    Kernel.load(path, wrap)
-  rescue SyntaxError => e
-    DeadEnd.handle_error(e)
-  end
-
-  def require(path)
-    Kernel.require(path)
-  rescue SyntaxError => e
-    DeadEnd.handle_error(e)
-  end
-end

data/lib/dead_end/capture_code_context.rb

@@ -1,13 +1,27 @@
 # frozen_string_literal: true
 
 module DeadEnd
-  # Given a block, this method will capture surrounding
-  # code to give the user more context for the location of
-  # the problem.
+  # Turns a "invalid block(s)" into useful context
   #
-  # Return is an array of CodeLines to be rendered.
+  # There are three main phases in the algorithm:
   #
-  # Surrounding code is captured regardless of visible state
+  # 1. Sanitize/format input source
+  # 2. Search for invalid blocks
+  # 3. Format invalid blocks into something meaninful
+  #
+  # This class handles the third part.
+  #
+  # The algorithm is very good at capturing all of a syntax
+  # error in a single block in number 2, however the results
+  # can contain ambiguities. Humans are good at pattern matching
+  # and filtering and can mentally remove extraneous data, but
+  # they can't add extra data that's not present.
+  #
+  # In the case of known ambiguious cases, this class adds context
+  # back to the ambiguitiy so the programmer has full information.
+  #
+  # Beyond handling these ambiguities, it also captures surrounding
+  # code context information:
   #
   #   puts block.to_s # => "def bark"
   #
@@ -16,7 +30,8 @@ module DeadEnd
   #     code_lines: code_lines
   #   )
   #
-  #   puts context.call.join
+  #   lines = context.call.map(&:original)
+  #   puts lines.join
   #   # =>
   #     class Dog
   #       def bark
@@ -34,19 +49,34 @@ module DeadEnd
 
     def call
       @blocks.each do |block|
+        capture_first_kw_end_same_indent(block)
         capture_last_end_same_indent(block)
         capture_before_after_kws(block)
         capture_falling_indent(block)
       end
 
       @lines_to_output.select!(&:not_empty?)
-      @lines_to_output.select!(&:not_comment?)
       @lines_to_output.uniq!
       @lines_to_output.sort!
 
       @lines_to_output
     end
 
+    # Shows the context around code provided by "falling" indentation
+    #
+    # Converts:
+    #
+    #       it "foo" do
+    #
+    # into:
+    #
+    #   class OH
+    #     def hello
+    #       it "foo" do
+    #     end
+    #   end
+    #
+    #
     def capture_falling_indent(block)
       AroundBlockScan.new(
         block: block,
@@ -56,7 +86,36 @@ module DeadEnd
       end
     end
 
+    # Shows surrounding kw/end pairs
+    #
+    # The purpose of showing these extra pairs is due to cases
+    # of ambiguity when only one visible line is matched.
+    #
+    # For example:
+    #
+    #     1  class Dog
+    #     2    def bark
+    #     4    def eat
+    #     5    end
+    #     6  end
+    #
+    # In this case either line 2 could be missing an `end` or
+    # line 4 was an extra line added by mistake (it happens).
+    #
+    # When we detect the above problem it shows the issue
+    # as only being on line 2
+    #
+    #     2    def bark
+    #
+    # Showing "neighbor" keyword pairs gives extra context:
+    #
+    #     2    def bark
+    #     4    def eat
+    #     5    end
+    #
     def capture_before_after_kws(block)
+      return unless block.visible_lines.count == 1
+
       around_lines = AroundBlockScan.new(code_lines: @code_lines, block: block)
         .start_at_next_line
         .capture_neighbor_context
@@ -66,9 +125,10 @@ module DeadEnd
       @lines_to_output.concat(around_lines)
     end
 
-    # When there is an invalid with a keyword
-    # right before an end, it's unclear where
-    # the correct code should be.
+    # When there is an invalid block with a keyword
+    # missing an end right before another end,
+    # it is unclear where which keyword is missing the
+    # end
     #
     # Take this example:
     #
@@ -87,20 +147,21 @@ module DeadEnd
     # line 4. Also work backwards and if there's a mis-matched keyword, show it
     # too
     def capture_last_end_same_indent(block)
-      start_index = block.visible_lines.first.index
-      lines = @code_lines[start_index..block.lines.last.index]
+      return if block.visible_lines.length != 1
+      return unless block.visible_lines.first.is_kw?
+
+      visible_line = block.visible_lines.first
+      lines = @code_lines[visible_line.index..block.lines.last.index]
 
       # Find first end with same indent
       # (this would return line 4)
       #
       #   end             # 4
-      matching_end = lines.find { |line| line.indent == block.current_indent && line.is_end? }
+      matching_end = lines.detect { |line| line.indent == block.current_indent && line.is_end? }
       return unless matching_end
 
       @lines_to_output << matching_end
 
-      lines = @code_lines[start_index..matching_end.index]
-
       # Work backwards from the end to
       # see if there are mis-matched
       # keyword/end pairs
@@ -113,7 +174,7 @@ module DeadEnd
       #   end             # 4
       end_count = 0
       kw_count = 0
-      kw_line = lines.reverse.detect do |line|
+      kw_line = @code_lines[visible_line.index..matching_end.index].reverse.detect do |line|
         end_count += 1 if line.is_end?
         kw_count += 1 if line.is_kw?
 
@@ -122,5 +183,51 @@ module DeadEnd
       return unless kw_line
       @lines_to_output << kw_line
     end
+
+    # The logical inverse of `capture_last_end_same_indent`
+    #
+    # When there is an invalid block with an `end`
+    # missing a keyword right after another `end`,
+    # it is unclear where which end is missing the
+    # keyword.
+    #
+    # Take this example:
+    #
+    #   class Dog       # 1
+    #       puts "woof" # 2
+    #     end           # 3
+    #   end             # 4
+    #
+    # the problem line will be identified as:
+    #
+    #  ❯ end            # 4
+    #
+    # This happens because lines 1, 2, and 3 are technically valid code and are expanded
+    # first, deemed valid, and hidden. We need to un-hide the matching keyword on
+    # line 1. Also work backwards and if there's a mis-matched end, show it
+    # too
+    def capture_first_kw_end_same_indent(block)
+      return if block.visible_lines.length != 1
+      return unless block.visible_lines.first.is_end?
+
+      visible_line = block.visible_lines.first
+      lines = @code_lines[block.lines.first.index..visible_line.index]
+      matching_kw = lines.reverse.detect { |line| line.indent == block.current_indent && line.is_kw? }
+      return unless matching_kw
+
+      @lines_to_output << matching_kw
+
+      kw_count = 0
+      end_count = 0
+      orphan_end = @code_lines[matching_kw.index..visible_line.index].detect do |line|
+        kw_count += 1 if line.is_kw?
+        end_count += 1 if line.is_end?
+
+        end_count >= kw_count
+      end
+
+      return unless orphan_end
+      @lines_to_output << orphan_end
+    end
   end
 end