syntax_search 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64d391c1ee60a9784b3b53ec9c404739b06dd390d263793795110cdc555bdfb0
-  data.tar.gz: 70cbe011308ad0c94c88240e5aadf4e7e024b0f83ff65377b99fe82550779ebc
+  metadata.gz: 66acadf6481512affd39e4a1fb691ed41a6be537a8a63801f71316863d30494d
+  data.tar.gz: 1bcb85706516cbe5c3f53a1ed48bf5215479672952fc62d2e3221c583e468b22
 SHA512:
-  metadata.gz: 119be89600a50534968502162df65d972a4fe1ecd93a70378e843cbe22effbe0d3f4a7fb12761740efa95152d81bf3a30abc79401cfbff4ba8ad89e9b9390a47
-  data.tar.gz: aa93927ba70886754499d263087c89a546d2791b8de3911175e365d7aa111b1d8d659dd3ae015e8297b75b62b9c4e4958c8e9f6c08ac9a4d444f18ccdc7ad8fb
+  metadata.gz: 4e60777bd284d78436db8608f34d11b4b5aa8456bfe0c9507ddf3a0e3b97b902a2d00d1537433ed914c637a0729ccb253fc9047fb6db9e3b18a8cc8d0294ae06
+  data.tar.gz: 2fb1b35e70507f4b358be4b767cbf266c2d47c55efba1b77d7ca5f260cac4e77d519fc7439f55c78c5294c0c87240d15b4cab3721c8cfd580b518f5051b7cd0c

data/.github/workflows/check_changelog.yml

@@ -0,0 +1,13 @@
+name: Check Changelog
+
+on:
+ pull_request:
+  types: [opened, reopened, edited, synchronize]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    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

data/CHANGELOG.md

@@ -1,8 +1,31 @@
 ## HEAD (unreleased)
 
+## 0.2.0
+
+- Simplify large file output so minimal context around the invalid section is shown (https://github.com/zombocom/syntax_search/pull/26)
+- Block expansion is now lexically aware of keywords (def/do/end etc.) (https://github.com/zombocom/syntax_search/pull/24)
+- Fix bug where not all of a source is lexed which is used in heredoc detection/removal (https://github.com/zombocom/syntax_search/pull/23)
+
+## 0.1.5
+
+- Strip out heredocs in documents first (https://github.com/zombocom/syntax_search/pull/19)
+
+## 0.1.4
+
+- Parser gem replaced with Ripper (https://github.com/zombocom/syntax_search/pull/17)
+
+## 0.1.3
+
+- Internal refactor (https://github.com/zombocom/syntax_search/pull/13)
+
+## 0.1.2
+
+- Codeblocks in output are now indented with 4 spaces and "code fences" are removed (https://github.com/zombocom/syntax_search/pull/11)
+- "Unmatched end" and "missing end" not generate different error text instructions (https://github.com/zombocom/syntax_search/pull/10)
+
 ## 0.1.1
 
-- Fix error message detection to fire on more rubies ()
+- Fire search on both unexpected end-of-input and unexected end (https://github.com/zombocom/syntax_search/pull/8)
 
 ## 0.1.0
 

data/Gemfile

@@ -7,3 +7,4 @@ gemspec
 
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
+gem "stackprof"

data/Gemfile.lock

@@ -1,16 +1,12 @@
 PATH
   remote: .
   specs:
-    syntax_search (0.1.1)
-      parser
+    syntax_search (0.2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    ast (2.4.1)
     diff-lcs (1.4.4)
-    parser (2.7.2.0)
-      ast (~> 2.4.1)
     rake (12.3.3)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
@@ -25,6 +21,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.0)
+    stackprof (0.2.16)
 
 PLATFORMS
   ruby
@@ -32,6 +29,7 @@ PLATFORMS
 DEPENDENCIES
   rake (~> 12.0)
   rspec (~> 3.0)
+  stackprof
   syntax_search!
 
 BUNDLED WITH

data/README.md

@@ -10,30 +10,29 @@ What happened? Likely you forgot a `def`, `do`, or maybe you deleted some code a
 
 What if I told you, that there was a library that helped find your missing `def`s and missing `do`s. What if instead of searching through hundreds of lines of source for the cause of your syntax error, there was a way to highlight just code in the file that contained syntax errors.
 
-    $ syntax_search <path/to/file.rb>
+    $ syntax_search path/to/file.rb
 
-    SyntaxErrorSearch: A syntax error was detected
+    SyntaxSearch: Unmatched `end` detected
 
-    This code has an unmatched `end` this is caused by either
-    missing a syntax keyword (`def`,  `do`, etc.) or inclusion
-    of an extra `end` line
+    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/file.rb
     simplified:
 
-    ```
-         1  require 'animals'
-         2
-      ❯ 10  defdog
-      ❯ 15  end
-      ❯ 16
-        20  def cat
-        22  end
-    ```
+       1  require 'zoo'
+       2
+       3  class Animal
+       4
+    ❯  5    defdog
+    ❯  7    end
+       8
+      12  end
 
 How much would you pay for such a library? A million, a billion, a trillion? Well friends, today is your lucky day because you can use this library today for free!
 
-## Installation
+## Installation in your codebase
 
 To automatically search syntax errors when they happen, add this to your Gemfile:
 
@@ -51,6 +50,16 @@ If your application is not calling `Bundler.require` then you must manually add
 require "syntax_search/auto"
 ```
 
+If you're using rspec add this to your `.rspec` file:
+
+```
+--require syntax_search/auto
+```
+
+> This is needed because people can execute a single test file via `bundle exec rspec path/to/file_spec.rb` and if that file has a syntax error, it won't load `spec_helper.rb` to trigger any requires.
+
+## Install the CLI
+
 To get the CLI and manually search for syntax errors, install the gem:
 
     $ gem install syntax_search
@@ -74,6 +83,10 @@ We know that source code that does not contain a syntax error can be parsed. We
 
 Since there can be multiple syntax errors in a document it's not good enough to check individual code blocks, we've got to check multiple at the same time. We will keep creating and adding new blocks to our search until we detect that our "frontier" (which contains all of our blocks) contains the syntax error. After this, we can stop our search and instead focus on filtering to find the smallest subset of blocks that contain the syntax error.
 
+Here's an example:
+
+![](assets/syntax_search.gif)
+
 ## How is source code broken up into smaller blocks?
 
 By definition source code with a syntax error in it cannot be parsed, so we have to guess how to chunk up the file into smaller pieces. Once we've split up the file we can safely rule out or zoom into a specific piece of code to determine the location of the syntax error. This libary uses indentation and empty lines to make guesses about what might be a "block" of code. Once we've got a chunk of code, we can test it.

data/exe/syntax_search

@@ -62,6 +62,7 @@ if file.nil? || file.empty?
 end
 
 file = Pathname(file)
+options[:record_dir] = "tmp" if ENV["DEBUG"]
 
 $stderr.puts "Record dir: #{options[:record_dir]}"  if options[:record_dir]
 

data/lib/syntax_search.rb

@@ -2,10 +2,10 @@
 
 require_relative "syntax_search/version"
 
-require 'parser/current'
 require 'tmpdir'
 require 'stringio'
 require 'pathname'
+require 'ripper'
 
 module SyntaxErrorSearch
   class Error < StandardError; end
@@ -23,7 +23,7 @@ module SyntaxErrorSearch
       self.call(
         source: Pathname(filename).read,
         filename: filename,
-        terminal: true
+        terminal: true,
       )
     end
 
@@ -40,6 +40,8 @@ module SyntaxErrorSearch
       blocks: blocks,
       filename: filename,
       terminal: terminal,
+      code_lines: search.code_lines,
+      invalid_type: invalid_type(source),
       io: $stderr
     ).call
   end
@@ -78,6 +80,13 @@ module SyntaxErrorSearch
     end
   end
 
+  def self.invalid?(source)
+    source = source.join if source.is_a?(Array)
+    source = source.to_s
+
+    Ripper.new(source).tap(&:parse).error?
+  end
+
   # Returns truthy if a given input source is valid syntax
   #
   #   SyntaxErrorSearch.valid?(<<~EOM) # => true
@@ -113,24 +122,24 @@ module SyntaxErrorSearch
   # so passing a CodeLine in as an object or as an array
   # will convert it to it's code representation.
   def self.valid?(source)
-    source = source.join if source.is_a?(Array)
-    source = source.to_s
+    !invalid?(source)
+  end
 
-    # Parser writes to stderr even if you catch the error
-    stderr = $stderr
-    $stderr = StringIO.new
 
-    Parser::CurrentRuby.parse(source)
-    true
-  rescue Parser::SyntaxError
-    false
-  ensure
-    $stderr = stderr if stderr
+  def self.invalid_type(source)
+    WhoDisSyntaxError.new(source).call.error_symbol
   end
 end
 
 require_relative "syntax_search/code_line"
 require_relative "syntax_search/code_block"
 require_relative "syntax_search/code_frontier"
-require_relative "syntax_search/code_search"
 require_relative "syntax_search/display_invalid_blocks"
+require_relative "syntax_search/around_block_scan"
+require_relative "syntax_search/block_expand"
+require_relative "syntax_search/parse_blocks_from_indent_line"
+
+require_relative "syntax_search/code_search"
+require_relative "syntax_search/who_dis_syntax_error"
+require_relative "syntax_search/heredoc_block_parse"
+require_relative "syntax_search/lex_all"

data/lib/syntax_search/around_block_scan.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+#
+module SyntaxErrorSearch
+  # This class is useful for exploring contents before and after
+  # a block
+  #
+  # It searches above and below the passed in block to match for
+  # whatever criteria you give it:
+  #
+  # Example:
+  #
+  #   def dog
+  #     puts "bark"
+  #     puts "bark"
+  #   end
+  #
+  #   scan = AroundBlockScan.new(
+  #     code_lines: code_lines
+  #     block: CodeBlock.new(lines: code_lines[1])
+  #   )
+  #
+  #   scan.scan_while { true }
+  #
+  #   puts scan.before_index # => 0
+  #   puts scan.after_index # => 3
+  #
+  # Contents can also be filtered using AroundBlockScan#skip
+  #
+  # To grab the next surrounding indentation use AroundBlockScan#scan_adjacent_indent
+  class AroundBlockScan
+    def initialize(code_lines: , block:)
+      @code_lines = code_lines
+      @orig_before_index = block.lines.first.index
+      @orig_after_index = block.lines.last.index
+      @orig_indent = block.current_indent
+      @skip_array = []
+      @after_array = []
+      @before_array = []
+      @stop_after_kw = false
+    end
+
+    def skip(name)
+      @skip_array << name
+      self
+    end
+
+    def stop_after_kw
+      @stop_after_kw = true
+      self
+    end
+
+    def scan_while(&block)
+      stop_next = false
+
+      kw_count = 0
+      end_count = 0
+      @before_index = before_lines.reverse_each.take_while do |line|
+        next false if stop_next
+        next true if @skip_array.detect {|meth| line.send(meth) }
+
+        kw_count += 1 if line.is_kw?
+        end_count += 1 if line.is_end?
+        if @stop_after_kw && kw_count > end_count
+          stop_next = true
+        end
+
+        block.call(line)
+      end.reverse.first&.index
+
+      stop_next = false
+      kw_count = 0
+      end_count = 0
+      @after_index = after_lines.take_while do |line|
+        next false if stop_next
+        next true if @skip_array.detect {|meth| line.send(meth) }
+
+        kw_count += 1 if line.is_kw?
+        end_count += 1 if line.is_end?
+        if @stop_after_kw && end_count > kw_count
+          stop_next = true
+        end
+
+        block.call(line)
+      end.last&.index
+      self
+    end
+
+    def capture_neighbor_context
+      lines = []
+      kw_count = 0
+      end_count = 0
+      before_lines.reverse.each do |line|
+        next if line.empty?
+        break if line.indent < @orig_indent
+        next if line.indent != @orig_indent
+
+        kw_count += 1 if line.is_kw?
+        end_count += 1 if line.is_end?
+        if kw_count != 0 && kw_count == end_count
+          lines << line
+          break
+        end
+
+        lines << line
+      end
+
+      lines.reverse!
+
+      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
+
+        kw_count += 1 if line.is_kw?
+        end_count += 1 if line.is_end?
+        if kw_count != 0 && kw_count == end_count
+          lines << line
+          break
+        end
+
+        lines << line
+      end
+      lines.select! {|line| !line.is_comment? }
+
+      lines
+    end
+
+    def on_falling_indent
+      last_indent = @orig_indent
+      before_lines.reverse.each do |line|
+        next if line.empty?
+        if line.indent < last_indent
+          yield line
+          last_indent = line.indent
+        end
+      end
+
+      last_indent = @orig_indent
+      after_lines.each do |line|
+        next if line.empty?
+        if line.indent < last_indent
+          yield line
+          last_indent = line.indent
+        end
+      end
+    end
+
+    def scan_neighbors
+      self.scan_while {|line| line.not_empty? && line.indent >= @orig_indent }
+    end
+
+    def scan_adjacent_indent
+      before_indent = @code_lines[@orig_before_index.pred]&.indent || 0
+      after_indent = @code_lines[@orig_after_index.next]&.indent || 0
+
+      indent = [before_indent, after_indent].min
+      self.scan_while {|line| line.not_empty? && line.indent >= indent }
+
+      self
+    end
+
+    def start_at_next_line
+      before_index; after_index
+      @before_index -= 1
+      @after_index += 1
+      self
+    end
+
+    def code_block
+      CodeBlock.new(lines: @code_lines[before_index..after_index])
+    end
+
+    def before_index
+      @before_index ||= @orig_before_index
+    end
+
+    def after_index
+      @after_index ||= @orig_after_index
+    end
+
+    private def before_lines
+      @code_lines[0...@orig_before_index]
+    end
+
+    private def after_lines
+      @code_lines[@orig_after_index.next..-1]
+    end
+  end
+end