tbmx 0.1.0 → 0.2.0

data/lib/tbmx.rb

@@ -36,111 +36,287 @@
 # POSSIBILITY OF SUCH DAMAGE.
 
 require 'active_support/all'
+require 'monkey-patch'
 
 include ERB::Util
 
 module TBMX
-  class HTML
-    attr_reader :text, :lines, :paragraphs
+  class ParseError < RuntimeError
+  end
+
+  class ParserNode
+  end
+
+  class Token < ParserNode
+    class << self
+      # The child classes should implement this method.  If there is an
+      # immediate match, they should return a newly-created instance of
+      # themselves and the rest of the input as a string.  If there is no match,
+      # they should return nil.
+      def matches? text
+        raise NotImplementedError,
+              "Child class #{self.class} should implement this."
+      end
+    end
+  end
+
+  class SingleCharacterToken < Token
+    def text
+      self.class.character_matched
+    end
+
+    class << self
+      def character_matched
+        self::CHARACTER_MATCHED
+      end
 
+      def matches? text
+        if text.first == character_matched
+          return [self.new, text.rest]
+        else
+          return nil
+        end
+      end
+    end
+  end
+
+  class StringToken < Token
+    attr_reader :text
     def initialize(text)
       raise ArgumentError if not text.is_a? String
+      raise ArgumentError if not text =~ self.class.full_match_regex
       @text = text
-      @lines = text.split("\n").map &:strip
-      @paragraphs = @lines.split ""
-    end
-
-    def evaluate_command(command, input)
-      case command
-      when "\\"
-        "\\ #{input}"
-      when "b"
-        "<b>#{input}</b>"
-      when "i"
-        "<i>#{input}</i>"
-      when "sub"
-        "<sub>#{input}</sub>"
-      when "sup"
-        "<sup>#{input}</sup>"
-      else
-        "<b>[UNKNOWN COMMAND #{command}]</b>"
-      end
     end
 
-    def parse_command(command, rest)
-      if rest == nil or rest == ""
-        return [evaluate_command(command, rest),
-                ""]
-      elsif rest[0] =~ /\s/
-        return [evaluate_command(command, ""),
-                rest[1 .. -1]]
-      elsif rest[0] == "{"
-        if backslash = rest.index("\\")
-          if (closing_brace = rest.index("}")) < backslash
-            return [evaluate_command(command, rest[1 ... closing_brace]),
-                                              rest[      closing_brace+1 .. -1]]
-          elsif closing_brace
-            interior = parse_command_body(backslash, rest)
-            if new_closing_brace = interior.index("}")
-              return [evaluate_command(command,
-                                       interior[1 ... new_closing_brace]),
-                                       interior[      new_closing_brace+1 .. -1]]
-            else # Assume an implied closing brace.
-              return [evaluate_command(command, interior[1 .. -1]),
-                      ""]
-            end
+    def to_html
+      @text
+    end
+
+    class << self
+      def full_match_regex
+        self::FULL_MATCH_REGEX # Define this in a child class.
+      end
+
+      def front_match_regex
+        self::FRONT_MATCH_REGEX # Define this in a child class.
+      end
+
+      def count_regex
+        self::COUNT_REGEX # Define this in a child class.
+      end
+
+      def matches? text
+        if text =~ front_match_regex
+          count = text.index count_regex
+          if count.nil?
+            return [self.new(text), ""]
           else
-            return evaluate_command(command, parse_command_body(backslash, rest))
+            return [self.new(text[0 ... count]), text[count .. -1]]
           end
-        elsif closing_brace = rest.index("}")
-          return [evaluate_command(command, rest[1 ... closing_brace]),
-                                            rest[      closing_brace+1 .. -1]]
-        else # Assume an implied closing brace.
-          return [evaluate_command(command, rest[1 .. -1]),
-                  ""]
+        else
+          return nil
         end
-      else
-        raise RuntimeError, "Unreachable: probably a bug in parse_command_name."
       end
     end
+  end
 
-    def parse_command_name(input)
-      if end_command = input.index(/[\{\s]/)
-        return [input[0 ... end_command],
-                input[      end_command .. -1]]
-      else
-        return [input, ""]
+  class BackslashToken < SingleCharacterToken
+    CHARACTER_MATCHED = "\\"
+  end
+
+  class LeftBraceToken < SingleCharacterToken
+    CHARACTER_MATCHED = "{"
+  end
+
+  class RightBraceToken < SingleCharacterToken
+    CHARACTER_MATCHED = "}"
+  end
+
+
+  class EmptyNewlinesToken < StringToken
+    FULL_MATCH_REGEX = /\A\n\n+\z/
+    FRONT_MATCH_REGEX = /\A\n\n+/
+    COUNT_REGEX = /[^\n]/
+
+    def newlines
+      text
+    end
+  end
+
+  class WhitespaceToken < StringToken
+    FULL_MATCH_REGEX = /\A\s+\z/
+    FRONT_MATCH_REGEX = /\A\s+/
+    COUNT_REGEX = /\S/
+
+    def whitespace
+      text
+    end
+
+    def to_html
+      " " # Replace all whitespace tokens with a single space.
+    end
+  end
+
+  class WordToken < StringToken
+    FULL_MATCH_REGEX = /\A[^\s{}\\]+\z/
+    FRONT_MATCH_REGEX = /[^\s{}\\]+/
+    COUNT_REGEX = /[\s{}\\]/
+
+    def word
+      text
+    end
+  end
+
+  class Tokenizer
+    attr_reader :text, :tokens
+    def initialize(text)
+      @text = text
+      tokenize
+    end
+
+    def tokenize
+      @tokens = []
+      rest = text
+      while rest.length > 0
+        if result =     BackslashToken.matches?(rest) or # Single Character Tokens
+           result =     LeftBraceToken.matches?(rest) or
+           result =    RightBraceToken.matches?(rest) or
+           result = EmptyNewlinesToken.matches?(rest) or # String Tokens
+           result =    WhitespaceToken.matches?(rest) or
+           result =          WordToken.matches?(rest)
+        then
+          @tokens << result[0]
+          rest = result[1]
+        else
+          raise RuntimeError, "Couldn't tokenize the remaining text."
+        end
       end
+      return @tokens
     end
+  end
 
-    def parse_command_body(backslash, input)
-      before = input[0 ... backslash]
-      command, rest = parse_command_name input[backslash+1 .. -1]
-      middle, back = parse_command(command, rest)
-      return before + middle + parse_paragraph_body(back)
+  class CommandParser < ParserNode
+    attr_reader :command, :expressions
+
+    def initialize(command, expressions)
+      raise ArgumentError if not command.is_a? WordToken
+      @command = command
+      raise ArgumentError if not expressions.is_a? Array
+      expressions.each {|expression| raise ArgumentError if not expression.kind_of? ParserNode}
+      @expressions = expressions
     end
 
-    def parse_paragraph_body(body)
-      return "" if body.nil? or body == ""
-      raise ArgumentError, "Body is #{body.class}" if not body.is_a? String
-      if backslash = body.index("\\")
-        return parse_command_body backslash, body
+    def to_html
+      case command.word
+      when "backslash", "bslash"
+        "\\"
+      when "left-brace", "left_brace", "leftbrace", "lbrace"
+        "{"
+      when "right-brace", "right_brace", "rightbrace", "rbrace"
+        "}"
+      when "br", "newline"
+        "\n</br>\n"
+      when "bold", "b"
+        "<b>" + expressions.map(&:to_html).join + "</b>"
+      when "italic", "i"
+        "<i>" + expressions.map(&:to_html).join + "</i>"
+      when "underline", "u"
+        "<u>" + expressions.map(&:to_html).join + "</u>"
+      when "subscript", "sub"
+        "<sub>" + expressions.map(&:to_html).join + "</sub>"
+      when "superscript", "sup"
+        "<sup>" + expressions.map(&:to_html).join + "</sup>"
       else
-        return body
+        %{<span style="color: red">[UNKNOWN COMMAND #{command.to_html}]}
+      end
+    end
+
+    class << self
+      def parse(tokens)
+        expressions = []
+        rest = tokens
+        backslash, command, left_brace = rest.shift(3)
+        right_brace = nil
+        raise ParseError if not backslash.is_a? BackslashToken
+        raise ParseError if not command.is_a? WordToken
+        if not left_brace.is_a? LeftBraceToken # A command with no interior.
+          rest.unshift left_brace if not left_brace.is_a? WhitespaceToken
+          return [CommandParser.new(command, []), rest]
+        end
+        while rest.length > 0
+          if rest.first.is_a? WordToken
+            expressions << rest.shift
+          elsif rest.first.is_a? WhitespaceToken
+            expressions << rest.shift
+          elsif rest.first.is_a? BackslashToken
+            result, rest = CommandParser.parse(rest)
+            expressions << result
+          elsif rest.first.is_a? RightBraceToken
+            right_brace = rest.shift
+            return [CommandParser.new(command, expressions), rest]
+          else
+            raise ParseError
+          end
+        end
+        if right_brace.nil? # Allow a forgotten final right brace.
+          return [CommandParser.new(command, expressions), rest]
+        end
       end
     end
+  end
 
-    def parse_paragraph(paragraph)
-      raise ArgumentError if not paragraph.is_a? Array
-      paragraph.each {|line| raise ArgumentError if not line.is_a? String}
-      body = paragraph.map do |line|
-        html_escape line
-      end.join "\n"
-      "<p>#{parse_paragraph_body body}</p>"
+  class ParagraphParser < ParserNode
+    attr_reader :expressions, :tokens
+
+    def initialize(tokens)
+      raise ArgumentError if not tokens.is_a? Array
+      tokens.each {|token| raise ArgumentError if not token.kind_of? ParserNode}
+      @tokens = tokens
+      parse
     end
 
     def parse
-      paragraphs.map {|paragraph| parse_paragraph paragraph}.join "\n\n"
+      @expressions = []
+      rest = tokens
+      while rest.length > 0
+        if rest.first.is_a? WordToken
+          @expressions << rest.shift
+        elsif rest.first.is_a? WhitespaceToken
+          @expressions << rest.shift
+        elsif rest.first.is_a? BackslashToken
+          command, rest = CommandParser.parse(rest)
+          @expressions << command
+        else
+          return self
+        end
+      end
+    end
+
+    def to_html
+      "<p>\n" + expressions.map(&:to_html).join + "\n</p>\n"
+    end
+  end
+
+  class Parser < ParserNode
+    attr_reader :paragraphs, :split_tokens, :text, :tokenizer
+
+    def tokens
+      tokenizer.tokens
+    end
+
+    def initialize(text)
+      @text = text
+      @tokenizer = Tokenizer.new text
+      parse
+    end
+
+    def parse
+      @split_tokens = tokens.split {|token| token.class == EmptyNewlinesToken}
+      @paragraphs = @split_tokens.map {|split_tokens| ParagraphParser.new split_tokens}
+    end
+
+    def to_html
+      paragraphs.map(&:to_html).join "\n"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tbmx
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-04 00:00:00.000000000 Z
+date: 2013-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport