fdlint 0.1.0

data/lib/js/stat/stat.rb

@@ -0,0 +1,117 @@
+require_relative 'var'
+require_relative 'if'
+require_relative 'switch'
+require_relative 'iter'
+require_relative 'try'
+
+module XRay
+  module JS
+    module Stat 
+      
+      module Stat
+
+        include Var, If, Switch, Iter, Try
+
+        def parse_statement
+          # 在1.8下map是无序的,所以这里只能用数组来实现
+          map = [
+            /\{/, 'block',
+            /\;/, 'empty',
+            /var\b/, 'var',
+            /if\b/, 'if',
+            /switch\b/, 'switch',
+            /do\b/, 'dowhile',
+            /while\b/, 'while',
+            /for\b/, 'for',
+            /continue\b/, 'continue',
+            /break\b/, 'break',
+            /return\b/, 'return',
+            /throw\b/, 'throw',
+            /try\b/, 'try',
+            /./, 'expression'
+          ] 
+
+          0.upto(map.size / 2 - 1) do |i|
+            if check(map[i * 2])
+              return self.send('parse_stat_' + map[i * 2 + 1])
+            end
+          end
+        end
+
+        def parse_stat_block
+          log 'parse stat block'
+          
+          pos = skip /\{/
+          stats = batch(:parse_statement, /\}/)
+          skip /\}/ 
+
+          create_element BlockStatement, Elements.new(stats), pos
+        end
+
+        def parse_stat_empty
+          log 'parse stat empty'
+          pos = skip /;/
+          
+          stat = create_element Statement, 'empty'
+          stat.end_with_semicolon = true
+          stat
+        end
+
+        def parse_stat_expression
+          log 'parse stat expression'
+
+          expr = parse_expression
+          stat = create_element ExpressionStatement, expr
+          after_parse_statement stat
+        end
+
+        def parse_stat_continue
+          log 'parse stat continue'
+          parse_stat_simple /continue/, :parse_expr_identifier
+        end
+
+        def parse_stat_break
+          log 'parse stat break'
+          parse_stat_simple /break/, :parse_expr_identifier
+        end
+
+        def parse_stat_return
+          log 'parse stat return'
+          parse_stat_simple /return/, :parse_expression
+        end
+
+        def parse_stat_throw
+          log 'parse stat throw'
+          parse_stat_simple /throw/, :parse_expression
+        end
+
+        def parse_stat_label
+          log 'parse stat label'
+          raise 'not impelments'
+        end
+
+        def after_parse_statement(stat)
+          skip /[ \t]*/, true
+          colon = !!check(/;/, true)
+          stat.end_with_semicolon = colon
+          colon ? skip(/;/, true) :
+              (eos? || check(/\}/)) ? nil : skip(/\n/, true)
+          stat
+        end
+
+        private
+
+        def parse_stat_simple(pattern, action)
+          type = scan pattern
+          skip /[ \t]*/, true
+          left = (eos? || check(/[;\n}]/, true)) ? nil : self.send(action)
+          
+          stat = create_element Statement, type.text, left, nil, type.position
+          after_parse_statement stat
+        end
+
+      end
+       
+    end
+  end
+end

data/lib/js/stat/switch.rb

@@ -0,0 +1,65 @@
+module XRay
+  module JS
+    module Stat
+      
+      module Switch
+        def parse_stat_switch
+          log 'parse stat switch'
+
+          pos = skip /switch\s*\(/
+          expression = parse_expression
+          skip /\)/
+          block = parse_stat_caseblock
+          
+          create_element SwitchStatement, expression, block, pos
+        end
+
+        def parse_stat_caseblock
+          log 'parse stat caseblock'
+
+          pos = skip /\{/
+          case_clauses = check(/case\b/) ? parse_stat_caseclauses : nil
+          default_clause = check(/default\b/) ? parse_stat_defaultclause : nil
+          bottom_case_clauses = check(/case\b/) ? parse_stat_caseclauses : nil
+          skip /\}/
+
+          create_element CaseBlockStatement, case_clauses, default_clause, 
+              bottom_case_clauses, pos
+        end
+
+        def parse_stat_caseclauses
+          log 'parse stat caseclauses'
+          stats = batch(:parse_stat_caseclause, /default\b|\}/)
+          create_element Elements, stats 
+        end
+
+        def parse_stat_caseclause
+          log 'parse stat caseclause'
+
+          pos = skip /case/
+          expr = parse_expression
+          skip /:/
+          stats = parse_statement_list
+          create_element Statement, 'caseclause', expr, stats, pos
+        end
+
+        def parse_stat_defaultclause
+          log 'parse stat defaultclause'
+
+          pos = skip /default\s*:/
+          stats = parse_statement_list 
+          create_element Statement, 'defaultclause', stats, nil, pos
+        end
+
+        private
+
+        def parse_statement_list
+          elms = batch(:parse_statement, /case\b|default\b|\}/)
+          Elements.new elms
+        end
+
+      end
+
+    end
+  end
+end

data/lib/js/stat/try.rb

@@ -0,0 +1,28 @@
+module XRay
+  module JS
+    module Stat
+      
+      module Try
+        def parse_stat_try
+          pos = skip /try/
+          try_part = parse_stat_block
+
+          catch_part = if check /catch\b/
+            catch_pos = skip /catch\s*\(/
+            id = parse_expr_identifier
+            skip /\)/
+            create_element Statement, 'catch', id, parse_stat_block, catch_pos
+          end
+          
+          finally_part = if check /finally\b/
+            skip /finally/
+            parse_stat_block
+          end
+
+          create_element TryStatement, try_part, catch_part, finally_part, pos
+        end
+      end
+
+    end
+  end
+end

data/lib/js/stat/var.rb

@@ -0,0 +1,40 @@
+module XRay
+  module JS
+    module Stat
+      
+      module Var
+        def parse_stat_var
+          log 'parse stat var'
+
+          pos = skip /var/
+
+          decs = parse_stat_var_declarationlist
+          stat = create_element VarStatement, decs, pos
+          after_parse_statement stat
+        end
+
+        def parse_stat_var_declarationlist
+          log 'parse stat var declarationlist'
+          decs = []
+          decs << parse_stat_var_declaration 
+          while check /,/
+            skip /,/
+            decs << parse_stat_var_declaration
+          end
+          create_element Elements, decs
+        end
+
+        def parse_stat_var_declaration 
+          log 'parse stat var declaration'
+          name = parse_expr_identifier
+          expr = if check(/\=/)
+            skip /\=/
+            parse_expr_assignment
+          end
+          create_element Statement, 'var=', name, expr
+        end
+      end
+
+    end
+  end
+end

data/lib/js/struct.rb

@@ -0,0 +1,248 @@
+require_relative '../node'
+
+module XRay
+  module JS
+    Node = XRay::Node
+
+    class Element < Node
+      attr_reader :type, :left, :right
+
+      def initialize(type, left = nil, right = nil, position = nil)
+        @type, @left, @right, @position = type, left, right, position
+      end
+
+      def text
+        "(#{type},#{left},#{right})"
+      end
+
+      def position
+        @position ? @position : 
+            left ? left.position : 
+            right ? right.position : nil
+      end
+
+      def contains?(target)
+        return true if target == @type
+        left && left.respond_to?(:contains?) && left.contains?(target) or 
+          right && right.respond_to?(:contains?) && right.contains?(target)
+      end
+
+    end
+
+    class Elements < Node
+      attr_reader :elements, :type
+
+      def initialize(elements, position = nil)
+        @elements, @position = elements, position
+        @type = 'elements'
+      end
+
+      def text
+        "[#{elements.collect(&:text).join(',')}]"
+      end
+
+      def position
+        @position ? @position : 
+           elements.empty? ? nil : elements[0].position
+      end
+
+      def method_missing(m, *args, &block)
+        @elements.send m, *args, &block
+      end
+
+      def contains?( target )
+        @elements.any? {|elm| elm.contains? target }
+      end
+
+      alias :contain? :contains?
+    end
+
+    class Program < Element
+      alias :elements :left
+
+      def initialize(elements)
+        super 'program', elements
+      end
+
+    end
+
+    class FunctionDeclaraion < Element
+      attr_reader :body
+      alias :name :left
+      alias :parameters :right
+       
+      def initialize(name, parameters, body, pos)
+        super 'function', name, parameters, pos
+        @body = body
+      end
+    end
+
+    class Statement < Element
+
+      def end_with_semicolon=(end_with_semicolon)
+        @end_with_semicolon = !!end_with_semicolon
+      end
+
+      def end_with_semicolon?
+        @end_with_semicolon || false
+      end
+
+    end
+
+    class VarStatement < Statement
+      alias :declarations :left
+
+      def initialize(declarations, position)
+        super 'var', declarations, nil, position
+      end
+    end
+
+    class BlockStatement < Statement
+      alias :elements :left
+
+      def initialize(elements, pos)
+        super 'block', elements, nil, pos
+      end
+    end
+
+    class IfStatement < Statement
+      attr_reader :false_part
+      alias :condition :left
+      alias :true_part :right
+       
+      def initialize(condition, true_part, false_part, position)
+        super 'if', condition, true_part, position
+        @false_part = false_part
+      end
+    end
+
+    class SwitchStatement < Statement
+      alias :expression :left
+      alias :case_block :right
+       
+      def initialize(expression, case_block, position)
+        super 'switch', expression, case_block, position
+      end
+    end
+
+    class CaseBlockStatement < Statement
+      attr_reader :bottom_case_clauses
+      alias :case_clauses :left
+      alias :default_clause :right
+
+      def initialize(case_clauses, default_clause, bottom_case_clauses, position)
+        super 'caseblock', case_clauses, default_clause, position
+        @bottom_case_clauses = bottom_case_clauses
+      end
+    end
+
+    class DowhileStatement < Statement
+      alias :body :left
+      alias :condition :right
+
+      def initialize(body, condition, pos)
+        super 'dowhile', body, condition, pos
+      end
+    end
+
+    class WhileStatement < Statement
+      alias :condition :left
+      alias :body :right
+
+      def initialize(condition, body, pos)
+        super 'while', condition, body, pos
+      end
+    end
+
+    class ForStatement < Statement
+      alias :condition :left
+      alias :body :right
+
+      def initialize(condition, body, pos)
+        super 'for', condition, body, pos
+      end
+    end
+
+    class ForConditionElement < Element
+      attr_reader :third
+      alias :first :left
+      alias :second :right
+
+      def initialize(type, first, second, third, pos)
+        super type, first, second
+        @third = third
+      end
+
+    end
+
+    class TryStatement < Statement
+      attr_reader :finally_part
+      alias :try_part :left
+      alias :catch_part :right
+
+      def initialize(try_part, catch_part, finally_part, pos)
+        super 'try', try_part, catch_part, pos
+        @finally_part = finally_part
+      end
+    end
+
+    class ExpressionStatement < Statement
+      alias :expression :left
+
+      def initialize(expression)
+        super 'expression', expression
+      end 
+    end
+
+    class Expression < Element
+      def left_hand?
+        @left_hand || false
+      end
+
+      def left_hand=(left_hand)
+        @left_hand = left_hand
+      end
+    end
+
+    class PrimaryExpression < Expression
+
+      def initialize(type, expr, position = nil)
+        super type, expr, nil, position
+      end
+
+      def text
+        node.text
+      end
+
+      def node
+        left
+      end
+    end
+
+    class ConditionExpression < Expression
+      attr_reader :condition
+      
+      def initialize(condition, left, right)
+        super '?:', left, right, condition.position
+        @condition = condition
+      end
+
+      def text
+        "(#{type},#{condition},#{left},#{right})"
+      end
+
+    end
+
+    class FunctionExpression < Expression
+      attr_reader :body
+      alias :name :left
+      alias :parameters :right
+       
+      def initialize(func)
+        super 'function', func.name, func.parameters, func.position
+        @body = func.body
+      end
+    end
+
+  end
+end

data/lib/log_entry.rb

@@ -0,0 +1,49 @@
+require_relative 'helper/color_string'
+
+module XRay
+
+  LogEntry = Struct.new(:message, :level, :row, :column)
+  
+  class LogEntry
+
+    def initialize(message, level, row = 0, colmn = 0)
+      super
+    end
+
+    def to_s
+      pos = row.nil? ? "" : "[#{row},#{column}]"
+      "[#{level.to_s.upcase}] #{pos} #{message}"
+    end
+
+    def to_color_s
+      t = self.to_s
+      if warn?
+        t.yellow
+      elsif fatal?
+        t.white.red_bg
+      elsif error?
+        t.red
+      else
+        t
+      end
+    end
+
+    def error?
+      level == :error
+    end
+
+    def warn?
+      level == :warn
+    end
+
+    def fatal?
+      level == :fatal
+    end
+
+    def info?
+      level == :info
+    end
+
+  end
+
+end

data/lib/node.rb

@@ -0,0 +1,28 @@
+require_relative 'context'
+
+module XRay
+
+  class Node
+
+    attr_accessor :text, :position
+
+    def initialize(text = '', position = nil)
+
+      if text.is_a? Node
+        @text, @position = text.text, text.position
+      else
+        @text, @position = (text || '').strip, position
+      end
+    end
+
+    def =~(other)
+      text =~ other
+    end
+
+    def to_s
+      text
+    end
+
+  end
+
+end

data/lib/parse_error.rb

@@ -0,0 +1,13 @@
+module XRay
+  
+  class ParseError < RuntimeError
+    attr_reader :position
+
+    def initialize(msg = nil, position = nil)
+      super msg
+      @position = position
+    end
+
+  end
+  
+end