teepee 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 39c6bf274f4c82db707b2ba44ffe90057f87e0b3
-  data.tar.gz: 4a57736a99aee7dd8e119defe2d288bcaa53c18a
+  metadata.gz: 7d3f7f012149fdff0a39dfec0d8a8dd301eec2e0
+  data.tar.gz: 75cc86a2801db966891c6be12570b496c21c5f15
 SHA512:
-  metadata.gz: 6a2155902fecf31514399bcc9bf3c8a44c85f8ed1d139d09e0ef301b4e20a0a575800adb95d9b479a14644610ec20e7f0a881f570c0737b49f2d564f27acd271
-  data.tar.gz: d81d6dfd76f3aef611b214997401705e3def22204c6c064e92244251d8249433325c44bc9ca6ed1be6b63a50cce703c24fbf90e42b8adea7d906d32bd184431d
+  metadata.gz: c30fedd28550b28526f5f0b259c44939fe04b0727f8ce65c403430d98788bd17a345c4c37458db4a2779581cadc7c49b8fd008bf57a0b080a4c1031b8da82de0
+  data.tar.gz: 5634379fef912b567b5e55bbedd3a6d623fe49d4d11968bf85522f7bfb34dcff8b91a59896f1e9912d71cd668baeb0f3ec5f8553dced5e71da420fb1901923b4

data/lib/teepee.rb

@@ -35,536 +35,24 @@
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 
-require 'active_support/all'
-require 'monkey-patch'
-
-include ERB::Util
-
 module Teepee
-  TB_COM = "http://thinkingbicycle.com"
-
-  module MathFunctions
-    class << self
-      def degrees2radians degrees
-        degrees * Math::PI / 180.0
-      end
-
-      def lgamma n
-        Math::lgamma(n).first
-      end
-
-      def radians2degrees radians
-        radians * 180.0 / Math::PI
-      end
-    end
-  end
-
-  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
-    end
-
-    def to_s
-      @text
-    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 [self.new(text[0 ... count]), text[count .. -1]]
-          end
-        else
-          return nil
-        end
-      end
-    end
-  end
-
-  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 to_html
-      html_escape text
-    end
-
-    def word
-      text
-    end
-  end
-
-  class NumberToken < Token
-    attr_reader :number, :text
-
-    def initialize(text)
-      raise ArgumentError if not text.is_a? String
-      @text = text
-    end
-
-    def parse
-    end
-
-    def to_s
-      number.to_s
-    end
-
-    def to_html
-      to_s
-    end
-
-    class << self
-      def matches? text
-      end
-    end
-  end
-
-  class Tokenizer
-    attr_reader :text, :tokens
-    def initialize(text)
-      @text = text
-      tokenize
-    end
-
-    def tokenize
-      @tokens = []
-      rest = text.gsub("\r", "")
-      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 =        NumberToken.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
-
-  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 command_error(message)
-      %{<span style="color: red">[#{message}]</span>}
-    end
-
-    def to_html
-      case command.word
-      when "backslash", "bslash"
-        "\\"
-      when "left-brace", "left_brace", "leftbrace", "lbrace", "opening-brace", "opening_brace",
-           "openingbrace", "obrace"
-        "{"
-      when "right-brace", "right_brace", "rightbrace", "rbrace", "closing-brace", "closing_brace",
-           "closingbrace", "cbrace"
-        "}"
-      when "br", "newline"
-        "\n</br>\n"
-      when "bold", "b", "textbf"
-        html_tag :b
-      when "del", "s", "strike", "strikethrough", "strikeout"
-        html_tag :del
-      when "i"
-        command_error "Complex numbers are not yet supported."
-      when "italic", "textit", "it"
-        html_tag :i
-      when "underline", "u"
-        html_tag :u
-      when "tt", "texttt", "teletype", "typewriter"
-        html_tag :tt
-      when "small"
-        html_tag :small
-      when "big"
-        html_tag :big
-      when "subscript", "sub"
-        html_tag :sub
-      when "superscript", "sup"
-        html_tag :sup
-      when "user", "user-id", "user_id"
-        user_command_handler
-      when "link-id", "link_id"
-        link_id_command_handler
-      when "keyword-id", "keyword_id"
-        keyword_id_command_handler
-      when "tag-id", "tag_id"
-        tag_id_command_handler
-      when "forum-id", "forum_id"
-        forum_id_command_handler
-      when "folder-id", "folder_id"
-        folder_id_command_handler
-      when "bookmarks-folder-id", "bookmarks_folder_id", "bookmarks_folder-id", "bookmarks-folder_id",
-           "bookmark-folder-id",  "bookmark_folder_id",  "bookmark_folder-id",  "bookmark-folder_id"
-        bookmarks_folder_id_command_handler
-      when "pi"
-        "#{Math::PI}"
-      when "e"
-        "#{Math::E}"
-      when "+"
-        injectable_math_function_handler 0, :+
-      when "-"
-        if (numbers = numbers_from_expressions).length == 1
-          injectable_math_function_handler 0, :-
-        else
-          reducable_math_function_handler :-
-        end
-      when "*"
-        injectable_math_function_handler 1, :*
-      when "/"
-        if (numbers = numbers_from_expressions).length == 1
-          1 / numbers.first
-        else
-          reducable_math_function_handler :/
-        end
-      when "%"
-        injectable_math_function_handler numbers_from_expressions.first, :%
-      when "^", "**"
-        number, exponent = numbers_from_expressions
-        number.send :**, exponent
-      when "sin", "cos", "tan",
-        "asin", "acos", "atan",
-        "sinh", "cosh", "tanh",
-        "asinh", "acosh", "atanh",
-        "erf", "erfc",
-        "gamma", "log10", "sqrt"
-        math_function_handler command.word.to_sym
-      when "d2r", "deg->rad", "degrees->radians"
-        MathFunctions::degrees2radians number_from_expression
-      when "r2d", "rad->deg", "radians->degrees"
-        MathFunctions::radians2degrees number_from_expression
-      when "lgamma"
-        MathFunctions::lgamma number_from_expression
-      when "ld", "log2"
-        Math.log2 number_from_expression
-      when "ln"
-        Math.log number_from_expression
-      when "log"
-        base, number = numbers_from_expressions
-        if number.nil?
-          Math.log base
-        else
-          Math.log number, base
-        end
-      when "ldexp"
-        fraction, exponent = numbers_from_expressions
-        Math.ldexp fraction, exponent
-      when "hypot"
-        Math.sqrt numbers_from_expressions.map {|n| n**2}
-      else
-        command_error "unknown command #{command.to_html}"
-      end
-    end
-
-    def html_tag(tag)
-      "<#{tag}>" + expressions.map(&:to_html).join + "</#{tag}>"
-    end
-
-    def tb_href(target, string)
-      %{<a href="#{TB_COM}/#{target}">#{string}</a>}
-    end
-
-    def numbers_from_expressions
-      expressions
-        .map do |number|
-          begin
-            Float(number.to_html)
-          rescue ArgumentError
-            nil
-          end
-        end.reject &:nil?
-    end
-
-    def number_from_expression
-      numbers_from_expressions.first
-    end
-
-    def injectable_math_function_handler(initial, function)
-      numbers_from_expressions.inject initial, function
-    end
-
-    def reducable_math_function_handler(function)
-      numbers_from_expressions.reduce function
-    end
-
-    def math_function_handler(function)
-      Math.send function, numbers_from_expressions.first
-    end
-
-    def user_command_handler
-      user = expressions.select {|expr| expr.is_a? WordToken}.first
-      if not user
-        command_error "user: error: no user specified"
-      else
-        if @@action_view.kind_of? ActionView::Base
-          the_user = User.smart_find user.to_s
-          if the_user
-            @@action_view.render partial: 'users/name_link',
-                                 locals: {the_user: the_user}
-          else
-            command_error "unknown user #{user.to_s}"
-          end
-        else
-          tb_href "users/#{user}", user.to_s
-        end
-      end
-    end
-
-    def id_command_handler(klass,
-                           singular = klass.to_s.camelcase_to_snakecase,
-                           plural = singular.pluralize,
-                           partial = "#{plural}/inline",
-                           view="")
-      id = expressions.select {|expr| expr.is_a? WordToken}.first
-      if not id
-        command_error "#{singular}_id: error: no #{singular} ID specified"
-      elsif not id.to_s =~ /\A[0-9]+\z/
-        command_error "#{singular}_id: error: invalid #{singular} ID specified"
-      else
-        if @@action_view.kind_of? ActionView::Base
-          thing = klass.find Integer(id.to_s)
-          if thing
-            @@action_view.render partial: partial,
-                                 locals: {singular.to_sym => thing}
-          else
-            command_error "unknown #{singular} ID #{id.to_s}"
-          end
-        else
-          tb_href "/#{plural}/#{id.to_s}/#{view}", "#{klass} ##{id.to_s}"
-        end
-      end
-    end
-
-    def link_id_command_handler
-      id_command_handler Link
-    end
-
-    def tag_id_command_handler
-      id_command_handler Tag
-    end
-
-    def folder_id_command_handler
-      id_command_handler Folder
-    end
-
-    def forum_id_command_handler
-      id_command_handler Forum
-    end
-
-    def bookmarks_folder_id_command_handler
-      id_command_handler Folder, "folder", "folders", "folders/bookmarks_inline", "bookmarks"
-    end
-
-    class << self
-      @@action_view = nil
-      @@controller = nil
-
-      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
-
-      def action_view=(new)
-        @@action_view = new
-      end
-
-      def controller=(new)
-        @@controller = new
-      end
-    end
-  end
-
-  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
-      @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
+end
 
-    def initialize(text)
-      @text = text
-      @tokenizer = Tokenizer.new text
-      parse
-    end
+include ERB::Util
 
-    def parse
-      @split_tokens = tokens.split {|token| token.class == EmptyNewlinesToken}
-      @paragraphs = @split_tokens.map {|split_tokens| ParagraphParser.new split_tokens}
-    end
+require 'active_support/all'
+require 'monkey-patch'
 
-    def to_html
-      paragraphs.map(&:to_html).join "\n"
-    end
-  end
-end
+require 'teepee/constants'
+require 'teepee/errors'
+require 'teepee/parser-node'
+require 'teepee/token'
+require 'teepee/commander'
+require 'teepee/actionable-commander'
+require 'teepee/single-character-token'
+require 'teepee/string-token'
+require 'teepee/number-token'
+require 'teepee/tokenizer'
+require 'teepee/command-parser'
+require 'teepee/paragraph-parser'
+require 'teepee/parser'