myco 0.1.8 → 0.1.9

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/String/Parser.my

@@ -0,0 +1,45 @@
+
+String << {
+  Parser < Common::Parser {
+    State < Common::Parser::State {
+      var string
+      
+      var error_row
+      var error_col
+      
+      raise_error: self.error_idx && raise(SyntaxError
+        "Unexpected character with parser: "self.rule \
+          " near line: "self.error_row \
+          ", column: "self.error_col".\n" \
+          self.string.each_line.to_a[self.error_row - 1]"" \
+          (' ' * [(self.error_col - 1), 0].max)"^"
+      )
+    }
+    
+    # Match and process the given string using the current grammar
+    parse: |string, rule:"root", start_idx:0| {
+      worker    = new_worker
+      processor = new_processor
+      state     = State.new(
+        string:    string.to_s
+        rule:      rule.to_sym
+        start_idx: start_idx.to_i
+      )
+      
+      state.end_idx = worker.__send__(state.rule, state.string, state.start_idx)
+      
+      state.end_idx &? (
+        processor.string = state.string
+        processor.capture_items = captures_of_worker(worker)
+        grammar.?tokenizer && (processor.tokenizer = grammar.tokenizer)
+        state.result = processor.process
+      ) ?? (
+        state.error_idx = highest_idx_of_worker(worker)
+        pos = processor.position_of(state.error_idx, state.string)
+        state.error_row = pos.first
+        state.error_col = pos.last
+      )
+      state
+    }
+  }
+}

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/String/Parser.my.rb

@@ -0,0 +1,85 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:String).component_eval {(::Myco.cscope.for_method_definition::Parser = ::Myco::Component.new([::Myco.find_constant(:Common)::Parser], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco.cscope.for_method_definition::State = ::Myco::Component.new([::Myco.find_constant(:Common)::Parser::State], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:string, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:error_row, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:error_col, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:raise_error, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"&&", self.error_idx) {self.raise(
+      ::Myco.find_constant(:SyntaxError),
+      "Unexpected character with parser: #{self.rule} near line: #{self.error_row}, column: #{self.error_col}.\n#{self.string.each_line.to_a.__send__(
+        :[],
+        self.error_row.__send__(
+          :-,
+          1
+        )
+      )}#{" ".__send__(
+        :*,
+        [
+          self.error_col.__send__(
+            :-,
+            1
+          ),
+          0
+        ].max
+      )}^"
+    )})}
+  )}}
+  .tap { |__c__| __c__.__name__ = :State }
+  declare_meme(:parse, [], nil, ::Myco.cscope.dup) { |string, rule:"root", start_idx:0| (
+    worker = self.new_worker
+    processor = self.new_processor
+    state = ::Myco.find_constant(:State).new({
+      :string => string.to_s,
+      :rule => rule.to_sym,
+      :start_idx => start_idx.to_i
+    })
+    state.__send__(
+      :end_idx=,
+      worker.__send__(
+        state.rule,
+        state.string,
+        state.start_idx
+      )
+    )
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", state.end_idx) {(
+      processor.__send__(
+        :string=,
+        state.string
+      )
+      processor.__send__(
+        :capture_items=,
+        self.captures_of_worker(worker)
+      )
+      ::Myco.branch_op(:"&&", (Rubinius::Type.object_respond_to?(self.grammar, :tokenizer).false? ? ::Myco::Void : self.grammar.tokenizer)) {processor.__send__(
+        :tokenizer=,
+        self.grammar.tokenizer
+      )}
+      state.__send__(
+        :result=,
+        processor.process
+      )
+    )}) {(
+      state.__send__(
+        :error_idx=,
+        self.highest_idx_of_worker(worker)
+      )
+      pos = processor.position_of(
+        state.error_idx,
+        state.string
+      )
+      state.__send__(
+        :error_row=,
+        pos.first
+      )
+      state.__send__(
+        :error_col=,
+        pos.last
+      )
+    )}
+    state
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :Parser })})}}.instance

data/lib/myco/code_tools/parser/pegleromyces/spec/Patterns.test.my

@@ -1,9 +1,9 @@
 
 BasicSpec {
-  name: "Patterns"
+  name: "Common::Patterns"
   
-  new_pattern: Patterns::Base { }
-  var shorthand: Patterns::ShorthandMethods { }
+  new_pattern: Common::Patterns::Base { }
+  var shorthand: Common::Patterns::ShorthandMethods { }
   
   [tests]
   
@@ -14,21 +14,21 @@ BasicSpec {
   it "creates a NegativePredicate with the '!' unary operator": {
     a = new_pattern
     b = !a
-    assert_is_a(b, Patterns::NegativePredicate)
+    assert_is_a(b, Composite::Patterns::NegativePredicate)
     assert_equal(b.inner, a)
   }
   
   it "creates a PositivePredicate with two uses of the '!' unary operator": {
     a = new_pattern
     b = !!a
-    assert_is_a(b, Patterns::PositivePredicate)
+    assert_is_a(b, Composite::Patterns::PositivePredicate)
     assert_equal(b.inner, a)
   }
   
   it "creates a NegativePredicate with three uses of the '!' unary operator": {
     a = new_pattern
     b = !!!a
-    assert_is_a(b, Patterns::NegativePredicate)
+    assert_is_a(b, Composite::Patterns::NegativePredicate)
     assert_equal(b.inner, a)
   }
   
@@ -36,7 +36,7 @@ BasicSpec {
     a = new_pattern
     b = new_pattern
     c = a / b
-    assert_is_a(c, Patterns::OrderedChoice)
+    assert_is_a(c, Composite::Patterns::OrderedChoice)
     assert_equal(c.first, a)
     assert_equal(c.second, b)
   }
@@ -47,9 +47,9 @@ BasicSpec {
     c = new_pattern
     d = new_pattern
     e = a / b / c / d
-    assert_is_a(e, Patterns::OrderedChoice)
-    assert_is_a(e.second, Patterns::OrderedChoice)
-    assert_is_a(e.second.second, Patterns::OrderedChoice)
+    assert_is_a(e, Composite::Patterns::OrderedChoice)
+    assert_is_a(e.second, Composite::Patterns::OrderedChoice)
+    assert_is_a(e.second.second, Composite::Patterns::OrderedChoice)
     assert_equal(e.first, a)
     assert_equal(e.second.first, b)
     assert_equal(e.second.second.first, c)
@@ -60,7 +60,7 @@ BasicSpec {
     a = new_pattern
     b = new_pattern
     c = a + b
-    assert_is_a(c, Patterns::Concatenation)
+    assert_is_a(c, Composite::Patterns::Concatenation)
     assert_equal(c.first, a)
     assert_equal(c.second, b)
   }
@@ -71,9 +71,9 @@ BasicSpec {
     c = new_pattern
     d = new_pattern
     e = a + b + c + d
-    assert_is_a(e, Patterns::Concatenation)
-    assert_is_a(e.second, Patterns::Concatenation)
-    assert_is_a(e.second.second, Patterns::Concatenation)
+    assert_is_a(e, Composite::Patterns::Concatenation)
+    assert_is_a(e.second, Composite::Patterns::Concatenation)
+    assert_is_a(e.second.second, Composite::Patterns::Concatenation)
     assert_equal(e.first, a)
     assert_equal(e.second.first, b)
     assert_equal(e.second.second.first, c)
@@ -83,64 +83,64 @@ BasicSpec {
   it "creates a OneOrMore with the '+' operator used as a 'suffix' call": {
     a = new_pattern
     b = a.+
-    assert_is_a(b, Patterns::OneOrMore)
+    assert_is_a(b, Composite::Patterns::OneOrMore)
     assert_equal(b.inner, a)
     
     # This is implemented as a special case but should act the same
     a = (new_pattern + new_pattern)
     b = a.+
-    assert_is_a(b, Patterns::OneOrMore)
+    assert_is_a(b, Composite::Patterns::OneOrMore)
     assert_equal(b.inner, a)
   }
   
   it "creates a ZeroOrOne with the '-' operator used as a 'suffix' call": {
     a = new_pattern
     b = a.-
-    assert_is_a(b, Patterns::ZeroOrOne)
+    assert_is_a(b, Composite::Patterns::ZeroOrOne)
     assert_equal(b.inner, a)
   }
   
   it "creates a ZeroOrMore with the '*' operator used as a 'suffix' call": {
     a = new_pattern
     b = a.*
-    assert_is_a(b, Patterns::ZeroOrMore)
+    assert_is_a(b, Composite::Patterns::ZeroOrMore)
     assert_equal(b.inner, a)
   }
   
   it "creates a NamedCapture with the '[]' operator, given a capture name": {
     a = new_pattern
     b = a[:foo]
-    assert_is_a(b, Patterns::NamedCapture)
+    assert_is_a(b, Capture::Patterns::NamedCapture)
     assert_equal(b.inner, a)
     assert_equal(b.name, :foo)
   }
   
   it "creates an AnyCharacter with the 'any' shorthand method": {
     a = shorthand.any
-    assert_is_a(a, Patterns::AnyCharacter)
+    assert_is_a(a, String::Patterns::AnyCharacter)
   }
   
   it "creates a Character with the 'char' shorthand method": {
     a = shorthand.char('x')
-    assert_is_a(a, Patterns::Character)
+    assert_is_a(a, String::Patterns::Character)
     assert_equal(a.code, 120)
   }
   
   it "creates a CharacterString with the 'str' shorthand method": {
     a = shorthand.str('xyz')
-    assert_is_a(a, Patterns::CharacterString)
+    assert_is_a(a, String::Patterns::CharacterString)
     assert_equal(a.codes, [120,121,122])
   }
   
   it "creates a CharacterSet with the 'set' shorthand method": {
     a = shorthand.set('xyz')
-    assert_is_a(a, Patterns::CharacterSet)
+    assert_is_a(a, String::Patterns::CharacterSet)
     assert_equal(a.codes, [120,121,122])
   }
   
   it "creates a CharacterRange with the 'range' shorthand method": {
     a = shorthand.range('x','z')
-    assert_is_a(a, Patterns::CharacterRange)
+    assert_is_a(a, String::Patterns::CharacterRange)
     assert_equal(a.start, 120)
     assert_equal(a.stop,  122)
   }
@@ -149,8 +149,14 @@ BasicSpec {
     a_proc = Proc.new { }
     a = new_pattern
     b = shorthand.r(a, &a_proc)
-    assert_is_a(b, Patterns::Reduction)
+    assert_is_a(b, Capture::Patterns::Reduction)
     assert_equal(b.inner, a)
     assert_equal(b.block, a_proc)
   }
+  
+  it "creates a Stream Item with the 'si' shorthand method": {
+    a = shorthand.si([:foo?, [], true])
+    assert_is_a(a, Stream::Patterns::Item)
+    assert_equal(a.checks, [[:foo?, [], true]])
+  }
 }

data/lib/myco/code_tools/parser/pegleromyces/spec/Patterns.test.my.rb

@@ -2,10 +2,10 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Component.new([::Myco.find_constant(:BasicSpec)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| ("Patterns")}
-  declare_meme(:new_pattern, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Patterns)::Base], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| ("Common::Patterns")}
+  declare_meme(:new_pattern, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Common)::Patterns::Base], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
-  declare_meme(:shorthand, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Patterns)::ShorthandMethods], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  declare_meme(:shorthand, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Common)::Patterns::ShorthandMethods], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
   __category__(:tests).component_eval {(
     declare_meme(:"knows its name", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (self.assert_equal(
@@ -17,7 +17,7 @@
       b = a.__send__(:!)
       self.assert_is_a(
         b,
-        ::Myco.find_constant(:Patterns)::NegativePredicate
+        ::Myco.find_constant(:Composite)::Patterns::NegativePredicate
       )
       self.assert_equal(
         b.inner,
@@ -29,7 +29,7 @@
       b = a.__send__(:!).__send__(:!)
       self.assert_is_a(
         b,
-        ::Myco.find_constant(:Patterns)::PositivePredicate
+        ::Myco.find_constant(:Composite)::Patterns::PositivePredicate
       )
       self.assert_equal(
         b.inner,
@@ -41,7 +41,7 @@
       b = a.__send__(:!).__send__(:!).__send__(:!)
       self.assert_is_a(
         b,
-        ::Myco.find_constant(:Patterns)::NegativePredicate
+        ::Myco.find_constant(:Composite)::Patterns::NegativePredicate
       )
       self.assert_equal(
         b.inner,
@@ -57,7 +57,7 @@
       )
       self.assert_is_a(
         c,
-        ::Myco.find_constant(:Patterns)::OrderedChoice
+        ::Myco.find_constant(:Composite)::Patterns::OrderedChoice
       )
       self.assert_equal(
         c.first,
@@ -85,15 +85,15 @@
       )
       self.assert_is_a(
         e,
-        ::Myco.find_constant(:Patterns)::OrderedChoice
+        ::Myco.find_constant(:Composite)::Patterns::OrderedChoice
       )
       self.assert_is_a(
         e.second,
-        ::Myco.find_constant(:Patterns)::OrderedChoice
+        ::Myco.find_constant(:Composite)::Patterns::OrderedChoice
       )
       self.assert_is_a(
         e.second.second,
-        ::Myco.find_constant(:Patterns)::OrderedChoice
+        ::Myco.find_constant(:Composite)::Patterns::OrderedChoice
       )
       self.assert_equal(
         e.first,
@@ -121,7 +121,7 @@
       )
       self.assert_is_a(
         c,
-        ::Myco.find_constant(:Patterns)::Concatenation
+        ::Myco.find_constant(:Composite)::Patterns::Concatenation
       )
       self.assert_equal(
         c.first,
@@ -149,15 +149,15 @@
       )
       self.assert_is_a(
         e,
-        ::Myco.find_constant(:Patterns)::Concatenation
+        ::Myco.find_constant(:Composite)::Patterns::Concatenation
       )
       self.assert_is_a(
         e.second,
-        ::Myco.find_constant(:Patterns)::Concatenation
+        ::Myco.find_constant(:Composite)::Patterns::Concatenation
       )
       self.assert_is_a(
         e.second.second,
-        ::Myco.find_constant(:Patterns)::Concatenation
+        ::Myco.find_constant(:Composite)::Patterns::Concatenation
       )
       self.assert_equal(
         e.first,
@@ -181,7 +181,7 @@
       b = a.__send__(:+)
       self.assert_is_a(
         b,
-        ::Myco.find_constant(:Patterns)::OneOrMore
+        ::Myco.find_constant(:Composite)::Patterns::OneOrMore
       )
       self.assert_equal(
         b.inner,
@@ -194,7 +194,7 @@
       b = a.__send__(:+)
       self.assert_is_a(
         b,
-        ::Myco.find_constant(:Patterns)::OneOrMore
+        ::Myco.find_constant(:Composite)::Patterns::OneOrMore
       )
       self.assert_equal(
         b.inner,
@@ -206,7 +206,7 @@
       b = a.__send__(:-)
       self.assert_is_a(
         b,
-        ::Myco.find_constant(:Patterns)::ZeroOrOne
+        ::Myco.find_constant(:Composite)::Patterns::ZeroOrOne
       )
       self.assert_equal(
         b.inner,
@@ -218,7 +218,7 @@
       b = a.__send__(:*)
       self.assert_is_a(
         b,
-        ::Myco.find_constant(:Patterns)::ZeroOrMore
+        ::Myco.find_constant(:Composite)::Patterns::ZeroOrMore
       )
       self.assert_equal(
         b.inner,
@@ -233,7 +233,7 @@
       )
       self.assert_is_a(
         b,
-        ::Myco.find_constant(:Patterns)::NamedCapture
+        ::Myco.find_constant(:Capture)::Patterns::NamedCapture
       )
       self.assert_equal(
         b.inner,
@@ -248,14 +248,14 @@
       a = self.shorthand.any
       self.assert_is_a(
         a,
-        ::Myco.find_constant(:Patterns)::AnyCharacter
+        ::Myco.find_constant(:String)::Patterns::AnyCharacter
       )
     )}
     declare_meme(:"creates a Character with the 'char' shorthand method", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
       a = self.shorthand.char("x")
       self.assert_is_a(
         a,
-        ::Myco.find_constant(:Patterns)::Character
+        ::Myco.find_constant(:String)::Patterns::Character
       )
       self.assert_equal(
         a.code,
@@ -266,7 +266,7 @@
       a = self.shorthand.str("xyz")
       self.assert_is_a(
         a,
-        ::Myco.find_constant(:Patterns)::CharacterString
+        ::Myco.find_constant(:String)::Patterns::CharacterString
       )
       self.assert_equal(
         a.codes,
@@ -281,7 +281,7 @@
       a = self.shorthand.set("xyz")
       self.assert_is_a(
         a,
-        ::Myco.find_constant(:Patterns)::CharacterSet
+        ::Myco.find_constant(:String)::Patterns::CharacterSet
       )
       self.assert_equal(
         a.codes,
@@ -299,7 +299,7 @@
       )
       self.assert_is_a(
         a,
-        ::Myco.find_constant(:Patterns)::CharacterRange
+        ::Myco.find_constant(:String)::Patterns::CharacterRange
       )
       self.assert_equal(
         a.start,
@@ -319,7 +319,7 @@
       )
       self.assert_is_a(
         b,
-        ::Myco.find_constant(:Patterns)::Reduction
+        ::Myco.find_constant(:Capture)::Patterns::Reduction
       )
       self.assert_equal(
         b.inner,
@@ -330,5 +330,24 @@
         a_proc
       )
     )}
+    declare_meme(:"creates a Stream Item with the 'si' shorthand method", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.shorthand.si([
+        :foo?,
+        [],
+        true
+      ])
+      self.assert_is_a(
+        a,
+        ::Myco.find_constant(:Stream)::Patterns::Item
+      )
+      self.assert_equal(
+        a.checks,
+        [[
+          :foo?,
+          [],
+          true
+        ]]
+      )
+    )}
   )}
 )}}.instance)}}.instance