lib/liquidscript/scanner/liquidscript.rb in liquidscript-0.7.9 vs lib/liquidscript/scanner/liquidscript.rb in liquidscript-0.7.10

@@ -1,5 +1,10 @@
+require "liquidscript/scanner/liquidscript/main"
+require "liquidscript/scanner/liquidscript/regexs"
+require "liquidscript/scanner/liquidscript/heredocs"
+require "liquidscript/scanner/liquidscript/interpolations"
+
 module Liquidscript
   module Scanner
     class Liquidscript < Base
 
       include Base::DSL
@@ -7,188 +12,13 @@
       attr_reader :tokens
 
       define do
         default_context :main
 
-        context :main do
-          set :number, %r{
-            -? ([1-9][0-9]* | 0) # the base of the number
-            (\.[0-9]+)?          # decmial portion, if needed
-            ([eE][+-]?[0-9]+)?   # scientific notation
-          }x
-
-          set :string, %r{
-            '
-            [A-Za-z0-9_$\-\/\.]+
-            '?
-          }x
-
-          set :unops, %w(
-            ++
-            --
-          )
-
-          set :preunops, %w(
-            !
-            ~
-            new
-            return
-            typeof
-            throw
-          )
-
-          set :actions, %w(
-            break
-            continue
-          )
-
-          set :binops, %w(
-            * / ^
-            << >> >>>
-            === ==
-            !== !=
-            >= >
-            <= <
-            && ||
-            & |
-            instanceof
-            or and
-          )
-
-          set :keywords, %w(
-            undefined
-            null
-            true
-            false
-          )
-
-          set :identifier, %r{[A-Za-z_$]([A-Za-z0-9_$-]*[A-Za-z0-9_$])?}
-
-          on("class")     {     emit :class         }
-          on("module")    {     emit :module        }
-          on("if")        {     emit :if            }
-          on("unless")    {     emit :unless        }
-          on("elsif")     {     emit :elsif         }
-          on("else")      {     emit :else          }
-          on("for")       {     emit :for           }
-          on("while")     {     emit :while         }
-          on("try")       {     emit :try           }
-          on("catch")     {     emit :catch         }
-          on("finally")   {     emit :finally       }
-          on(:number)     { |m| emit :number,  m    }
-          on(:string)     { |m| emit :sstring, m    }
-          on(:keywords)   { |m| emit :keyword, m    }
-          on(:actions)    { |m| emit :action,  m    }
-          on("->")        {     emit :arrow         }
-          on("=")         {     emit :equal         }
-          on("{")         {     emit :lbrace        }
-          on("(")         {     emit :lparen        }
-          on("[")         {     emit :lbrack        }
-          on("}")         {     emit :rbrace        }
-          on(")")         {     emit :rparen        }
-          on("]")         {     emit :rbrack        }
-          on(":")         {     emit :colon         }
-          on(".")         {     emit :prop          }
-          on(",")         {     emit :comma         }
-          on("-")         {     emit :minus         }
-          on("+")         {     emit :plus          }
-          on("\n")        {     line!               }
-          on(%r{"} => :istring)
-          on(%r{<<([A-Z]+)}) do |_, s|
-            emit :heredoc_ref, s
-            @lexes << [:heredoc, s]
-          end
-          on(%r{<<-([A-Z]+)}) do |_, s|
-            emit :iheredoc_ref, s
-            @lexes << [:iheredoc, s]
-          end
-          on(%r{/(.*?)/([a-z]*)}) { |_, m, b|
-            emit :regex, [m, b]
-          }
-          on("///" => :block_regex)
-          on(:binops)     { |m| emit :binop,    m   }
-          on(:preunops)   { |m| emit :preunop,  m   }
-          on(:unops)      { |m| emit :unop,     m   }
-
-          on(:identifier) { |m| emit :identifier, m.gsub(/\-[a-z]/) { |p| p[1].upcase } }
-
-          on(%r{#! ([A-Za-z]+) ?(.*?)\n}) do |_, c, a|
-            metadata[:directives] ||= []
-            metadata[:directives].push :command => c,
-                                       :args    => a
-          end
-
-          on(%r{#.*?\n}) { }
-          on(%r{\s})     { }
-          on(:_)         { |m| error }
-        end
-
-        context :istring do
-          init { @buffer = [] }
-
-          on('\\"') { |m| @buffer << m }
-          on('"') do
-            emit :istring, @buffer.join
-            exit
-          end
-
-          on(%r{\#\{(.*?)\}}) do |_, b|
-            emit :istring_begin, @buffer.join
-            lex :main => b
-            @buffer = []
-          end
-
-          on(:_) { |m| @buffer << m }
-        end
-
-        context :heredoc do
-          init { @buffer = [] }
-
-          on(%r{\n\s*([A-Z]+)\s*\n}) do |_, s|
-            if @start == s
-              emit :heredoc, @buffer.join
-              exit
-            else
-              @buffer << _
-            end
-          end
-
-          on(:_) { |m| @buffer << m }
-        end
-
-        context :iheredoc do
-          init { @buffer = [] }
-
-          on(%r{\n\s*([A-Z]+)\s*\n}) do |_, s|
-            if @start == s
-              emit :iheredoc, @buffer.join
-              @start = nil
-              exit
-            else
-              @buffer << _
-            end
-          end
-
-          on(%r{\#\{(.*?)\}}) do |_, b|
-            emit :iheredoc_begin, @buffer.join
-            lex :main => b
-            @buffer = []
-          end
-
-          on(:_) { |m| @buffer << m }
-        end
-
-        context :block_regex do
-          init { @buffer = [] }
-
-          on(%r{///([a-z]*)}) do |_, m|
-            emit :regex, [@buffer.join, m]
-            exit
-          end
-          on(%r{#.*?\n}) { }
-          on("\n")       { }
-          on(:_)         { |m| @buffer << m }
-        end
+        context Main
+        context Regexs
+        context Heredocs
+        context Interpolations
       end
 
       def initialize(*)
         @line = 1
         @cstart = 0