fdlint 0.1.3 → 0.2.0.pre

data/lib/js/stat/iter.rb

@@ -1,85 +0,0 @@
-module XRay
-  module JS
-    module Stat
-      
-      module Iter
-
-        def parse_stat_dowhile
-          log 'parse stat dowhile'
-
-          pos = skip /do/
-          body = parse_statement
-
-          skip /while\s*\(/
-          condition = parse_expression
-          skip /\)/ 
-          
-          create_element DowhileStatement, body, condition, pos
-        end 
-
-        def parse_stat_while
-          log 'parse stat while'
-
-          pos = skip /while\s*\(/
-          condition = parse_expression
-          skip /\)/
-          body = parse_statement
-
-          create_element WhileStatement, condition, body, pos
-        end
-
-        def parse_stat_for
-          log 'parse stat for'
-
-          pos = skip /for/
-          
-          con_pos = skip /\(/
-          first, is_var = parse_stat_for_con_first
-          type, second, third = parse_stat_for_con_other(first, is_var)
-          skip /\)/
-
-          condition = create_element ForConditionElement, type, first, second, third, con_pos
-          body = parse_statement
-          create_element ForStatement, condition, body, pos
-        end
-
-        private
-
-        def parse_stat_for_con_first
-          self.expr_operate_not_in = true
-          first = if check /var\b/
-            skip /var/
-            is_var = true 
-            parse_stat_var_declarationlist
-          elsif !check(/;/)
-            parse_expression 
-          end
-          self.expr_operate_not_in = false
-          [first, is_var]
-        end
-
-        def parse_stat_for_con_other(first, is_var)
-          if check /in\b/
-            if is_var && first.length != 1 || !is_var && !first.left_hand?
-              parse_error('first expression of for-condtion error')
-            end
-
-            skip /in/
-            type = is_var ? 'forvarin' : 'forin'
-            second = parse_expression
-          else
-            skip /;/
-            type = is_var ? 'forvar' : 'fordefault'
-            second = check(/;/) ? nil : parse_expression
-            skip /;/
-
-            third = check(/\)/) ? nil : parse_expression
-          end
-          [type, second, third]
-        end
-
-      end
-
-    end
-  end
-end

data/lib/js/stat/stat.rb

@@ -1,117 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,248 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

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