broomhlda 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b531cf8a1deb12865af0da4152652846aa41d4b8
-  data.tar.gz: 940fb9d11c3ed725af5e32c92b6d6988d3edc275
+  metadata.gz: a3a9585d07f566041aaa2f64eb3c39d8549659b0
+  data.tar.gz: f177b9a4c5037651d946fed5b778701199732973
 SHA512:
-  metadata.gz: c747b4053c1bc6b035f49207fcf5262d6b77f3634d79ec9dd46877f0ae28e35e4068c3afadbc8e088314ea51ffb18c791db5c209749497f2e7d4e27f12095c97
-  data.tar.gz: 4a1095545987f373e2a6a807db9d927569fb57985d32db51e854c8eee6dbbdd344e36d24b6533cc03cfa017db0fda818236ba39c09f5888eb02c6355fee6fd38
+  metadata.gz: db598fbeb791fb044348c1a28925edee938c043ed4a235170b6ac2c4c90c7059e1d8ae6e98c371d1b3209c76e420975667b3222f37636c726d51ab058a51d152
+  data.tar.gz: 8cc5f90657ff5fcf48e722bc0daa958bceb7f449d17f17b3153e74fb39b8c3ff21453546bec350d9a4a32c90d6f845b544c9e85ea039775e7762a09469bcf93e

data/lib/hl/define.ay

@@ -53,14 +53,11 @@ def(type-from(`(using(~who)))):
 
 def(type-from(x)): raise("unknown match type: " + x inspect)
 
-def(regexp-from(x, regexps)):
-  regexps <<
-    `([x]: Regexp new(
-        x source
-        x options | @info fetch(.flags)
-      ); call(~x))
-
-  `(regexps[~(Atomy Grammar AST Number new(regexps size - 1))])
+def(regexp-from(x)):
+  `([x]: Regexp new(
+      x source
+      x options | @info fetch(.flags)
+    ); call(~x))
 
 def(state-from('pop)): '(State Pop new)
 def(state-from(`(pop(~n)))): `(State PopNum new(~n))
@@ -86,15 +83,13 @@ macro(lex(~name) [~*args]: ~*tokens):
 
   body = []
 
-  regexps = []
-
   tokens each [c]:
     c match:
       -- implicit continue state
       `(~x is(~y)):
         branches <<
           `(Matcher new(
-              ~(regexp-from(x, regexps))
+              ~(regexp-from(x))
               ~(type-from(y))
               State Continue new
             ))
@@ -103,7 +98,7 @@ macro(lex(~name) [~*args]: ~*tokens):
       `(~x is(~y) -> ~z):
         branches <<
           `(Matcher new(
-              ~(regexp-from(x, regexps))
+              ~(regexp-from(x))
               ~(type-from(y))
               ~(state-from(z))
             ))
@@ -112,7 +107,7 @@ macro(lex(~name) [~*args]: ~*tokens):
       `(~x is(~y) => ~z):
         branches <<
           `(Matcher new(
-              ~(regexp-from(x, regexps))
+              ~(regexp-from(x))
               ~(type-from(y))
               State GoTo new(@matchers, .~z)
             ))
@@ -126,6 +121,5 @@ macro(lex(~name) [~*args]: ~*tokens):
 
   body << `([~*branches] flatten)
 
-  `([regexps] {
-      @matchers[.~name] = proc [~*args]: ~*body
-    } call([~*regexps]))
+  `(@matchers[.~name] = proc [~*args]:
+      ~*body)

data/lib/hl/formatters/html.ay

@@ -13,7 +13,7 @@ formatter = class:
       div(#{ .class: "highlight" }) [d]:
         d pre [p]:
           format-tokens(p)
-      
+
     builder doc children first serialize(#{ .save-with: 0 })
 
   def(format-tokens(to)):

data/lib/hl/lexer.ay

@@ -40,7 +40,7 @@ fn(try-all(matchers)):
         break
 
   unless(closest):
-    /error(NoMatchFor new(@input))
+    Self error(NoMatchFor new(@input))
 
   skipped = closest pre-match
   @input = closest post-match
@@ -55,7 +55,7 @@ fn(try-all(matchers)):
 
   tokens(closest, worked type)
 
-lexer = class:
+class(Lexer):
   def(initialize(input)):
     @input = input dup
 
@@ -95,5 +95,3 @@ lexer = class:
 
     def(flags &x):
       @info[.flags] = x call
-
-const-set(.Lexer, lexer)

data/lib/hl/lexers/yaml.ay

@@ -0,0 +1,348 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "YAML"
+  aliases: "yaml"
+  extensions: [".yaml", ".yml"]
+  mimetypes: "text/x-yaml"
+  start: .root
+  flags: Regexp MULTILINE
+
+  -- starting point for lexing
+  lex(root):
+    @indent-stack = []
+    @indent = -1
+    @next-indent = 0
+
+    -- ignored whitespace
+    r"[ ]+(?=#|$)" is(text)
+
+    -- line breaks
+    r"\n+" is(text)
+
+    -- comments
+    r"#[^\n]*" is(comment.single)
+
+    -- '%YAML' directive
+    r"^%YAML(?=[ ]|$)" is(name.tag) -> do-all(
+      go-to(reset-indent)
+      go-to(yaml-directive)
+    )
+
+    -- '%TAG' directive
+    r"^%TAG(?=[ ]|$)" is(name.tag) -> do-all(
+      go-to(reset-indent)
+      go-to(tag-directive)
+    )
+
+    -- document start/end indicators
+    r"^(?:---|\.\.\.)(?=[ ]|$)" is(name.namespace) -> do-all(
+      go-to(reset-indent)
+      go-to(block-line)
+    )
+
+    -- indentation
+    r"[ ]*(?!\s|$)" is(text) -> do-all(
+      go-to(save-start-indent)
+      go-to(block-line)
+      go-to(indentation)
+    )
+
+
+  lex(reset-indent):
+    @indent-stack = []
+    @indent = -1
+    @next-indent = 0
+
+    r"" is(text) -> pop
+
+  lex(save-start-indent) [d]:
+    @next-indent = d[0] size
+
+    when(@next-indent < @indent):
+      while(@next-indent < @indent):
+        @indent = @indent-stack pop
+
+    r"" is(text) -> pop
+
+  lex(save-indent) [d]:
+    @next-indent += d[0] size
+
+    r"" is(text) -> pop
+
+  lex(set-indent) [d]:
+    when(@indent < @next-indent):
+      @indent-stack << @indent
+      @indent = @next-indent
+
+    @next-indent += d[0] size
+
+    r"" is(text) -> pop
+
+  lex(set-implicit-indent) [d]:
+    when(@indent < @next-indent):
+      @indent-stack << @indent
+      @indent = @next-indent
+
+    r"" is(text) -> pop
+
+
+  lex(ignored-line):
+    -- ignored whitespace
+    r"[ ]+(?=#|$)" is(text)
+
+    -- a comment
+    r"#[^\n]*" is(comment.single)
+
+    -- line break
+    r"\n" is(text) -> pop(2)
+
+
+  lex(yaml-directive):
+    -- the version number
+    r"([ ]+)([0-9]+\.[0-9]+)" is(by-groups(text, number)) => ignored-line
+
+
+  lex(tag-directive):
+    -- a tag handle and the corresponding prefix
+    r"([ ]+)(!|![\w-]*!)([ ]+)(!|!?[\w;/?:@&=+$,.!~*'()\[\]%-]+)" is(
+        by-groups(text, keyword.type, text, keyword.type)) => ignored-line
+
+
+  lex(indentation):
+    -- trailing whitespaces are ignored
+    r"[ ]*$" is(text) -> pop(2)
+
+    -- whitespaces preceding block collection indicators
+    r"[ ]+(?=[?:-](?:[ ]|$))" is(text) => save-indent
+
+    -- block collection indicators
+    r"[?:-](?=[ ]|$)" is(punctuation.indicator) => set-indent
+
+    -- the beginning a block line
+    r"[ ]*" is(text) -> do-all(pop, go-to(save-indent))
+
+
+  lex(block-line):
+    -- the line end
+    r"[ ]*(?=#|$)" is(text) -> pop -- something(Text)
+
+    -- whitespaces separating tokens
+    r"[ ]+" is(text)
+
+    -- tags, anchors and aliases,
+    any-of(descriptors)
+
+    -- block collections and scalars
+    any-of(block-nodes)
+
+    -- flow collections and quoted scalars
+    any-of(flow-nodes)
+
+    -- a plain scalar
+    r"(?=[^\s?:,\[\]{}#&*!|>'\"%@`-]|[?:-]\S)" is(name.variable) => plain-scalar-in-block-context -- something(Name.Variable)
+
+
+  lex(descriptors):
+    -- a full-form tag
+    r"!<[\w;/?:@&=+$,.!~*'()\[\]%-]+>" is(keyword.type)
+
+    -- a tag in the form '!', '!suffix' or '!handle!suffix'
+    r"!(?:[\w-]+)?(?:![\w;/?:@&=+$,.!~*'()\[\]%-]+)?" is(keyword.type)
+
+    -- an anchor
+    r"&[\w-]+" is(name.label)
+
+    -- an alias
+    r"\*[\w-]+" is(name.variable)
+
+
+  lex(block-nodes):
+    -- implicit key
+    r":(?=[ ]|$)" is(punctuation.indicator) => set-implicit-indent
+
+    -- literal and folded scalars
+    r"[|>][+-]?\n(?=([ ]*))" is(punctuation.indicator) => block-scalar-content
+
+    -- literal and folded scalars with explicit indent levels
+    r"[|>][+-]?([0-9]+)\n" is(punctuation.indicator) => block-scalar-content-with-indent
+    r"[|>]([0-9]+)[+-]?\n" is(punctuation.indicator) => block-scalar-content-with-indent
+
+
+  lex(block-scalar-content) [d]:
+    -- line break
+    r"\n" is(text)
+
+    -- indented line
+    r"^([ ]{#{d[1] size}})([^\n]*)" is(by-groups(text, name.constant))
+
+    -- unindented; leave state
+    r"^([ ]{0,#{d[1] size - 1}})(?=[^ ])" is(text) -> pop(2)
+
+
+  lex(block-scalar-content-with-indent) [d]:
+    -- line break
+    r"\n" is(text)
+
+    -- indented line
+    r"^([ ]{#{d[1] to-i}})([^\n]*)" is(by-groups(text, name.constant))
+
+    -- unindented; leave state
+    r"^([ ]{0,#{d[1] to-i - 1}})(?=[^ ])" is(text) -> pop(2)
+
+
+  lex(flow-nodes):
+    -- a flow sequence
+    r"\[" is(punctuation.indicator) => flow-sequence
+
+    -- a flow mapping
+    r"\{" is(punctuation.indicator) => flow-mapping
+
+    -- a single-quoted scalar
+    r"'" is(string) => single-quoted-scalar
+
+    -- a double-quoted scalar
+    r"\"" is(string) => double-quoted-scalar
+
+
+  lex(flow-collection):
+    -- whitespaces
+    r"[ ]+" is(text)
+
+    -- line breaks
+    r"\n+" is(text)
+
+    -- a comment
+    r"#[^\n]*" is(comment.single)
+
+    -- simple indicators
+    r"[?:,]" is(punctuation.indicator)
+
+    -- tags, anchors and aliases
+    any-of(descriptors)
+
+    -- nested collections and quoted scalars
+    any-of(flow-nodes)
+
+    -- a plain scalar
+    r"(?=[^\s?:,\[\]{}#&*!|>'\"%@`])" is(name.variable) => plain-scalar-in-flow-context
+
+
+  lex(flow-sequence):
+    -- include flow collection rules
+    any-of(flow-collection)
+
+    -- the closing indicator
+    r"\]" is(punctuation.indicator) -> pop
+
+
+  lex(flow-mapping):
+    -- include flow collection rules
+    any-of(flow-collection)
+
+    -- the closing indicator
+    r"\}" is(punctuation.indicator) -> pop
+
+
+  lex(quoted-scalar-whitespaces):
+    -- leading and trailing whitespaces are ignored
+    r"^[ ]+" is(text)
+    r"[ ]+$" is(text)
+
+    -- line breaks are ignored
+    r"\n+" is(text)
+
+    -- other whitespaces are a part of the value
+    r"[ ]+" is(name.variable)
+
+
+  lex(single-quoted-scalar):
+    -- include whitespace and line break rules
+    any-of(quoted-scalar-whitespaces)
+
+    -- escaping of the quote character
+    r"\'\'" is(string.escape)
+
+    -- regular non-whitespace characters
+    r"[^\s\']+" is(string)
+
+    -- the closing quote
+    r"\'" is(string) -> pop
+
+
+  lex(double-quoted-scalar):
+    -- include whitespace and line break rules
+    any-of(quoted-scalar-whitespaces)
+
+    -- escaping of special characters
+    r"\\[0abt\tn\nvfre \"\\N_LP]" is(string)
+
+    -- escape codes
+    r"\\(?:x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})" is(string.escape)
+
+    -- regular non-whitespace characters
+    r"[^\s\"\\]+" is(string)
+
+    -- the closing quote
+    r"\"" is(string) -> pop
+
+
+  lex(plain-scalar-in-block-context-new-line):
+    -- empty lines
+    r"^[ ]+$" is(text)
+
+    -- line breaks
+    r"\n+" is(text)
+
+    -- document start and document end indicators
+    r"^(?=---|\.\.\.)" is(name.namespace) -> pop(3)
+
+    -- continuing indentation spaces
+    r"^[ ]{#{@indent}}" is(text) -> pop
+
+    -- unindented; pop out of scalar
+    r"^[ ]{0,#{@indent - 1}}(?=[^ ])" is(text) -> pop(3)
+
+
+  lex(plain-scalar-in-block-context):
+    -- the scalar ends with the ':' indicator
+    r"[ ]*(?=:[ ]|:$)" is(text) -> pop -- something(Text)
+
+    -- the scalar ends with whitespaces followed by a comment
+    r"[ ]+(?=#)" is(text) -> pop
+
+    -- trailing whitespaces are ignored
+    r"[ ]+$" is(text)
+
+    -- line breaks are ignored
+    r"\n+" is(text) => plain-scalar-in-block-context-new-line
+
+    -- other whitespaces are a part of the value
+    r"[ ]+" is(literal.scalar.plain)
+
+    -- regular non-whitespace characters
+    r"(?::(?!\s)|[^\s:])+" is(name.property) --literal.scalar.plain)
+
+
+  lex(plain-scalar-in-flow-context):
+    -- the scalar ends with an indicator character
+    r"[ ]*(?=[,:?\[\]{}])" is(text) -> pop -- something(Text)
+
+    -- the scalar ends with a comment
+    r"[ ]+(?=#)" is(text) -> pop
+
+    -- leading and trailing whitespaces are ignored
+    r"^[ ]+" is(text)
+    r"[ ]+$" is(text)
+
+    -- line breaks are ignored
+    r"\n+" is(text)
+
+    -- other whitespaces are a part of the value
+    r"[ ]+" is(name.variable)
+
+    -- regular non-whitespace characters
+    r"[^\s,:?\[\]{}]+" is(name.variable)
+
+const-set(.Lexer, lexer)

metadata

@@ -1,39 +1,39 @@
 --- !ruby/object:Gem::Specification
 name: broomhlda
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Alex Suraci
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-09 00:00:00.000000000 Z
+date: 2015-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: atomy
-  version_requirements: !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.2
+        version: 0.6.3
   type: :runtime
-  prerelease: false
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.2
+        version: 0.6.3
 - !ruby/object:Gem::Dependency
   name: rake
-  version_requirements: !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.4'
   type: :development
-  prerelease: false
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
@@ -215,9 +215,10 @@ files:
 - lib/hl/lexers/imported/xslt.ay
 - lib/hl/lexers/imported/xtend.ay
 - lib/hl/lexers/ruby.ay
+- lib/hl/lexers/yaml.ay
 - lib/hl/state.ay
 - lib/hl/token.ay
-homepage: http://atomy-lang.org
+homepage: https://vito.github.io/atomy
 licenses:
 - Apache-2.0
 metadata: {}
@@ -237,7 +238,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: broomhlda syntax highlighter and tokenizer