fdlint 0.1.0

data/lib/js/expr/primary.rb

@@ -0,0 +1,166 @@
+module XRay
+  module JS
+    module Expr
+      
+      module Primary
+      
+        R_IDENTIFY = /[a-zA-Z_$][\w$]*/
+
+        RESERVED_WORDS = %w(
+            break case catch continue debugger default delete do else 
+            finally for function if in instanceof new return switch this
+            throw try typeof var void while with
+            class const enum export extends import super
+            implements interface let package private protected public static yield
+            null true false
+        )
+
+        R_THIS_NULL_BOOLEAN = /(?:this|null|true|false)\b/
+        R_HEX = /0[xX]/
+        R_NUMBERIC = /[+-]?(?:\d|(?:[.]\d))/
+        R_STRING = /['"]/
+        R_REGEXP = /\/[^\/]/
+
+        def parse_expr_primary
+          log "parse expr primary"
+          if check /\(/
+            parse_expr_parentheses
+
+          elsif check /\[/
+            parse_expr_array
+
+          elsif check /\{/
+            parse_expr_object
+        
+          # literal 
+          elsif check R_THIS_NULL_BOOLEAN 
+            parse_expr_literal_this_null_boolean
+
+          elsif check R_HEX
+            parse_expr_literal_hex
+
+          elsif check R_NUMBERIC
+            parse_expr_literal_number
+
+          elsif check R_STRING
+            parse_expr_literal_string
+
+          elsif check R_REGEXP
+            parse_expr_literal_regexp
+          #~
+          
+          else
+            parse_expr_identifier
+          end
+        end
+
+        def parse_expr_parentheses
+          log 'parse expr parentheses'
+
+          pos = skip /\(/
+          expr = parse_expression
+          skip /\)/
+          
+          create_expression 'parentheses', expr, pos
+        end
+
+        def parse_expr_array
+          log 'parse expr array'
+
+          pos = skip /\[/
+          elms = batch(:parse_expr_assignment, /\]/, /,/)
+          skip /\]/
+
+          create_expression 'array', Elements.new(elms), pos 
+        end
+
+        def parse_expr_object
+          log 'parse expr object'
+
+          pos = skip /\{/
+          elms = batch(:parse_expr_object_item, /\}/, /,/)
+          skip /\}/
+
+          create_expression 'object', Elements.new(elms), pos
+        end
+
+        def parse_expr_object_item
+          log 'parse expr object item'
+
+          name = if check R_STRING
+            parse_expr_literal_string
+          elsif check R_NUMBERIC
+            parse_expr_literal_number
+          else
+            parse_expr_identifier
+          end
+
+          skip /:/
+          value = parse_expr_assignment
+          
+          Expression.new ':', name, value
+        end
+
+        def parse_expr_identifier
+          log 'parse expr identifier'
+
+          id = scan(R_IDENTIFY)
+          RESERVED_WORDS.include?(id.text) ? 
+              parse_error("identifier can not be reserved word: #{id}") : id
+        
+          create_expression 'id', id
+        end
+
+        def parse_expr_literal_this_null_boolean
+          log 'parse expr literal this null boolean'
+          expr = scan /this|null|true|false/
+          type = expr.text.gsub(/true|false/, 'boolean')
+
+          create_expression type, expr 
+        end
+
+        def parse_expr_literal_string
+          log 'parse expr literal string'
+
+          expr = if check /'/
+            scan /'(?:(?:\\')|(?:\\\n)|[^'\n])*'/
+          elsif check /"/
+            scan /"(?:(?:\\")|(?:\\\n)|[^"\n])*"/
+          else
+            raise 'assert false'
+          end
+
+          create_expression 'string', expr 
+        end
+
+        def parse_expr_literal_hex
+          log 'parse expr literal hex'
+          expr = scan /0[xX][0-9a-fA-F]+/
+          create_expression 'number', expr
+        end
+
+        def parse_expr_literal_number
+          log 'parse expr literal number'
+          expr = scan /[+-]?(?:(?:\d*[.]\d+)|(?:\d+))(?:[eE][+-]?\d+)?/
+          create_expression 'number', expr
+        end
+
+        def parse_expr_literal_regexp
+          log 'parse expr literal regexp'
+          expr = scan %r{/(?:(?:\\.)|(?:\[(?:\\.|[^\[\]])+\])|[^/\\])+/[a-z]*}
+          create_expression 'regexp', expr
+        end
+
+        private
+
+        def create_expression(*args)
+          expr = PrimaryExpression.new *args
+          log "  #{expr}"
+          expr
+        end
+
+      end
+
+    end
+  end 
+end

data/lib/js/parser.rb

@@ -0,0 +1,116 @@
+require_relative '../base_parser'
+require_relative 'struct'
+
+require_relative 'expr/expr'
+require_relative 'stat/stat'
+
+
+module XRay
+  module JS
+    
+    class Parser < XRay::BaseParser
+
+      include Expr::Expr
+      include Stat::Stat
+
+      attr_reader :singleline_comments, :mutiline_comments
+
+      def initialize(js, logger)
+        super js, logger
+        @singleline_comments, @mutiline_comments = [], []
+      end
+
+      def parse_program
+        log 'parse program'
+        parse_comments
+        Program.new parse_source_elements
+      end
+
+      alias_method :parse, :parse_program
+
+      def parse_source_element
+        log 'parse source_element'
+
+        check(/function\b/) ? parse_function_declaration : parse_statement
+      end
+
+      def parse_function_declaration(skip_name = false)
+        log 'parse function declaration'
+
+        pos = skip /function/
+
+        name = (skip_name && check(/\(/)) ? nil : parse_function_name
+        skip /\(/
+        params = parse_function_parameters
+        skip /\)\s*\{/
+        body = parse_source_elements true
+        skip /\}/
+         
+        FunctionDeclaraion.new name, params, body, pos
+      end
+
+      def parse_function_name
+         parse_expr_identifier
+      end
+
+      def parse_function_parameters
+        Elements.new batch(:parse_expr_identifier, /\)/, /,/)
+      end
+
+      def parse_singleline_comment
+        log 'parse singleline comment'
+        comment = raw_scan /\/\/.*/
+        log "  #{comment}"
+        comment
+      end
+
+      def parse_mutiline_comment
+        log 'parse mutiline comment'
+        comment = raw_scan /\/\*[^*]*\*+([^\/*][^*]*\*+)*\//
+        log "  #{comment}"
+        comment
+      end
+
+      protected
+
+      def create_element(klass, *args)
+        elm = klass.new *args
+        log "  #{elm.text} #{elm.position}"
+        elm
+      end
+
+      #override
+      def after_scan(pattern)
+        parse_comments
+      end
+
+      def after_skip(pattern)
+        parse_comments
+      end
+
+      private
+
+      def parse_source_elements(inner = false)
+        elms = batch(:parse_source_element) do
+          skip_empty
+          inner ? !check(/\}/) : !eos? 
+        end
+        Elements.new elms
+      end
+
+      def parse_comments
+        while true
+          if check /\/\//
+            @singleline_comments << parse_singleline_comment
+          elsif check /\/\*/
+            @mutiline_comments << parse_mutiline_comment
+          else
+            break
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/js/rule/all.rb

@@ -0,0 +1,35 @@
+require 'delegate'
+
+module XRay
+  module JS
+    module Rule
+
+      class All < SimpleDelegator
+
+        attr_reader :rules
+
+        def initialize(options = {})
+          @rules = load_sub_rules.collect do |name|
+            klass = Rule.const_get name
+            klass.method(:initialize).arity >= 1 ? klass.new(options) :
+                klass.new
+          end
+
+          super @rules
+        end
+
+        def load_sub_rules
+          Dir.glob File.expand_path( '*.rb', File.dirname(__FILE__) ) do |file|
+            require file
+          end
+          XRay::JS::Rule.constants.select { |c| c.to_s.end_with? 'Rule' }
+        end
+
+
+      end
+
+    end
+  end
+end
+
+

data/lib/js/rule/checklist.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require_relative 'helper'
+require_relative '../../rule'
+
+module XRay
+  module JS
+    module Rule
+     
+      class ChecklistRule
+
+        include XRay::JS::Rule::Helper, XRay::Rule
+        
+        def visit_statement(stat)
+          check_js_statement stat
+        end
+
+        def visit_stat_if(stat)
+          check_js_stat_if stat
+        end
+         
+        def visit_expr_member(expr)
+          check_js_expr_member expr
+        end
+         
+        def visit_expr_new(expr)
+          check_js_expr_new expr
+        end
+         
+        def visit_expr_equal(expr)
+          check_js_expr_equal expr
+        end
+         
+        def visit_stat_try(stat)
+          check_js_stat_try stat
+        end
+
+      end
+    
+    end
+  end
+end

data/lib/js/rule/file_checker.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require_relative '../../helper/file_reader'
+require_relative 'helper'
+require_relative '../../rule'
+
+
+module XRay
+  module JS
+    module Rule
+      
+      class FileChecker
+
+        include Helper, XRay::Rule
+        
+        def check_file(path)
+          src = readfile(path)
+          ret = results_to_logs check_js_file( path, src )
+
+          if merge_file? path
+            pathes = grep_import_js_path( src )
+            ret.concat results_to_logs( check_js_merge_file( path, src, pathes ) )
+            ret.concat results_to_logs( check_merge_imports( pathes, path ) )
+          end
+          ret
+        end
+
+        def check_merge_imports( pathes, path )
+          ret = []
+          pathes.each do |import|
+            r = check_js_merge_importing import, pathes, path
+            ret.concat r
+          end
+          ret
+        end
+        
+        
+      end
+
+    end
+  end
+end

data/lib/js/rule/helper.rb

@@ -0,0 +1,96 @@
+module XRay
+  module JS
+    module Rule
+      
+      module Helper
+        def find_expr_member(expr)
+          while expr.is_a?(Expression) && !yield(expr) 
+            expr = expr.left
+          end
+          expr && expr.is_a?(Expression) && yield(expr) ? expr : nil
+        end
+
+        def has_doc_comment?(body)
+          body =~ /^\s*\/\*\*[^*]*\*+([^\/*][^*]*\*+)*\//
+        end
+
+        def readfile(path)
+          text, encoding = XRay::Helper::FileReader.readfile path
+          text
+        end
+
+        def merge_file?(path)
+          return path =~ /\w+-merge([-_]?\d+)?\.js$/
+        end
+
+        def min_file?(path)
+          return path =~ /\w+-min\.js$/ 
+        end
+
+        def func_file?(path)
+          !merge_file?(path) and !min_file?(path)
+        end
+
+        def grep_import_js_path(body)
+          lines = body.split /\n/
+          pattern = /(ImportJavscript\s*\.\s*url\s*\(\s*['"]?([^'"]+)['"]?\s*\)\s*;?)/
+
+          pathes = []
+          lines.each_with_index do |line, index|
+            line.scan(pattern) do |text, url|
+              pathes << {
+                :text => text,
+                :url => url,
+                :row => index + 1,
+                :col => Regexp.last_match.begin(0) + 1 
+              }
+            end
+          end
+          pathes
+        end
+
+
+        def scope(path)
+          parts = path.split(/\\\//)
+          if parts.include? 'global'
+            :global
+          elsif parts.include? 'page'
+            :page
+          elsif parts.include? 'lib' or parts.include? 'sys'
+            :lib
+          end
+        end
+
+        def global_scope?( path )
+          scope(path) == :global
+        end
+
+        def page_scope?( path )
+          scope(path) == :page
+        end
+
+        def lib_scope?( path )
+          scope(path) == :lib
+        end
+
+        def relative?( path )
+          path !~ %r(^https?://)
+        end
+
+        def app( path )
+          sep = /(?:\\|\/)/
+          path[/#{sep}app#{sep}(.*?)#{sep}(?:.+#{sep})*(global|page|module)(?:\\|\/)/, 1]
+        end
+
+        def results_to_logs( results )
+          results.map do |r|
+            msg, level, row, column = *r
+            LogEntry.new(msg, level, row || 0, column || 0)
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/js/rule/no_global.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+module XRay
+  module JS
+    module Rule
+      
+      class NoGlobalRule
+        
+        def visit_stat_var(stat)
+          unless @scope_index > 0
+            ['不允许使用全局变量', :error] 
+          end
+        end
+
+        def visit_stat_var_declaration(dec)
+          scope = current_scope
+          scope << dec.left.text
+          nil
+        end 
+
+        def visit_function_name(name)
+          current_scope << name.text 
+          ['不允许申明全局函数', :error] if @scope_index == 0
+        end
+
+        def visit_function_parameters(params)
+          @scope_index = (@scope_index || 0) + 1
+          scope = current_scope(true)
+          params.each do |param|
+            scope << param.text
+          end
+          nil
+        end
+
+        def visit_stat_for(stat)
+          first = stat.condition.first
+          nil
+        end
+
+        def visit_function_declaration(fun)
+          @scope_index -= 1
+          nil
+        end
+
+        def visit_expr_assignment(expr)
+          if expr.type == '='
+            id = find_assignment_id(expr.left)
+
+            if id && use_id_global?(id.text)
+              ['禁止使用未定义的变量(或全局变量)', :error] 
+            end
+          end
+        end
+
+        private
+
+        def current_scope(empty = false)
+          @scopes ||= []
+          @scope_index ||= 0
+          @scopes[@scope_index] = [] if empty
+          @scopes[@scope_index] ||= []
+        end
+
+        def find_assignment_id(expr)
+          expr.type == 'id' ? expr :  
+            expr.type == '.' && expr.left.text == 'window' &&
+              expr.right.type == 'id' ? expr.right : nil
+        end
+
+        def use_id_global?(id)
+          white_list = %w(ImportJavscript)
+
+          return false if white_list.include? id
+          return true unless @scopes && @scope_index
+
+          @scope_index.downto(0) do |index|
+            scope = @scopes[index]
+            return false if scope && scope.find { |name| name == id}
+          end 
+          true
+        end
+
+      end
+
+    end 
+  end
+end

data/lib/js/stat/if.rb

@@ -0,0 +1,25 @@
+module XRay
+  module JS
+    module Stat
+
+      module If
+        def parse_stat_if
+          log 'parse stat if'
+
+          pos = skip /if\s*\(/
+          condition = parse_expression
+          skip /\)/
+
+          true_part = parse_statement
+          false_part = if check /else\b/
+            skip /else/
+            parse_statement
+          end
+          
+          create_element IfStatement, condition, true_part, false_part, pos
+        end
+      end
+
+    end
+  end
+end

data/lib/js/stat/iter.rb

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