moron_text 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 144d379141e2a6c2b6f27a3225fcd1a62f7df66f
+  data.tar.gz: df899b273eceefcab7b505dcbb0829055f2d015a
+SHA512:
+  metadata.gz: 274084399d161b9ffb57091f3bbae6c49a0c6f1fad3b2202048736ee92b47c8706723923f508be7fbd7e45c702535742c07b8eb0084be043e5067b52e85d2842
+  data.tar.gz: 2ebae11133e9839546d02de3f6ba76f5e26fe871c2fc739c50605e47c408e3d5118baa404824bfc9d1a4020921d82162584f6a82787dab5b61289ce297986b22

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Future-1.md

@@ -0,0 +1,64 @@
+
+# Syntax: 
+
+    TEXT : InTRO
+
+    In the far east corner of the Galos Building...
+
+    TEXT : OuTRO ----------------
+    We end with a swipe towards the past...
+    !InTRO
+    !POS
+    --------------------------
+
+    ABOUT : first-guess
+    ON : apple
+    |
+    | PUT "100,100" into POS
+    |
+    | BLOCK : MOVE_CARD
+    | | SET the location of card button x to POS
+    | | ADD 15 to item 1 of POS
+    | |---
+    |
+    | REPEAT with x = 1 to the number of card buttons
+    | | MOVE_CARD .
+    | | PLAY_HARD .
+    | | DIE_HARD .
+    | | LIVE_HARD .
+    | |---
+    |
+    | REPEAT with x = 1 to the number of card buttons
+    | | SET the location of card button x to POS
+    | | ADD 15 to item 1 of POS
+    | |---
+    |
+    | ADD 15 to item 1 of POS
+    | ALERT : InTRO
+    | OuTRO .
+    | REPLACE : !POS POS
+    | REPLACE : !InTRO InTRO
+    | ALERT .
+    |---
+
+    ON FIRST TRUE :
+    |
+    | |---
+    | | ARR size  > 2
+    | |---
+    | | DO SOMETHING .
+    | |---
+    |
+    | |---
+    | | ARR size < 5
+    | |---
+    | | DO SOMETHING ELSE.
+    | |---
+    |
+    | |---
+    | | DEFAULT .
+    | |---
+    |
+    |---
+
+

data/Future-2.md

@@ -0,0 +1,56 @@
+
+## Example: Form that saves a record.
+
+    Which is your favorite fruit?
+    ( ) apple
+     | I like apples too!
+    ( ) orange
+     | I hate oranges. Blah!
+    ( ) round
+     | ( ) prune
+     | ( ) raisin
+     | ( ) grapes
+    MERGE : previous answers
+    ( ) Other.
+     |* Other: [___]
+
+    { Send }
+
+    WHEN : Other: [xxx]
+    Cool... I never heard of ^X.
+
+## Example: Arithmetic Calculator
+
+    [|     STACK         |]
+    { 0 ... 9 . }  || { + }
+                   || { - }
+                   || { * }
+                   || { / }
+    =======================
+                      { = }
+
+    ON : CLICK NUMBER
+    VALUE -> [| STACK |] .
+    " " -> [| STACK |] .
+
+    ON : CLICK NON-ALPHA-NUM AND NOT =
+    VALUE -> [| STACK |] .
+    " " -> [| STACK |] .
+
+    ON : CLICK =
+    MATH-EVAL : LAST 3 .
+
+## Example:
+
+    ON : any wrong answer
+    SHOW PICTURE : http://www..../failure.jpg
+
+    ON : final right answer
+
+    You got it! Wait while I show you your secret
+    admirer.
+
+    Please wait a few seconds:
+
+    WAIT AND SHOW CLOCK : 5 secs
+    GO TO : http://www../admirer

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,23 @@
+
+Copyright (c) 2014 da99
+
+MIT License
+
+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/README.md

@@ -0,0 +1,38 @@
+
+# Note:
+
+This is not ready yet.
+
+# Installation
+
+    gem 'moron_text'
+
+# Moron\_Text
+
+## Example: Menu
+
+```ruby
+  moron = Moron_Text.new(<<-EOF)
+    CORRECT /*
+    This is the right answer.
+    WRONG /*
+    This is the 1st wrong answer.
+    WRONG /*
+    This is the 2nd wrong answer.
+    WRONG /*
+    This is the 3rd wrong answer.
+    ON /* CORRECT
+    You chose wisely.
+  EOF
+
+  moron.run do | name, line, text |
+    case name
+    when 'CORRECT'
+    when 'WRONG'
+    when 'ON'
+    else
+      text.next
+    end
+  end
+```
+

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/moron_text.rb

@@ -0,0 +1,382 @@
+
+require "about_pos"
+
+class Moron_Text
+
+  SPACE = ' '.freeze
+  DELIM = "\\s+" + Regexp.escape("/*")
+
+  PATTERNS = {
+    :command__arg         => [
+      %r!\A\s*(.+)#{DELIM}\s+(.+)\Z!,
+      :value, :arg
+    ],
+
+    :command              => [
+      /\A\s*(.+)#{DELIM}\s*\Z/,
+      :value
+    ]
+  }
+
+  NEW_LINE_REG_EXP = /\r?\n/
+  NL               = "\n".freeze
+  TYPO             = Class.new(RuntimeError) do
+
+    attr_reader :moron, :line_number
+
+    def initialize moron, text = "Typo"
+      super text
+      @moron = moron
+      @line_number = @moron.line_number
+    end
+
+    def line
+      moron.lines[line_number-1]
+    end
+
+    def line_context
+      start = line_number - 3 - 1
+      stop  = line_number + 3 - 1
+      start = 0 if start < 0
+      i = start
+      moron.lines.slice(start, stop - start).map { |o|
+        i += 1
+        [i, o]
+      }
+    end
+  end # === Class TYPO
+
+  MISSING_KEY  = lambda { |hash, key|
+    fail RuntimeError, "Missing key: #{key.inspect}"
+  }
+
+  class << self
+
+    def standard_name n
+      n.split.map(&:upcase).join(SPACE)
+    end
+
+    def run *args
+      case
+
+      when block_given?
+        @run_lambda = lambda { |*args| yield(*args) }
+
+      when args.size == 3
+        args.last.next unless @run_lambda
+        @run_lambda.call(*args)
+
+      when args.size == 1 && args.first.is_a?(Proc)
+        @run_lambda = args.first
+
+      else
+        fail "Unknown args: #{args.inspect}"
+
+      end # === case
+    end
+
+  end # === class self ===
+
+  attr_reader :lines, :parsed_lines, :stack, :defs
+
+  def initialize str
+    @str                = str
+    @lines              = nil
+    @parsed_lines       = nil
+    @stack              = nil
+    @has_run            = false
+    @defs               = {}
+    @line_number        = nil
+    @parsed_line_number = nil
+    @next_parse_line    = nil
+    @settings           = {}
+    @settings.default_proc = MISSING_KEY
+  end # === def initialize
+
+  def turn_on sym
+    @settings[sym] = true
+  end
+
+  def turn_off sym
+    @settings[sym] = false
+  end
+
+  def on? sym
+    if !@settings.has_key?(sym)
+      @settings[sym] = false
+    end
+
+    if @settings[sym] != true && @settings[sym] != false
+      fail "Invalid type for: #{sym.inspect}: #{settings[sym].inspect}"
+    end
+
+    @settings[sym]
+  end
+
+  def off? sym
+    if !@settings.has_key?(sym)
+      @settings[sym] = false
+    end
+
+    !on?[sym]
+  end
+
+  def []= k, v
+    @settings[k] = v
+  end
+
+  def [] k
+    @settings[k]
+  end
+
+  def typo!
+    throw :moron_flow, :typo
+  end
+
+  def typo msg
+    TYPO.new(self, msg)
+  end
+
+  def line_number
+    current[:line_number]
+  end
+
+  def current
+    @parsed_lines[@parsed_line_number]
+  end
+
+  def grab_prev_text
+    prev_text
+  end
+
+  def prev_text
+    fail typo("Missing previous text for line.") unless @seq.prev?
+    prev = @seq.prev.value
+    fail typo("Missing previous text for line.") unless prev[:type] == :text
+    prev[:value]
+  end
+
+  def grab_text
+    val = text
+    @seq.grab
+    val
+  end
+
+  def text
+    fail typo("Missing text for line.") unless @seq.next?
+
+    next_ = @seq.next.value
+    fail typo("Missing text for line.")  unless next_[:type] == :text
+
+    next_[:value]
+  end
+
+  def split
+    current[:arg].split
+  end
+
+  def numbers
+    split.map { |u|
+      begin
+        Float(u)
+      rescue ArguementError
+        fail typo("Numerical typo.")
+      end
+    }
+  end
+
+  def fulfills? cond
+    parsed = current
+    About_Pos.Forward(cond).all? { |v,i,m|
+      args = m.grab
+      case v
+      when :on
+        args.any? { |on_name| on?(on_name) }
+      when :value
+        args.any? { |v| parsed[:value] == v }
+      else
+        fail "Typo: #{v.inspect}"
+      end
+    }
+  end
+
+  def next
+    throw :moron_flow, :next
+  end
+
+  def return *args
+    @stack.concat args
+    throw :moron_flow, :ignore
+  end
+
+  def run l = nil
+    return @stack if @has_run
+
+    parse
+    @stack       = []
+    @line_number = 0
+
+    About_Pos.Forward(@parsed_lines) { |line, i, m|
+      @parsed_line_number = i
+      @seq = m
+
+      case line[:type]
+
+      when :text
+        line
+
+      when :command
+        if line.has_key?(:grab_all_text)
+          line[:text] = [
+            (line.has_key?(:text)                    ? line[:text]    : nil),
+            (m.next? && m.next.value[:type] == :text ? m.grab[:value] : nil)
+          ].
+          compact.
+          join(NL)
+        end
+
+        if line.has_key?(:allow)
+          case
+          when line[:allow].all? { |c| c.is_a?(Array) }
+            line[:allow].detect { |cond,i,m| fulfills? cond }
+          else
+            fulfills? line[:allow]
+          end
+        end
+
+        args    = [line[:value], line, self]
+        val     = nil
+        do_next = :next
+
+        if block_given?
+          do_next = catch(:moron_flow) { val = yield(*args) }
+        end
+
+        if do_next == :next && l
+          do_next = catch(:moron_flow) { val = l.call(*args) }
+        end
+
+        if do_next == :next
+          do_next = catch(:moron_flow) { val = self.class.run(*args) }
+        end
+
+        fail(typo "Typo: #{line[:value]}") if do_next == :typo || do_next == :next
+        (@stack << val) unless do_next == :ignore
+
+      else
+        fail "Programmer error: #{line[:type].inspect}"
+
+      end # case line[:type]
+
+    } # === About_Pos
+
+    @has_run = true
+    @stack
+  end
+
+  def meta_line type, val
+    {
+      :type        =>type,
+      :value       =>val,
+      :original    =>@lines[@parse_index-1],
+      :line_number =>@parse_index,
+      :is_closed   =>false,
+      :arg         =>nil
+    }
+  end
+
+  def parse
+    return @parsed_lines if @parsed_lines
+
+    @lines       = @str.split(NEW_LINE_REG_EXP)
+    @parse_index = 0
+
+    @parsed_lines = []
+
+    # === Pass 1: Create an array of commands and text.
+    @lines.each { |line|
+
+      @parse_index += 1
+      parsed = nil
+
+      is_command = PATTERNS.detect { |name, pattern|
+        match = line.match pattern.first
+        next unless match
+        captures = match.captures
+        shift_capture = lambda {
+          fail "Captures already empty: #{name.inspect}" if captures.empty?
+          captures.shift
+        }
+
+        parsed    = meta_line(:command, nil)
+        start     = 0
+        step      = start
+        stop      = pattern.size
+        capture_i = 0
+        while step < (stop-1)
+          grab_next = lambda {
+            step += 1
+            fail("No more items.") if step >= stop
+            pattern[step]
+          }
+
+          val = grab_next.call
+          next if step == start
+
+          case val
+
+          when :value
+            if parsed[:type] == :command
+              parsed[:value] = Moron_Text.standard_name shift_capture.call
+            else
+              parsed[:value] = shift_capture.call
+            end
+
+          when :arg
+            parsed[:arg] = shift_capture.call
+
+          when :is_closed
+            parsed[:is_closed] = true
+
+          when :allow
+            parsed[:allow] = grab_next.call
+
+          when :grab_all_text
+            parsed[:grab_all_text] = true
+            parsed[:text] = captures.compact.join ' '.freeze
+
+          else
+            fail "Typo: unknown pattern command: #{val.inspect}"
+
+          end # case val
+        end # while step < stop
+
+        match
+      } # detect if is command?
+
+      if !is_command
+        parsed = meta_line(:text, line.dup)
+      end
+
+      parsed.default_proc = MISSING_KEY
+      @parsed_lines << parsed
+
+    }
+
+    # === PASS 2: combine text, strip it
+    lines = []
+    About_Pos.Forward(@parsed_lines) { |o, i, m|
+      if o[:type] == :text
+        while m.next? && m.next.value[:type] == :text
+          o[:value] << NL
+          o[:value] << m.grab[:value]
+        end
+        o[:value].strip! 
+      end
+      lines << o
+    }
+
+    @parsed_lines = lines
+  end # === def parse
+
+end # === class Moron_Text ===

data/moron_text.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "moron_text"
+  spec.version       = `cat VERSION`
+  spec.authors       = ["da99"]
+  spec.email         = ["i-hate-spam-1234567@mailinator.com"]
+  spec.summary       = %q{A DSL for WWW mini-apps.}
+  spec.description   = %q{
+    It won't be useful for you. It is meant to be
+    used with the WWW_App gem.
+  }
+  spec.homepage      = "https://github.com/da99/moron_text"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |file|
+    file.index('bin/') == 0 && file != "bin/#{File.basename Dir.pwd}"
+  }
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "about_pos"           , ">= 2.0.0"
+
+  spec.add_development_dependency "pry"           , "~> 0.9"
+  spec.add_development_dependency "bundler"       , "~> 1.5"
+  spec.add_development_dependency "bacon"         , "~> 1.0"
+  spec.add_development_dependency "Bacon_Colored" , "~> 0.1"
+end

data/specs/0000-parse.rb

@@ -0,0 +1,50 @@
+
+describe ":parse" do
+
+  it "returns an array describing the text" do
+    o = Moron_Text.new(<<-EOF)
+      MENU /* My Title
+      This is some text.
+      MENU2 /* arg arg
+      MENU3 /*
+      More text
+      content.
+    EOF
+
+    o.parse.map { |line| 
+      line.values_at(:type, :value, :arg)
+    }.should == [
+      [:command, 'MENU',                      'My Title'],
+      [:text,    "This is some text.",        nil],
+      [:command, 'MENU2',                     'arg arg'],
+      [:command, 'MENU3',                     nil],
+      [:text,    "More text\n      content.", nil]
+    ]
+  end
+
+  it "parses stripped text" do
+    o = Moron_Text.new(trim <<-EOF)
+      CMD /*
+        some text
+    EOF
+
+    o.parse.map { |line|
+      line.values_at(:type, :value)
+    }.should == [
+      [:command, 'CMD'],
+      [:text, 'some text']
+    ]
+  end
+
+  it "parses the following as a command: CMD :" do
+    o = Moron_Text.new(<<-EOF)
+      CMD /*
+        some text
+    EOF
+
+    o.parse.map { |line|
+      line[:type]
+    }.should == [:command, :text]
+  end
+
+end # === describe ":parse"

data/specs/0010-run.rb

@@ -0,0 +1,24 @@
+
+describe :run do
+
+  it "runs the text as code" do
+    o = Moron_Text.new(<<-EOF)
+      ADD /* 1 2 3
+      SUBTRACT /* 100 5 5
+    EOF
+
+    o.run do |name, line, moron|
+      case name
+      when 'ADD'
+        moron.numbers.reduce(:+)
+      when 'SUBTRACT'
+        moron.numbers.reduce(:-)
+      else
+        moron.next
+      end
+    end
+
+    o.stack.should == [6, 90]
+  end
+
+end # === describe ":run"

data/specs/0011-run_Class.rb

@@ -0,0 +1,52 @@
+
+describe ":run Class" do
+
+  it "runs given block on commands" do
+    stack = []
+
+    c = Class.new(Moron_Text)
+    c.run { |name, line, moron|
+      stack << [name, line[:arg]]
+    }
+
+    o = c.new(<<-EOF)
+      BLADE_1 /* 1 2 3
+      BLADE_2 /* 100 5 5
+    EOF
+
+    o.run
+
+    stack.should == [
+      ['BLADE_1', '1 2 3'],
+      ['BLADE_2', '100 5 5'],
+    ]
+  end
+
+  it "runs given block if instance .run block uses .next" do
+    stack = []
+
+    c = Class.new(Moron_Text)
+    c.run { |name, line, moron|
+      stack << [name, line[:arg]]
+    }
+
+    o = c.new(<<-EOF)
+      BLADE_1 /* 1
+      BLADE_2 /* c
+    EOF
+
+    o.run { |name, line, moron|
+      stack << "instance"
+      moron.next
+      fail "Not reachable"
+    }
+
+    stack.should == [
+      "instance",
+      ['BLADE_1', '1'],
+      "instance",
+      ['BLADE_2', 'c'],
+    ]
+  end
+
+end # === describe ":run Class"

data/specs/0012-typo.rb

@@ -0,0 +1,102 @@
+
+describe :typo do
+
+  it "raises a TYPO" do
+    o = Moron_Text.new(<<-EOF)
+      DUCK /* a
+        Quack
+    EOF
+
+    lambda {
+      o.run do |name, line, moron|
+        fail moron.typo('blah') if name == 'DUCK'
+      end
+    }.should.raise(Moron_Text::TYPO).
+    message.should.match /blah/
+  end
+
+  it "returns a TYPO with :line" do
+    o = Moron_Text.new(trim <<-EOF)
+      GOOSE /*
+        Line 2
+        Line 3
+      DUCK /*
+        Line 5
+    EOF
+
+    lambda {
+      o.run do |name, line, moron|
+        case name
+        when 'GOOSE'
+          "done"
+        when 'DUCK'
+          fail moron.typo('blah 1')
+        else
+          moron.typo!
+        end
+      end
+    }.
+      should.raise(Moron_Text::TYPO).
+      line.should == 'DUCK /*'
+  end
+
+  it "returns a TYPO with :line_number" do
+    o = Moron_Text.new(<<-EOF)
+      GOOSE /*
+        Line 2
+        Line 3
+      DUCK /*
+        Line 5
+    EOF
+
+    lambda {
+      o.run do |name, line, moron|
+        case name
+        when 'GOOSE'
+          "done"
+        when 'DUCK'
+          fail moron.typo('blah 2')
+        else
+          moron.typo!
+        end
+      end
+    }.
+      should.raise(Moron_Text::TYPO).
+      line_number.should == 4
+  end # === it returns a TYPO with :line_number
+
+  it 'returns a TYPO with :line_context' do
+    o = Moron_Text.new(<<-EOF)
+      GOOSE /*
+        Line 2
+        Line 3
+      DUCK /*
+        Line 5
+    EOF
+    space = '      '
+
+    lambda {
+      o.run do |name, line, moron|
+        case name
+        when 'GOOSE'
+          "done"
+        when 'DUCK'
+          fail moron.typo('blah 3')
+        else
+          moron.typo!
+        end
+      end
+    }.
+      should.raise(Moron_Text::TYPO).
+      line_context.should == [
+        [1, "#{space}GOOSE /*"],
+        [2, "#{space}  Line 2"],
+        [3, "#{space}  Line 3"],
+        [4, "#{space}DUCK /*"],
+        [5, "#{space}  Line 5"]
+      ]
+  end
+
+end # === describe :typo
+
+

data/specs/0020-grab_text.rb

@@ -0,0 +1,51 @@
+
+describe :grab_text do
+
+  it "pops the following text" do
+    o = Moron_Text.new(<<-EOF)
+      DUCK /*
+        QUACK
+      BIRD /*
+        Whistle
+    EOF
+
+    sounds = []
+    o.run do |name, line, moron|
+      case name
+      when 'DUCK'
+        sounds << moron.grab_text
+      when 'BIRD'
+        sounds << moron.grab_text
+      else
+        moron.typo!
+      end
+    end
+    sounds.should == %w{ QUACK Whistle }
+  end
+
+  it "pops multiple lines of text" do
+    o = Moron_Text.new(<<-EOF)
+      DUCK /*
+
+       This is one line.
+
+       This is another line.
+
+    EOF
+
+    txt = nil
+    o.run { |name, line, moron|
+      if name == 'DUCK'
+        txt = moron.grab_text
+      else
+        moron.typo!
+      end
+    }
+    txt.should == <<-EOF.strip
+       This is one line.
+
+       This is another line.
+    EOF
+  end
+
+end # === describe :text

data/specs/0021-grab_prev_text.rb

@@ -0,0 +1,46 @@
+
+describe :grab_prev_text do
+
+  it "pops the previous text" do
+    o = Moron_Text.new(<<-EOF)
+      This is text.
+      BIRD /*
+        Whistle
+    EOF
+
+    sounds = []
+    o.run { |name, line, moron|
+      if name == 'BIRD'
+        sounds << moron.grab_prev_text
+      else
+        moron.typo!
+      end
+    }
+    sounds.should == ['This is text.']
+  end
+
+  it "pops multiple lines of text" do
+    o = Moron_Text.new(<<-EOF)
+     This is one line.
+
+     This is another line.
+     DUCK /*
+
+    EOF
+
+    txt = nil
+    o.run { |name, line, moron|
+      if name == 'DUCK'
+        txt = moron.grab_prev_text
+      else
+        moron.typo!
+      end
+    }
+    trim(txt).should == trim(<<-EOF)
+       This is one line.
+
+       This is another line.
+    EOF
+  end
+
+end # === describe :text

data/specs/0030-return.rb

@@ -0,0 +1,42 @@
+
+describe :return do
+
+  it "concats arguments to stack" do
+    m = Moron_Text.new(<<-EOF)
+      MENU /* 1
+      MENU /* 2
+      MENU /* 3
+    EOF
+
+    m.run { |name, line, moron| moron.return line[:arg] }
+    m.stack.should == '1 2 3'.split
+  end # === it adds value to stack
+
+  it "prevents the rest of the block or lambda from executing" do
+    m = Moron_Text.new(<<-EOF)
+      MENU /* 4
+      MENU /* 5
+      MENU /* 6
+    EOF
+
+    m.run { |name, line, moron|
+      moron.return line[:arg]
+      fail
+    }
+
+    m.stack.should == '4 5 6'.split
+  end # === it prevents the rest of the block or lambda from executing
+
+  it "does not alter the stack if no arguments are passed to it" do
+    m = Moron_Text.new(<<-EOF)
+      MENU /* 4
+      MENU /* 5
+      MENU /* 6
+    EOF
+
+    m.run { |name, line, moron| moron.return }
+
+    m.stack.should == []
+  end # === it does not alter the stack if no arguments are passed to it
+
+end # === describe :return

data/specs/0031-next.rb

@@ -0,0 +1,57 @@
+
+describe :next do
+
+  it "runs the given lambda if called from the :run block" do
+    m = Moron_Text.new(<<-EOF)
+      COMM 1 /* 1
+      COMM 2 /* 1
+    EOF
+
+    stack = []
+    l = lambda { |name, line, moron| stack << :lambda }
+    m.run(l) { |name, line, moron| stack << :block; moron.next }
+    stack.should == [:block, :lambda, :block, :lambda]
+  end
+
+  it "runs the given Class :run block if called from the instance :run lambda" do
+    stack = []
+    c = Class.new(Moron_Text)
+    c.run { |name, line, moron| stack << :class }
+    o = c.new(<<-EOF)
+      COMM 3 /* 2
+      COMM 4 /* 2
+    EOF
+    l = lambda { |name, line, moron| stack << :lambda; moron.next }
+    o.run(l)
+    stack.should == [:lambda, :class, :lambda, :class]
+  end
+
+  it "runs the given Class :run block if called from: instance :run lambda and block" do
+    stack = []
+    c = Class.new(Moron_Text)
+    c.run { |name, line, moron| stack << :class }
+    o = c.new(<<-EOF)
+      COMM 5 /* 3
+      COMM 6 /* 3
+    EOF
+    l = lambda { |name, line, moron| stack << :lambda; moron.next }
+    o.run(l) { |name, line, moron| stack << :block; moron.next }
+    stack.should == [:block, :lambda, :class, :block, :lambda, :class]
+  end
+
+  it "fails w/ Typo if :next is called in Class :run" do
+    stack = []
+    c = Class.new(Moron_Text)
+    c.run { |name, line, moron| moron.next if name == 'COMM 8' }
+    o = c.new(<<-EOF)
+      COMM 7 /* 4
+      COMM 8 /* 4
+      COMM 9 /* 4
+    EOF
+    lambda {
+      o.run { |name, line, moron| stack << :block; moron.next }
+    }.should.raise(Moron_Text::TYPO).
+    message.should =~ /Typo. COMM 8/
+  end
+
+end # === describe :next

data/specs/lib/helpers.rb

@@ -0,0 +1,8 @@
+
+require 'Bacon_Colored'
+require 'moron_text'
+require 'pry'
+
+def trim str
+  str.split("\n").map(&:strip).join("\n")
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: moron_text
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- da99
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: about_pos
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: bacon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: Bacon_Colored
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: "\n    It won't be useful for you. It is meant to be\n    used with the
+  WWW_App gem.\n  "
+email:
+- i-hate-spam-1234567@mailinator.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Future-1.md
+- Future-2.md
+- Gemfile
+- LICENSE
+- README.md
+- VERSION
+- lib/moron_text.rb
+- moron_text.gemspec
+- specs/0000-parse.rb
+- specs/0010-run.rb
+- specs/0011-run_Class.rb
+- specs/0012-typo.rb
+- specs/0020-grab_text.rb
+- specs/0021-grab_prev_text.rb
+- specs/0030-return.rb
+- specs/0031-next.rb
+- specs/lib/helpers.rb
+homepage: https://github.com/da99/moron_text
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A DSL for WWW mini-apps.
+test_files: []