kpeg 1.0.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7cbdc1c35b943bc3f71391cb377b422b91e68f52
-  data.tar.gz: 43d2cb391965f7ffd22f9afcbfee3f02b952ae3c
+SHA256:
+  metadata.gz: 69daab2a8357318c67653138ac1279d035305af374c0840164b535d3110a9a34
+  data.tar.gz: 703023a2c28f68a26cf1b84255e4aede05880eb6356ced93ec244bad471f05f7
 SHA512:
-  metadata.gz: 0a6aa682aefebb2c59f72e17a88be5a7c956bb87d8d1700b29916bbb624297959e7273ab57262f895ea073e2a08a91dd40b2879d532dfdef729720df980fb3fb
-  data.tar.gz: cdb1452be3a93769b4aba53e58cc13224b66eeca67b21b21df4731d4445d06b84c85f70432510e004f011e6902d1dcf34d3bb205fe661eacbaf1a6fda088f2d0
+  metadata.gz: f98d1334465ea3728004aea43b5abe33d8deae27c4100beaa091a87292ac0197a4580207b3036da616054d5dab8f931621597fc6c2294698eb32842be37e5458
+  data.tar.gz: acbd264cfd9de363de5eac6107baa58ef43535b5a071fee6da11ff2b33cdd6c2a378664b137b9bb359504b12b0e2f2060fca8cfde53d8196309c68f3132e6e0f

data/.hoeignore

@@ -0,0 +1,12 @@
+.hoeignore
+.gitignore
+.travis.yml
+.git/
+t/
+tmp/
+scratch/
+test/
+examples/
+Gemfile.lock
+*.jar
+*.bundle

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/History.txt

@@ -1,3 +1,21 @@
+=== 1.3.1 / 2022-01-10
+
+* File.exists? => File.exist?
+
+=== 1.3.0 / 2021-10-20
+
+* Fix current_line calculation
+
+=== 1.2.0 / 2021-10-20
+
+* Speed up current_line
+
+=== 1.2.0 / 2021-10-20
+
+* Speed up current_line
+
+=== (entries lost to time)
+
 === 0.10 / 2012-04-16
 
 * Minor enhancements

data/Manifest.txt

@@ -1,5 +1,6 @@
 .autotest
-.travis.yml
+.hoeignore
+Gemfile
 History.txt
 LICENSE
 Manifest.txt
@@ -17,6 +18,12 @@ examples/lua_string/lua_string.kpeg.rb
 examples/phone_number/README.md
 examples/phone_number/phone_number.kpeg
 examples/phone_number/phone_number.rb
+examples/tiny_markdown/Rakefile
+examples/tiny_markdown/driver.rb
+examples/tiny_markdown/node.rb
+examples/tiny_markdown/sample.md
+examples/tiny_markdown/tiny_markdown.kpeg
+examples/tiny_markdown/tiny_markdown.kpeg.rb
 examples/upper/README.md
 examples/upper/upper.kpeg
 examples/upper/upper.rb
@@ -42,5 +49,6 @@ test/test_kpeg_format.rb
 test/test_kpeg_format_parser_round_trip.rb
 test/test_kpeg_grammar.rb
 test/test_kpeg_grammar_renderer.rb
+test/test_kpeg_string_escape.rb
 vim/syntax_kpeg/ftdetect/kpeg.vim
 vim/syntax_kpeg/syntax/kpeg.vim

data/README.rdoc

@@ -143,13 +143,13 @@ Once you have the generated parser, include that file into your new grammar
 Then create a variable to hold to foreign interface and pass it the class name
 of your parser. In this case my parser class name is Literal 
 
-  %foreign_grammer = Literal
+  %foreign_grammar = Literal
 
 You can then use rules defined in the foreign grammar in the local grammar
 file like so
 
-  sentence = (%foreign_grammer.alpha %foreign_grammer.space*)+
-             %foreign_grammer.period
+  sentence = (%foreign_grammar.alpha %foreign_grammar.space*)+
+             %foreign_grammar.period
 
 === Comments
 
@@ -240,15 +240,15 @@ For a good example of usage check out Talon[https://github.com/evanphx/talon]
 There are several examples available in the /examples directory. The upper
 parser has a readme with a step by step description of the grammar.
 
-== Projects using kpeg
+== Projects
 
-Dang[https://github.com/veganstraightedge/dang]
+{Dang}[https://github.com/veganstraightedge/dang]
 
 {Email Address Validator}[https://github.com/larb/email_address_validator]
 
-Callisto[https://github.com/dwaite/Callisto]
+{Callisto}[https://github.com/dwaite/Callisto]
 
-Doodle[https://github.com/vito/doodle]
+{Doodle}[https://github.com/vito/doodle]
 
-Kanbanpad[https://kanbanpad.com] (uses kpeg for parsing of the 'enter
+{Kanbanpad}[https://kanbanpad.com] (uses kpeg for parsing of the 'enter
 something' bar)

data/Rakefile

@@ -11,6 +11,8 @@ Hoe.plugin :travis
 Hoe.spec 'kpeg' do
   self.readme_file = "README.rdoc"
   developer 'Evan Phoenix', 'evan@fallingsnow.net'
+
+  dependency 'minitest', '~> 5.0', :dev
 end
 
 task :test => :parser

data/bin/kpeg

@@ -8,7 +8,7 @@ require 'kpeg/grammar_renderer'
 require 'optparse'
 
 options = {}
-OptionParser.new do |o|
+optparser = OptionParser.new do |o|
   o.banner = "Usage: kpeg [options]"
 
   o.on("-t", "--test", "Syntax check the file only") do |v|
@@ -42,11 +42,18 @@ OptionParser.new do |o|
   o.on("-d", "--debug", "Debug parsing the file") do |v|
     options[:debug] = v
   end
-end.parse!
+end
+
+optparser.parse!
+
+if ARGV.empty?
+  puts optparser.help
+  exit 1
+end
 
 file = ARGV.shift
 
-unless File.exists?(file)
+unless File.exist?(file)
   puts "File '#{file}' does not exist"
   exit 1
 end
@@ -68,7 +75,7 @@ if options[:reformat]
   end
 
   output = options[:output]
-  if File.exists?(output) and !options[:force]
+  if File.exist?(output) and !options[:force]
     puts "Output '#{output}' already exists, not overwriting (use -f)"
     exit 1
   end
@@ -100,7 +107,7 @@ else
   new_path = "#{file}.rb"
 end
 
-if !options[:test] and File.exists?(new_path) and !options[:force]
+if !options[:test] and File.exist?(new_path) and !options[:force]
   puts "Path #{new_path} already exists, not overwriting\n"
   exit 1
 end

data/examples/lua_string/lua_string.kpeg.rb

@@ -275,8 +275,6 @@ class LuaString
         else
           return ans
         end
-
-        return ans
       end
     end
 

data/examples/tiny_markdown/Rakefile

@@ -0,0 +1,3 @@
+task :kpeg do
+  sh "kpeg -s -f tiny_markdown.kpeg"
+end

data/examples/tiny_markdown/driver.rb

@@ -0,0 +1,10 @@
+module TinyMarkdown; end
+require_relative 'tiny_markdown.kpeg.rb'
+require_relative 'node.rb'
+
+md = File.read(ARGV[0])
+
+parser = TinyMarkdown::Parser.new(md)
+parser.parse
+ast = parser.ast
+puts ast.to_html

data/examples/tiny_markdown/node.rb

@@ -0,0 +1,107 @@
+module TinyMarkdown
+  class Node
+    def to_html
+      if !self.respond_to?(:content)
+        return ""
+      end
+      if self.content.kind_of?(Array)
+        self.content.map(&:to_html).join("")
+      elsif self.content.kind_of?(TinyMarkdown::Node)
+        self.content.to_html
+      elsif self.content
+        self.content.to_s
+      else
+        ""
+      end
+    end
+
+    def inspect
+      if self.respond_to?(:content)
+        '#<'+self.class.to_s+' content="'+self.content.to_s+'">'
+      else
+        '#<'+self.class.to_s+'>'
+      end
+    end
+  end
+
+  class HeadlineNode
+    def to_html
+      children = self.content.map(&:to_html).join("")
+      "<h#{level}>#{children}</h#{level}>\n"
+    end
+  end
+
+  class TextNode
+    def to_html
+      self.content.to_s
+    end
+  end
+
+  class BlockQuoteNode
+    def to_html
+      children = self.content.map(&:to_html).join("")
+      "<blockquote>#{children}</blockquote>\n"
+    end
+  end
+
+  class BulletListNode
+    def to_html
+      children = self.content.map(&:to_html).join("")
+      "<ul>\n#{children}</ul>\n"
+    end
+  end
+
+  class BulletListItemNode
+    def to_html
+      children = self.content.map(&:to_html).join("")
+      "<li>#{children}</li>\n"
+    end
+  end
+
+  class PlainNode
+    def to_html
+      self.content.map(&:to_html).join("")
+    end
+  end
+
+  class ParaNode
+    def to_html
+      children = self.content.map(&:to_html).join("")
+      "<p>#{children}</p>\n"
+    end
+  end
+
+  class VerbatimNode
+    def to_html
+      children = self.content.map(&:to_html).join("")
+      "<pre><code>#{children}</code></pre>\n"
+    end
+  end
+
+  class InlineElementNode
+    def to_html
+      children = self.content.map(&:to_html).join("")
+      "<#{self.name}>#{children}</#{self.name}>"
+    end
+
+    def inspect
+        '#<'+self.class.to_s+' name="'+self.name.to_s+'" content="'+self.content.to_s+'">'
+    end
+  end
+
+  class LineBreakNode
+    def to_html
+      "<br />\n"
+    end
+
+    def inspect
+      "\\n"
+    end
+  end
+
+  class HorizontalRuleNode
+    def to_html
+      "<hr />\n"
+    end
+  end
+end

data/examples/tiny_markdown/sample.md

@@ -0,0 +1,51 @@
+# test
+
+## inline
+
+### strong1
+
+aaa **bbb** cc *dd*
+
+### strong2
+
+ee _fff_ gg __hhh__
+
+### code
+
+iii `jjjjj` kk `lll`
+
+## block
+
+### bullet
+
+* mmm
+* nnnnn
+* ooo
+
+### quote
+
+> pppp
+> qqqq
+> rrrr
+>
+> inlines are ignored **sss** ttt __uuu__
+
+### verbatim
+
+before verbatim.
+
+    yyyy
+    zzzz
+    1111
+
+    this is verbatim
+    2222
+    this is verbatim
+
+after verbatim.
+
+### Horizontal Rule
+
+
+- - - - -
+

data/examples/tiny_markdown/tiny_markdown.kpeg

@@ -0,0 +1,199 @@
+%% name = TinyMarkdown::Parser
+%% ast-location = ::TinyMarkdown
+%% document = ast DocumentNode(compiler, position, content)
+%% para = ast ParaNode(compiler, position, content)
+%% plain = ast PlainNode(compiler, position, content)
+%% text = ast TextNode(compiler, position, content)
+%% headline = ast HeadlineNode(compiler, position, level, content)
+%% block_quote = ast BlockQuoteNode(compiler, position, content)
+%% verbatim = ast VerbatimNode(compiler, position, content)
+%% horizontal_rule = ast HorizontalRuleNode(compiler, position)
+%% bullet_list = ast BulletListNode(compiler, position, content)
+%% list = ast ListNode(compiler, position, content)
+%% bullet_list_item = ast BulletListItemNode(compiler, position, content)
+%% linebreak = ast LineBreakNode(compiler, position)
+%% inline_element = ast InlineElementNode(compiler, position, name, content)
+
+%% {
+  attr_reader :ast
+
+  class Position
+    attr_accessor :pos, :line, :col
+    def initialize(compiler)
+      @pos = compiler.pos
+      @line = compiler.current_line
+      @col = compiler.current_column
+    end
+  end
+
+  def position
+    Position.new(self)
+  end
+}
+
+root = Start
+
+Start = &. Doc:c { @ast = c  }
+
+Doc =       Block*:c
+            ~document(self, position, c)
+
+Block =     BlankLine*
+            ( BlockQuote
+            | Verbatim
+            | HorizontalRule
+            | Heading
+            | BulletList
+            | Para
+            | Plain )
+
+Para =      NonindentSpace Inlines:a BlankLine+ ~para(self, position, a)
+
+Plain =     Inlines:a ~plain(self, position, a)
+
+AtxInline = !Newline !(Sp '#'* Sp Newline) Inline:c { c }
+
+AtxStart =  < /######|#####|####|###|##|#/ > { text.length }
+
+AtxHeading = AtxStart:level Sp AtxInline+:c (Sp "#"* Sp)?  Newline ~headline(self, position, level, c)
+
+Heading = AtxHeading
+
+BlockQuote = BlockQuoteRaw:c ~block_quote(self, position, c)
+
+BlockQuoteRaw =  ( '>' ' '? Line:c { c })+:cc { cc }
+
+NonblankIndentedLine = !BlankLine IndentedLine:c { c }
+
+VerbatimChunk =  (BlankLine { text(self,position,"\n") } )*:c1
+                 (NonblankIndentedLine:c { [c, text(self,position,"\n")] })+:c2 { c1 + c2.flatten }
+
+Verbatim =     VerbatimChunk+:cc ~verbatim(self, position, cc.flatten)
+
+HorizontalRule = NonindentSpace
+                 ( '*' Sp '*' Sp '*' (Sp '*')*
+                 | '-' Sp '-' Sp '-' (Sp '-')*
+                 | '_' Sp '_' Sp '_' (Sp '_')*)
+                 Sp Newline BlankLine+ ~horizontal_rule(self, position)
+
+Bullet = !HorizontalRule NonindentSpace ('+' | '*' | '-') Spacechar+
+
+BulletList = &Bullet ListTight:c ~bullet_list(self, position, c)
+
+ListTight = ListItemTight+:cc
+            BlankLine* !Bullet
+            { cc }
+
+ListItemTight = Bullet ListBlock:c ~bullet_list_item(self, position, c)
+
+ListBlock = !BlankLine Line:c ListBlockLine*:cc { cc.unshift(c) }
+
+ListBlockLine = !BlankLine
+                !( Indent? Bullet )
+                !HorizontalRule
+                OptionallyIndentedLine
+
+
+
+Inlines  =  ( !Endline Inline:c { c }
+            | Endline:c &Inline { c } )+:cc Endline?
+            { cc }
+
+Inline  = Str
+        | Endline
+        | Space
+        | Strong
+        | Emph
+        | Code
+        | Symbol
+
+Space = Spacechar+:c ~text(self, position, c.join(""))
+
+Str = NormalChar+:c1
+      StrChunk*:c2
+      ~text(self, position, (c1+c2).join(""))
+
+StrChunk = (NormalChar:c { [c] } | '_'+:c1 NormalChar:c2 { c1.push(c2) } )+:cc  { cc.flatten }
+
+
+Endline =   LineBreak | TerminalEndline | NormalEndline
+
+NormalEndline =   Sp Newline !BlankLine !'>' !AtxStart
+                  !(Line ('='+ | '-'+) Newline)
+                  ~text(self, position, "\n")
+
+TerminalEndline = Sp Newline Eof ~text(self, position, "\n")
+
+LineBreak = "  " NormalEndline ~linebreak(self, position)
+
+Symbol =    SpecialChar:c ~text(self, position, c)
+
+
+Emph =      EmphStar | EmphUl
+
+Whitespace = Spacechar | Newline
+
+EmphStar =  '*' !Whitespace
+            ( !'*' Inline:b { b }
+            | StrongStar:b  { b }
+            )+:c
+            '*'
+            ~inline_element(self, position, :em, c)
+
+EmphUl =    '_' !Whitespace
+            ( !'_' Inline:b { b }
+            | StrongUl:b  { b }
+            )+:c
+            '_'
+            ~inline_element(self, position, :em, c)
+
+Strong = StrongStar | StrongUl
+
+StrongStar =    "**" !Whitespace
+                ( !"**" Inline:b { b })+:c
+                "**"
+                ~inline_element(self, position, :strong, c)
+
+StrongUl   =    "__" !Whitespace
+                ( !"__" Inline:b { b })+:c
+                "__"
+                ~inline_element(self, position, :strong, c)
+
+
+
+Ticks1 = < /`/ > !'`' { text }
+Ticks2 = < /``/ > !'`' { text }
+
+Code =  ( Ticks1 Sp
+           ( !'`' Nonspacechar )+:c
+           Sp Ticks1  ~text(self, position, c.join(""))
+        | Ticks2 Sp
+           ( !'``' Nonspacechar )+:c
+           Sp Ticks2 ~text(self, position, c.join(""))
+        ):cc
+       ~inline_element(self, position, :code, [cc])
+
+
+BlankLine =     Sp Newline
+
+Quoted =        '"' (!'"' .)* '"' | '\'' (!'\'' .)* '\''
+Eof =           !.
+Spacechar =     < / |\t/ > { text }
+Nonspacechar =  !Spacechar !Newline <.> { text }
+Newline =       "\n" | "\r" "\n"?
+Sp =            Spacechar*
+Spnl =          Sp (Newline Sp)?
+##SpecialChar =   '~' | '*' | '_' | '`' | '&' | '[' | ']' | '(' | ')' | '<' | '!' | '#' | "\\" | "'" | '"'
+SpecialChar =   < /[~*_`&\[\]()<!#\\'"]/ > { text }
+NormalChar =    !( SpecialChar | Spacechar | Newline ) <.> { text }
+AlphanumericAscii =  < /[A-Za-z0-9]/ > { text }
+Digit =  < /[0-9]/ > { text }
+
+NonindentSpace =    < /   |  | |/ > { text }
+Indent =            < /\t|    / > { text }
+IndentedLine =      Indent Line:c { c }
+OptionallyIndentedLine = Indent? Line
+
+Line =  RawLine:c { c }
+RawLine = ((  < /[^\r\n]*/ > ) Newline { text } |  < /.+/ > Eof { text }):c  ~text(self, position, c)
+