korekto 1.6.210409 → 2.0.231231

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91b2307d9115580d8a6882a7bf8d417d1eca426d7539fff91dce791ea7dd1ff9
-  data.tar.gz: 1a1db1ac36359058341083031abe61e6e9c3258fdaf2cb2388140ef3e179b8fa
+  metadata.gz: 3b6d303ce45a7dc14c9dd65923f46d5c78728a7f90b5fa177cacce76a08e032f
+  data.tar.gz: 780b4c3d11b968a6183fe285e00c8d67b976691465694aa3ded19bde58e81d35
 SHA512:
-  metadata.gz: 0bbcd36ec3471eb628d1274e013d2c9f6e8b85ab4e8b0d99a226a43d58cbe471a74f9b39a5db0c63e66af888353fa7be0069224fb35df4a80d75b148356fccc9
-  data.tar.gz: ca4b3a0d970d6463f49f18af87767301d376d9a102031a88ebe3c8707114e60161f4ba4014e2608fda377515500b608361178b8b9ea9d02d3f577daa5e069c91
+  metadata.gz: 78b31ad18094000a9de76669b6d7fac178fa547b715e41705267e75c459fdf8e99b5d94ce310526f3991c9e3f5db9d6c92189d4a369bfd33df77b0c1bbd12969
+  data.tar.gz: 1efc9551d93da2507a736d725c5c043b4b710ced992b3d419cc0ee4cf5a10fa85dfd3700be81dd336869cb19808d8fc84d5b7482fb7604cff0d8cc96fe6e5754

data/README.md

@@ -0,0 +1,95 @@
+# Korekto
+
+* [VERSION 2.0.231231](https://github.com/carlosjhr64/korekto/releases)
+* [github](https://www.github.com/carlosjhr64/korekto)
+* [rubygems](https://rubygems.org/gems/korekto)
+
+## DESCRIPTION:
+
+A general proof checker.
+
+Works with [neovim](https://github.com/neovim/neovim).
+
+## INSTALL:
+```shell
+$ gem install korekto
+$ korekto --install
+$ ### And if missing:
+$ gem install neovim # Provides neovim-ruby-host
+```
+## SYNOPSIS:
+```korekto
+### Patterns ###
+# 'Hello World!'.scan(/\w+|\S|\s/) #=> ["Hello", " ", "World", "!"]
+! scanner: '\w+|\S|\s'
+! .Newline /\n/
+! .Newline {;}
+! Variables /\w+/
+! Variables {V W}
+### Acceptance patterns ###
+There might be V.	#L1 Let 1: There   might be .
+# /If I see (\w+), then I'll probably see (\w+).\nI see \1\nI'll probably see \2/
+If I see V, then I'll probably see W.;I see V.;I'll probably see W.	#I2 Modus ponens: If I see , then ' ll probably
+### Argument ###
+There might be Cows.	#S3/L1 Let 1: Cows
+There might be Chickens.	#S4/L1 Let 1: Chickens
+If I see Cows, then I'll probably see Chickens.	#P5
+I see Cows.	#P6
+I'll probably see Chickens.	#C7/I2,P5,P6 Modus ponens
+```
+## Examples
+
+* [Tutorial](examples/Tutorial.md)
+* [ABC music notation](examples/ABC.md)
+* [Computation](examples/Computation.md)
+* [Dx x^x](examples/Dxx.md)
+* [Sqrt(2) is irrational! (Classic Proof)](examples/Sqrt2.md)
+* [Squash Function](examples/Squash.md)
+
+## Help:
+```shell
+$ korekto --help
+Usage:
+  korekto [:options+]
+Options:
+ -h --help
+ -v --version
+ --scrape    	Scrape Korekto lines
+ --trace     	Show trace of each line, not just edits and errors
+ --patch     	Allow monkey patching in stdin
+ --install   	Installs the korekto neovim ruby plugin
+ --readme    	Open korekto github page
+ --heap=SIZE 	Set heap size (default: 13)
+Types:
+  SIZE    /^\d+$/
+Exclusive:
+  scrape trace install readme
+# Example usage:
+#   cat MARKDOWN.md | korekto
+#   korekto < MARKDOWN.md
+```
+## LICENSE:
+
+Copyright (c) 2023 CarlosJHR64
+
+Permission is hereby granted, free of charge,
+to any person obtaining a copy of this software and
+associated documentation files (the "Software"),
+to deal in the Software without restriction,
+including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and
+to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS",
+WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH
+THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/korekto

@@ -1,38 +1,62 @@
 #!/usr/bin/env ruby
-require 'help_parser'
-
-OPTIONS = HelpParser['1.6.210409', <<HELP]
-Usage:
-  korekto [:options]
-Options:
- -h --help
- -v --version
- --edits     \tShow only needed edits
- --install   \tInstalls the korekto neovim ruby plugin
- --readme    \tOpen korekto github page
-# Example usage:
-#   cat MARKDOWN.md | korekto
-#   korekto < MARKDOWN.md
-HELP
+require 'korekto'
 
-if OPTIONS.install?
+def do_install
+  local_pack = File.expand_path '~/.local/share/nvim/site/pack'
+  config_nvim = File.expand_path '~/.config/nvim'
+  unless File.directory?(local_pack) && File.directory?(config_nvim)
+    warn "Expected directories:\n\t#{local_pack}\n\t#{config_nvim}"
+    exit 78 # EX_CONFIG
+  end
   require 'fileutils'
   # pack
-  dest = File.expand_path '~/.local/share/nvim/site/pack/korekto'
+  dest = File.join(local_pack, 'korekto')
   FileUtils.mkdir_p dest
   src = File.join File.dirname(__dir__), 'start'
   FileUtils.cp_r src, dest
   # rplugin
-  dest = File.expand_path '~/.config/nvim'
+  dest = config_nvim
   src = File.join File.dirname(__dir__), 'rplugin'
   FileUtils.cp_r src, dest
   system "nvim -c ':UpdateRemotePlugins|:quit' > /dev/null"
   exit
 end
-if OPTIONS.readme?
-  Process.detach spawn('xdg-open', 'https://www.github.com/carlosjhr64/korekto')
+
+def spawn_readme
+  Process.detach spawn('xdg-open', 'https://www.github.com/carlosjhr64/korekto',
+                       %i[out err] => '/dev/null')
   exit
 end
 
-require 'korekto'
+def handle_options
+  require 'help_parser'
+  options = HelpParser[Korekto::VERSION, <<~HELP]
+    Usage:
+      korekto [:options+]
+    Options:
+     -h --help
+     -v --version
+     --scrape    \tScrape Korekto lines
+     --trace     \tShow trace of each line, not just edits and errors
+     --patch     \tAllow monkey patching in stdin
+     --install   \tInstalls the korekto neovim ruby plugin
+     --readme    \tOpen korekto github page
+     --heap=SIZE \tSet heap size (default: #{Korekto.heap})
+    Types:
+      SIZE    /^\\d+$/
+    Exclusive:
+      scrape trace install readme
+    # Example usage:
+    #   cat MARKDOWN.md | korekto
+    #   korekto < MARKDOWN.md
+  HELP
+  do_install if options.install?
+  spawn_readme if options.readme?
+  Korekto.scrape = options.scrape?
+  Korekto.trace  = options.trace?
+  Korekto.patch  = options.patch?
+  Korekto.heap   = options.heap.to_i if options.heap?
+end
+
+handle_options unless ARGV.empty?
 Korekto.run

data/lib/korekto/main.rb

@@ -1,12 +1,14 @@
 module Korekto
 class Main
-  MD_STATEMENT_CODE_TITLE = %r{^(?<statement>.*)\s#(?<code>[A-Z](\d+(\.\w+)?(/[\w,.]+)?)?)( (?<title>\S.*?\S))?$}
+  # rubocop: disable Layout/LineLength
+  MD_STATEMENT_CODE_TITLE = %r{^(?<statement>.*)\s#(?<code>[A-Z](\d+(\.\w+)?(/[\w,.]+)?)?)(\s+(?<title>[^#]+))?$}
   MD_FILENAME = %r{^< (?<filename>[/\w\-.]+)$}
   MD_KLASS_METHOD_DEFINITION = /^(?<klass>::[A-Z]\w+)#(?<method>\w+)(?<definition>[^=]*=.+)$/ # patch
   MD_RULE = /^[?] (?<rule>\S.*)$/
-  MD_TYPE_PATTERN = %r{^! (?<type>\S+)\s*/(?<pattern>.*)/$}
-  MD_TYPE_VARIABLES = /^! (?<type>\S+)\s*\{(?<variables>\S+( \S+)*)\}$/
-  MD_KEY_VALUE = /^! (?<key>\w+):\s*'(?<value>.*)'$/
+  MD_TYPE_PATTERN = %r{^! (?<type>\S+)\s+/(?<pattern>.*)/$}
+  MD_TYPE_VARIABLES = /^! (?<type>\S+)\s+\{(?<variables>\S+( \S+)*)\}$/
+  MD_KEY_VALUE = /^! (?<key>\w+):\s+'(?<value>.*)'$/
+  # rubocop: enable Layout/LineLength
 
   M_FENCE = /^```\s*$/
   M_COMMENT_LINE = /^\s*#/
@@ -18,12 +20,12 @@ class Main
     @imports.push @filename.freeze
     @line,@active = nil,false
     @section = File.basename(@filename,'.*')
-    @m_fence_korekto = /^```korekto$/
+    @m_fence_korekto = /^```korekto$/ # default fence
   end
 
   def type_pattern(type, pattern)
     t2p = @statements.symbols.t2p
-    raise Error, "type #{type} in use" if t2p.has_key? type
+    raise Error, "type #{type} in use" if t2p.key? type
     t2p[type] = pattern
   end
 
@@ -32,53 +34,26 @@ class Main
     pattern = t2p[type]
     raise Error, "type #{type} not defined" unless pattern
     variables.each do |variable|
-      raise Error, "variable #{variable} in use" if v2t.has_key? variable
+      raise Error, "variable #{variable} in use" if v2t.key? variable
       v2t[variable] = type
     end
   end
 
-  def active?
-    case @line
-    when @m_fence_korekto
-      raise Error, 'unexpected fence' if @active
-      @active = true
-      false
-    when M_FENCE
-      @active = false
-      false
-    else
-      @active and not M_COMMENT_LINE.match?(@line)
-    end
-  end
-
   def patch(klass, method, definition)
-    raise Error, "overrides: #{klass}##{method}" if eval(klass).method_defined? method
+    if Object.const_get(klass).method_defined?(method)
+      raise Error, "overrides: #{klass}##{method}"
+    end
+    # rubocop: disable Security/Eval
+    # rubocop: disable Style/DocumentDynamicEvalDefinition
+    # rubocop: disable Style/EvalWithLocation
     eval <<~EVAL
       class #{klass}
         def #{method}#{definition}
       end
     EVAL
-  end
-
-  def key_value(key, value)
-    case key
-    when 'scanner'
-      @statements.symbols.set_scanner value
-    when 'fence'
-      @m_fence_korekto = Regexp.new "^```#{value}$"
-    when 'section'
-      @section = value
-    when 'save'
-      BACKUPS[value] = Marshal.dump(@statements)
-    when 'restore'
-      if backup = BACKUPS[value]
-        @statements = Marshal.load(backup)
-      else
-        raise Error, "nothing saved as '#{value}'"
-      end
-    else
-      raise Error, "key '#{key}' not implemented"
-    end
+    # rubocop: enable Style/EvalWithLocation
+    # rubocop: enable Style/DocumentDynamicEvalDefinition
+    # rubocop: enable Security/Eval
   end
 
   def preprocess?
@@ -89,6 +64,10 @@ class Main
         Main.new(filename, statements:@statements, imports:@imports).run
       end
     when MD_KLASS_METHOD_DEFINITION
+      if @filename=='-' && !Korekto.patch?
+        # We'll trust files, but not stdin.
+        raise Error, 'monkey patching not allowed on stdin'
+      end
       patch($~[:klass],$~[:method],$~[:definition])
     when MD_RULE
       @statements.syntax.push $~[:rule].strip
@@ -104,19 +83,49 @@ class Main
     true
   end
 
+  def key_value(key, value)
+    case key
+    when 'scanner'
+      @statements.symbols.set_scanner value
+    when 'fence'
+      @m_fence_korekto = Regexp.new "^```#{value}$" # user defined fence
+    when 'section'
+      @section = value
+    when 'save'
+      BACKUPS[value] = Marshal.dump(@statements)
+    when 'restore'
+      if (backup = BACKUPS[value])
+        @statements = Marshal.load(backup)
+      else
+        raise Error, "nothing saved as '#{value}'"
+      end
+    else
+      raise Error, "key '#{key}' not implemented"
+    end
+  end
+
   def parse(lines)
     statement_number = line_number = 0
-    while @line = lines.shift
+    while (@line = lines.shift)
       begin
         line_number += 1
         next unless active?
         next if preprocess?
-        if md = MD_STATEMENT_CODE_TITLE.match(@line)
+        if (md = MD_STATEMENT_CODE_TITLE.match @line)
           code,title = @statements.add(md[:statement].strip,
                                        md[:code],
                                        md[:title],
-                                       @section){ statement_number += 1 }
-          if not OPTIONS.edits? or (@filename=='-' and not (md[:code]==code and md[:title]==title))
+                                       @section
+                                        # Block executes if statement is new.
+                                        # Method recieves the return value.
+                                      ){ statement_number += 1 }
+          if Korekto.scrape?
+            print @statements.last
+            print "\t##{code}"
+            print " #{title}" unless title.nil? || title.empty?
+            puts
+          elsif Korekto.trace? ||
+                (@filename=='-' && !(md[:code]==code && md[:title]==title))
             puts "#{@filename}:#{line_number}:#{code}:#{title}"
           end
         else
@@ -125,19 +134,30 @@ class Main
       rescue Error
         puts "#{@filename}:#{line_number}:!:#{$!.message}"
         exit 65
-      rescue Exception
+      rescue StandardError
         puts "#{@filename}:#{line_number}:?:#{$!.message}"
-        $stderr.puts $!.backtrace
+        warn $!.backtrace
         exit 1
       end
     end
   end
 
   def run
-    if @filename=='-'
-      parse $stdin.readlines(chomp: true)
+    parse @filename=='-' ? $stdin.readlines(chomp: true) :
+                           File.readlines(@filename, chomp: true)
+  end
+
+  # Is the current line a non-comment Korekto line?
+  def active?
+    case @line
+    when @m_fence_korekto
+      raise Error, 'unexpected fence' if @active
+      @active = true
+      false
+    when M_FENCE
+      @active = false
     else
-      parse IO.readlines(@filename, chomp: true)
+      @active && !M_COMMENT_LINE.match?(@line)
     end
   end
 end

data/lib/korekto/statement.rb

@@ -1,21 +1,26 @@
 module Korekto
 class Statement
   attr_reader :code,:title,:regexp,:section,:statement_number
+
+  # rubocop: disable Metrics/ParameterLists
   def initialize(statement,code,title,section,statement_number,context)
-    @statement,@code,@title,@section,@statement_number,@context =
-      statement,code,title,section,statement_number,context
+    @statement,@code,@title,@section,@statement_number,@context,@regexp =
+      statement,code,title,section,statement_number,context,nil
     @statement.freeze; @section.freeze; @statement_number.freeze
-    syntax_check unless @statement[0]=='/' and @statement[-1]=='/' and ['A','L','M','E','I'].include?(@code[0])
-    @regexp = nil
+    @title = @title.split(':',2).first if @title
+    syntax_check unless @statement[0]=='/' &&
+                        @statement[-1]=='/' &&
+                        %w[A L M E I].include?(@code[0])
     set_acceptance_code
     @code.freeze; @title.freeze; @regexp.freeze
   end
+  # rubocop: enable Metrics/ParameterLists
 
   def type              = @code[0]
   def to_s              = @statement
   def to_str            = @statement
   def match?(statement) = @regexp.match?(statement)
-  def scan(regex, &blk) = @statement.scan(regex, &blk)
+  def scan(regex, &)    = @statement.scan(regex, &)
   def pattern?          = !@regexp.nil?
   def literal_regexp?   = @statement[0]=='/' && @statement[-1]=='/'
 
@@ -23,8 +28,10 @@ class Statement
 
   def syntax_check
     @context.syntax.each do |rule|
-      raise Error, "syntax: #{rule}" unless @statement.instance_eval(rule)
-    rescue # other than Korekto::Error < Exception
+      next if @statement.instance_eval(rule)
+      raise Error, "syntax: #{rule}"
+    rescue StandardError
+      raise if $!.is_a? Error
       raise Error, "#{$!.class}: #{rule}"
     end
   end
@@ -46,7 +53,7 @@ class Statement
     when 'T'
       tautology
     when 'A', 'L'
-      # Axiom=>Tautoloty, Let=>Set,
+      # Axiom=>Tautology, Let=>Set,
       pattern_type(0)
     when 'M', 'E'
       # Map=>Result, Existential=>Instantiation(X)
@@ -55,14 +62,12 @@ class Statement
       # Inference=>Conclusion
       pattern_type(2)
     when 'W'
-      ['T','S','R','X','C'].any? do |code|
-        begin
-          @code[0]=code
-          set_acceptance_code
-          true
-        rescue Error
-          false
-        end
+      %w[T S R X C].any? do |code|
+        @code[0]=code
+        set_acceptance_code
+        true
+      rescue Error
+        false
       end or raise Error, 'did not match any statement pattern'
     else
       raise Error, "statement type #{@code[0]} not implemented"
@@ -71,26 +76,22 @@ class Statement
 
   # Common helper
 
-  def set_statement(support=nil, title=nil)
+  def set_statement(support=nil, title=nil, undefined:nil)
     @code = "#{@code[0]}#{@statement_number}"
     @code += '.' + @section unless @section=='-'
     @code += "/#{support}" if support
-    @title = title if (title=title&.split(':',2)&.first) and not title.empty?
+    @title = title if (title=title&.split(':',2)&.first) && !title.empty?
+    @title = "#{@title}: #{undefined.join(' ')}" if undefined
   end
 
-  def support(*s)
-    support = []
-    s.each do |s|
-      c = s.code.split('/',2)[0]
-      support.push(c)
-    end
-    return support.join(',')
-  end
+  def support(*s) = s.inject([]){|a,s| a.push(s.code.split('/',2)[0])}.join(',')
 
   # Pattern helpers
 
   def newlines_count(n)
-    raise Error, "expected #{n} newlines" unless n==@regexp.inspect.gsub('\\\\','').scan('\\n').length
+    unless n==@regexp.inspect.gsub('\\\\','').scan('\\n').length
+      raise Error, "expected #{n} newlines"
+    end
   end
 
   def set_regexp
@@ -100,11 +101,8 @@ class Statement
   # Searches
 
   def detect_statement(type)
-    statement = @context.type(type).detect do |statement|
-      statement.match? @statement
-    end
-    raise Error, "does not match any '#{type}' statement" unless statement
-    return statement
+    @context.type(type).detect{_1.match? @statement} ||
+      raise(Error, "does not match any '#{type}' statement")
   end
 
   def heap_combos_search(type)
@@ -132,16 +130,13 @@ class Statement
   def expected_instantiations(title=nil, n:nil)
     undefined = @context.symbols.undefined(self)
     if n ||= title&.match(/[1-9]\d*/)&.to_s&.to_i
-      raise Error, "expected #{n} undefined: #{undefined.join(' ')}" unless n==undefined.length
-    else
-      raise Error, 'nothing was undefined' if undefined.empty?
+      unless n==undefined.length
+        raise Error, "expected #{n} undefined: #{undefined.join(' ')}"
+      end
+    elsif undefined.empty?
+      raise Error, 'nothing was undefined'
     end
-  end
-
-  def undefined_in_pattern
-    @title = @title.split(':',2).first if @title
-    undefined = @context.symbols.undefined(self)
-    @title = "#{@title}: #{undefined.join(' ')}" unless undefined.empty?
+    undefined.empty? ? nil : undefined
   end
 
   # Statement type processing
@@ -149,50 +144,61 @@ class Statement
   def pattern_type(nl)
     set_regexp
     newlines_count(nl)
-    undefined_in_pattern
+    undefined = (_=@context.symbols.undefined(self)).empty? ? nil : _
     follows = @context.heap.to_a[0..nl].reverse
-    if @regexp.match? follows.map{_1.to_s}.join("\n")
-      set_statement(support(*follows))
-    else
-      set_statement
-    end
+    support = @regexp.match?(follows.map(&:to_s).join("\n"))?
+              support(*follows) : nil
+    set_statement(support, undefined: undefined)
   end
 
+  # A Tautology is an accepted true statement that immediately follows from
+  # an Axiom rule. It may not have any undefined terms.
   def tautology
     expected_instantiations(n:0)
     axiom = detect_statement('A')
     set_statement(support(axiom), axiom.title)
   end
 
+  # A Set(Assignment) is an allowed true statement that introduces at least one
+  # term as immediately validated by a matching Let rule.
   def set
     let = detect_statement('L')
-    expected_instantiations(let.title)
-    set_statement(support(let), let.title)
+    undefined = expected_instantiations(let.title)
+    set_statement(support(let), let.title, undefined: undefined)
   end
 
+  # A Result is a derived true statement that follows from a Map rule and
+  # matching true statement.
   def result
     expected_instantiations(n:0)
     mapping,s1 = heap_search('M')
     set_statement(support(mapping,s1), mapping.title)
   end
 
+  # An Instantiation is a derived true statement that introduces at least one
+  # new term as a result of an Existential rule and matching true statement.
   def instantiation
     existential,s1 = heap_search('E')
-    expected_instantiations(existential.title)
-    set_statement(support(existential,s1), existential.title)
+    undefined = expected_instantiations(existential.title)
+    set_statement(support(existential,s1), existential.title,
+                  undefined: undefined)
   end
 
+  # A Conclusion is a derived true statement, the result of an Inference rule
+  # that follows from two true statements.
   def conclusion
     expected_instantiations(n:0)
     inference,s1,s2 = heap_combos_search('I')
     set_statement(support(inference,s1,s2), inference.title)
   end
 
+  # A Definition is an assumed true statement that defines at least one term.
   def definition
     expected_instantiations(@title)
     set_statement
   end
 
+  # A Postulate is an assumed true statement with all terms defined.
   def postulate
     expected_instantiations(n:0)
     set_statement

data/lib/korekto/statements.rb

@@ -1,42 +1,36 @@
 module Korekto
 class Statements
   attr_reader :heap,:symbols,:syntax
+
   def initialize
     @statements = []
-    @heap = Heap.new(13)
+    @heap = Heap.new Korekto.heap
     @symbols = Symbols.new
     @syntax = Syntax.new
   end
 
   def type(c) = @statements.select{_1.type==c}
-  def length = @statements.length
+  def length  = @statements.length
+  def last    = @statements.last
 
   def add(statement,code,title,filename)
     c = code[0]; w = c=='W'
-    if restatement = @statements.detect{(w or _1.type==c) and _1.to_s==statement}
-      case restatement.type
-      when 'D','X','S','P','T','C','R'
-        @heap.add restatement
-      else
+    if (restatement=@statements.detect{(w || _1.type==c) && _1.to_s==statement})
+      unless 'DXSPTCR'.include?(restatement.type)
+        # Only allow heap-able statements to be restated.
         raise Error, "restatement: #{restatement.code}"
       end
-      code,_ = restatement.code
+      @heap.add restatement
+      code, = restatement.code
       title ||= restatement.title
       return code, title
     end
     statement_number = yield
-    statement = Statement.new(statement,code,title,filename,statement_number,self)
+    statement=Statement.new(statement,code,title,filename,statement_number,self)
     @statements.push statement
-    case statement.type
-    when 'A','I','E','M','L'
-      @symbols.define! statement
-    when 'D','X','S'
-      @symbols.define! statement
-      @heap.add statement
-    when 'P','T','C','R'
-      @heap.add statement
-    end
-    return statement.code, statement.title
+    @symbols.define! statement if 'AIEMLDXS'.include?(statement.type)
+    @heap.add statement if 'DXSPTCR'.include?(statement.type)
+    [statement.code, statement.title]
   end
 end
 end

data/lib/korekto/symbols.rb

@@ -1,66 +1,64 @@
 module Korekto
 class Symbols
   attr_reader :t2p, :v2t
+
   def initialize
-    @h   = {}
-    @t2p = {}
-    @v2t = {}
-    @scanner = /:\w+|./
+    @set   = Set.new # Set of Korekto symbols(strings)
+    @v2t = {} # Variable to Type
+    @t2p = {} # Type to Pattern
+    @scanner = /:\w+|./ # Default scanner
   end
 
+  # rubocop: disable Naming/AccessorMethodName
   def set_scanner(value) = @scanner=Regexp.new(value)
+  # rubocop: enable Naming/AccessorMethodName
 
   def undefined(statement)
-    undefined = []
+    undefined = Set.new
     if statement.pattern?
       unless statement.literal_regexp?
-        statement.scan(@scanner){|w| undefined.push(w) unless @v2t.include?(w) or @h.include?(w)}
+        statement.scan(@scanner) do |w|
+          undefined<<w unless @v2t.include?(w) || @set.include?(w)
+        end
       end
     else
-      statement.scan(@scanner){|w| undefined.push(w) unless @h.include?(w)}
+      statement.scan(@scanner){|w| undefined<<w unless @set.include?(w)}
     end
-    return undefined.uniq
+    undefined
   end
 
-  def define!(statement)
-    if statement.pattern?
-      unless statement.literal_regexp?
-        statement.scan(@scanner){|w| @h[w]=nil unless @v2t.include?(w) or @h.include?(w)}
-      end
-    else
-      statement.scan(@scanner){|w| @h[w]=nil unless @h.include?(w)}
-    end
-  end
+  def define!(statement) = undefined(statement).each{|w| @set<<w}
 
   def s2r(statement)
-    if statement[0]=='/' and statement[-1]=='/'
-      Regexp.new(statement[1..-2])
-    else
-      pattern,count,seen = '\A',0,{}
-      statement.scan(@scanner) do |v|
-        if n=seen[v]
-          pattern << '\\'+n
-        elsif type = @v2t[v]
-          regex = @t2p[type]
-          if type[0]=='.'
-            pattern << regex
-          else
-            count += 1
-            seen[v]=count.to_s
-            pattern << '('+regex+')'
-          end
+    return Regexp.new statement[1..-2] if statement[0]=='/' &&
+                                          statement[-1]=='/'
+    pattern,count,seen = '\A',0,{}
+    # Build pattern from statement token by token, v.
+    statement.scan(@scanner) do |v|
+      if (n=seen[v])
+        pattern << '\\'+n
+      elsif (type = @v2t[v])
+        regex = @t2p[type]
+        if type[0]=='.'
+          # No capture patterns start with '.'
+          pattern << regex
         else
-          # Escape Regexp specials
-          v = Regexp.quote v
-          # To avoid collisions with back-references, isolate digit in square brackets:
-          '0123456789'.include?(_=v[0]) and v[0]='['+_+']'
-          pattern << v
+          count += 1
+          seen[v]=count.to_s
+          pattern << '('+regex+')'
         end
+      else
+        # Escape Regexp specials
+        v = Regexp.quote v
+        # To avoid collisions with back-references,
+        # isolate digit in square brackets:
+        '0123456789'.include?(_=v[0]) and v[0]='['+_+']'
+        pattern << v
       end
-      raise Error, 'pattern with no captures' if count < 1
-      pattern << '\Z'
-      Regexp.new(pattern)
     end
+    raise Error, 'pattern with no captures' if count < 1
+    pattern << '\Z'
+    Regexp.new(pattern)
   end
 end
 end

data/lib/korekto/syntax.rb

@@ -1,14 +1,17 @@
 module Korekto
 class Syntax
   def initialize = @a=[]
-  def each = @a.each{|s| yield s}
+  def each(&blk) = @a.each{|s| blk[s]}
 
   def push(s)
     # ensure it'll eval on string and returns boolean
     b = ''.instance_eval(s)
+    # rubocop: disable Style/DoubleNegation
     raise Error, 'syntax rule must eval boolean' unless b==!!b
+    # rubocop: enable Style/DoubleNegation
     @a.push(s)
-  rescue
+  rescue StandardError
+    raise if $!.is_a? Error
     raise Error, "#{$!.class}: #{s}"
   end
 end

data/lib/korekto.rb

@@ -1,14 +1,51 @@
 module Korekto
-  VERSION = '1.6.210409'
-  class Error < Exception; end
-  require 'korekto/symbols'
-  require 'korekto/syntax'
-  require 'korekto/heap'
-  require 'korekto/statement'
-  require 'korekto/statements'
-  require 'korekto/main'
-  def Korekto.run = Korekto::Main.new.run
+  class Error < RuntimeError; end
+
+  VERSION = '2.0.231231'
+
+  def self.trace=(value)
+    @@trace = value
+  end
+  def self.trace?
+    @@trace
+  end
+  Korekto.trace = false
+
+  def self.patch=(value)
+    @@patch = value
+  end
+  def self.patch?
+    @@patch
+  end
+  Korekto.patch = false
+
+  def self.heap=(value)
+    @@heap = value
+  end
+  def self.heap
+    @@heap
+  end
+  Korekto.heap = 13
+
+  def self.scrape?
+    @@scrape
+  end
+  def self.scrape=(value)
+    @@scrape = value
+  end
+  Korekto.scrape = false
+
+  def self.run
+    require 'korekto/symbols'
+    require 'korekto/syntax'
+    require 'korekto/heap'
+    require 'korekto/statement'
+    require 'korekto/statements'
+    require 'korekto/main'
+    Korekto::Main.new.run
+  end
 end
+
 # Requires:
 # `ruby`
 # `nvim`

data/rplugin/ruby/korekto.rb

@@ -1,30 +1,38 @@
-Neovim.plugin do |plug|
-  plug.command(:Korekto) do |nvim|
-    validations = nvim.command_output('w !korekto --edits').strip.split("\n").map(&:strip)
-    msg = 'OK'
+module KorektoPlug
+  KOREKTO = `which korekto`.strip
+  VERSION = `#{KOREKTO} --version`.strip
+
+  def self.korekto(nvim, options='')
+    validations = nvim.command_output("w !#{KOREKTO} #{options}")
+                  .strip.split("\n").map(&:strip)
+    msg = "Korekto! #{VERSION}"
     unless validations.empty?
       buf = nvim.get_current_buf
-      while validation = validations.shift
+      while (validation = validations.shift)
         fields = validation.split(':',4)
         n = fields[1].to_i
-        if n > 0
-          fn,ln,code,title = fields
-          if code=='?' or code=='!'
-            # move onto error if on page
-            nvim.get_current_win.set_cursor([n,0]) if fn=='-'
-            # echo error message
-            msg = "#{fn}:#{ln}: #{title}"
-            # and stop.
-            break
-          elsif fn=='-'
-            line = buf[n].sub(/#.*$/,'').rstrip
-            line << "\t##{code}"
-            line << " #{title}" unless title==''
-            buf[n] = line unless line == buf[n]
-          end
+        next unless n.positive?
+        fn,ln,code,title = fields
+        if %w[? !].include?(code)
+          # move onto error if on page
+          nvim.get_current_win.set_cursor([n,0]) if fn=='-'
+          # echo error message
+          msg = "#{fn}:#{ln}: #{title}"
+          # and stop.
+          break
+        elsif fn=='-'
+          line = buf[n].sub(/#.*$/,'').rstrip
+          line << "\t##{code}"
+          line << " #{title}" unless title==''
+          buf[n] = line unless line == buf[n]
         end
       end
     end
     nvim.command "echom #{msg.inspect}"
   end
+
+  Neovim.plugin do |plug|
+    plug.command(:Korekto){|nvim| KorektoPlug.korekto(nvim)}
+    plug.command(:KorektoPatch){|nvim| KorektoPlug.korekto(nvim, '--patch')}
+  end
 end

data/start/korekto/syntax/korekto.vim

@@ -1,21 +1,31 @@
-syntax match Unsup   /#[A-Z]\d\+\(\.\w\+\)\?/ contained containedin=Type
-syntax match Sup     /#[A-Z]\d\+\(\.\w\+\)\?\/\S\+/ contained containedin=Type
-syntax match Title   / [^:]\+/ contained containedin=Type
-syntax match Undef   /:[^#]\+$/ contained containedin=Type
-syntax match Type    /\s#[A-Z][^#]\+/ contains=Unsup,Sup,Title,Undef
-syntax match Comment /^\s*#.\+$/
-syntax match Syntax  /^[?] \S.\+$/
-syntax match Patch   /^::[A-Z]\w\+#\w\+[^=]\+=.\+$/
-syntax match Import  /^< [\/A-Za-z\_\-\.]\+$/
-syntax match Setting /^! \S.*$/
-highlight Unsup   ctermfg=brown
-highlight Sup     ctermfg=darkgreen
-highlight Title   ctermfg=darkblue
-highlight Undef   ctermfg=red
-highlight Comment ctermfg=darkblue
-highlight Import  ctermfg=brown
-highlight Patch   ctermfg=darkgrey
-highlight Syntax  ctermfg=darkgrey
-highlight Setting ctermfg=darkmagenta
-setlocal tabstop=23
+"### Korekto Syntax ###
+" Korekto Type
+syntax match KorektoUnsup /#[A-Z]\d\+\(\.\w\+\)\?\(\/\)\@!/ containedin=KorektoType
+syntax match KorektoSup   /#[A-Z]\d\+\(\.\w\+\)\?\/\S\+/ contained containedin=KorektoType
+syntax match KorektoTitle /\(#[A-Z]\d\S*\s\)\@<=[^:]\+/ contained containedin=KorektoType
+syntax match KorektoUndef /\(:\)\@<=.\+$/ contained containedin=KorektoType
+syntax match KorektoType  /#[A-Z]\d[^#]\+$/ contains=KorektoUnsup,KorektoSup,KorektoTitle,KorektoUndef
+" Korekto Statement
+syntax match KorektoLetter      /[A-Za-z𝐀-𝟿]/ contained containedin=KorektoStatement
+syntax match KorektoNumber      /[0-9]/ contained containedin=KorektoStatement
+syntax match KorektoPunctuation /[^0-9A-Za-z𝐀-𝟿]/ contained containedin=KorektoStatement
+syntax match KorektoStatement   /^.\+\(\s#[A-Z]\d\)\@=/ contains=KorektoLetter,KorektoNumber,KorektoPunctuation
+" Korekto Non-Statement
+syntax match KorektoComment /^#\+\s.\+/
+syntax match KorektoPatch   /^::[A-Z].\+/
+syntax match KorektoCommand /^[<!?]\s.\+/
+"### Korekto Highlighting ###
+highlight KorektoUnsup       ctermfg=brown
+highlight KorektoSup         ctermfg=darkgreen
+highlight KorektoTitle       ctermfg=blue
+highlight KorektoUndef       ctermfg=red
+highlight KorektoComment     ctermfg=darkblue
+highlight KorektoPatch       ctermfg=grey
+highlight KorektoCommand     ctermfg=lightgrey
+highlight KorektoPunctuation ctermfg=darkgrey
+highlight KorektoNumber 	   ctermfg=darkred
+highlight KorektoLetter 	   ctermfg=black
+"### Settings ###
+setlocal tabstop=3
+map <leader><F7> :KorektoPatch<CR>
 map <F7> :Korekto<CR>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: korekto
 version: !ruby/object:Gem::Version
-  version: 1.6.210409
+  version: 2.0.231231
 platform: ruby
 authors:
-- carlosjhr64
-autorequire:
+- CarlosJHR64
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-09 00:00:00.000000000 Z
+date: 2023-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: help_parser
@@ -16,30 +16,131 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '8.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.200907
+        version: 8.2.230210
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '8.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.200907
+        version: 8.2.230210
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 9.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 9.1.0
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.2
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.59'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.59.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.59'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.59.0
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.1
 description: |
   A general proof checker.
 
-  Works with neovim(nvim).
+  Works with [neovim](https://github.com/neovim/neovim).
 email: carlosjhr64@gmail.com
 executables:
 - korekto
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
 - bin/korekto
 - lib/korekto.rb
 - lib/korekto/heap.rb
@@ -55,7 +156,7 @@ homepage: https://github.com/carlosjhr64/korekto
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -70,12 +171,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 3.0.1p64 (2021-04-05 revision 0fb782ee38) [x86_64-linux]'
-- 'nvim: NVIM v0.4.4'
-- 'neovim-ruby-host: 0.8.1'
-- 'xdg-open: xdg-open 1.1.3+'
-rubygems_version: 3.2.15
-signing_key:
+- 'git: 2.30'
+- 'neovim-ruby-host: 0.9'
+- 'nvim: 0.9'
+- 'ruby: 3.3'
+- 'xdg-open: 1.1'
+rubygems_version: 3.5.3
+signing_key: 
 specification_version: 4
 summary: A general proof checker.
 test_files: []