fdlint 0.1.3 → 0.2.0.pre

data/lib/fdlint/parser/js/struct.rb

@@ -0,0 +1,257 @@
+require_relative '../node'
+
+module Fdlint
+
+  module Parser
+
+    module JS
+
+      Node = ::Fdlint::Parser::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
+
+      # The whole program element
+      # Javascript files are first parsed into programs.
+      class Program < Element
+        alias :elements :left
+
+        def initialize(elements)
+          super 'program', elements
+        end
+
+      end
+
+      # Function declaraion
+      # key word 'function' parsed as FunctionDeclaraion
+      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
+        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
+end

data/lib/fdlint/parser/node.rb

@@ -0,0 +1,27 @@
+module Fdlint
+  module Parser
+
+    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
+end

data/lib/fdlint/parser/parse_error.rb

@@ -0,0 +1,10 @@
+class Fdlint::Parser::ParseError < RuntimeError
+
+  attr_reader :position
+
+  def initialize(msg = nil, position = nil)
+    super msg
+    @position = position
+  end
+
+end

data/lib/fdlint/parser/parser_visitable.rb

@@ -0,0 +1,134 @@
+require 'fdlint/log_entry'
+
+module Fdlint
+
+  module Parser
+  
+    class VisitResult < LogEntry
+    
+      attr_reader :node
+
+      def initialize(node, message, level)
+        @node = node
+        pos = node.position || Position.new(0, 0, 0)
+        super message, level, pos.row, pos.column
+      end
+    end
+
+
+    module ParserVisitable
+      
+      def self.included(klass)
+        klass.public_instance_methods(true).grep(/^parse_/) do |method|
+          wrap(klass, method)
+        end
+
+        def klass.method_added(method)
+          unless @flag
+            @flag = true
+            case method.to_s
+            when /^parse_/
+              ParserVisitable.wrap(self, method)
+            end
+            @flag = false
+          end
+        end
+      end
+
+      def self.wrap(klass, method)
+        method = method.to_s
+
+        klass.instance_eval do
+
+          old_method = "#{method}_without_visit"
+          name       = method.sub /^parse_/, ''
+
+          alias_method old_method, method
+
+          define_method(method) do |*args, &block|
+            before name, *args
+            node = self.send(old_method, *args, &block)
+            node && visit(name, node)
+            node
+          end
+        end
+      end
+   
+      def parse_no_throw
+        root = []
+        begin
+          root = self.parse
+        rescue ParseError => e
+          results << LogEntry.new(e.to_s, :fatal, e.position.row, e.position.column)
+        end
+        root
+      end
+
+      # Public: Add visitor hooks
+      #
+      # visitors - The visitors array. The members in the
+      #            Array must be presented in this format:
+      #            `[ scope, proc ]`
+      #            where scope is the name of target node
+      #            scope; proc is the handler.
+      #
+      # Returns Parser's visitors
+      def add_visitors(visitors)
+        visitors.each do |target, visitor|
+          add_visitor target, visitor
+        end
+        self.visitors
+      end
+
+      # Public: Add visitor hook
+      #
+      # target -  The target to watch. For example, when
+      #           target is 'selector', then the visitor
+      #           will be invoked after <code>parse_select
+      #           </code> invoked by parser.
+      # visitor - The handler proc. It will be yielded 
+      #           with these arguments:
+      #           * node:   current node scope, same as
+      #                     `target` here
+      #           * source: the entire file source
+      #
+      # Returns the visitors for the scope
+      def add_visitor(scope, visitor)
+        cache = visitors[scope.to_s] ||= []
+        cache << visitor
+      end
+
+      def visitors
+        @visitors ||= {}
+      end
+
+      def results
+        @results ||= []
+      end
+
+      private 
+
+        def visit(name, node)
+          walk(name, node) do |result|
+            results << result
+          end
+        end
+
+        def before(name)
+          walk 'before_parse_' << name, nil do |result|
+            results << result
+          end
+        end
+
+        def walk(name, node, &block)
+          visitors = self.visitors[name.to_s]
+          visitors && visitors.each do |visitor|
+            result = visitor.call node, source, self
+            yield result if result && block_given?
+          end
+        end
+
+    end
+
+  end
+end

data/lib/{position_info.rb → fdlint/parser/position_info.rb}

@@ -1,10 +1,14 @@
-module XRay
+module Fdlint::Parser
 
   Position = Struct.new(:pos, :row, :column)
   class Position
     def to_s
         "[#{row},#{column}]"
     end
+
+    def inspect
+      "[#{pos}, #{row}:#{column}]"
+    end
   end
 
   class PositionInfo
@@ -22,6 +26,13 @@ module XRay
       @len = lines.length
     end
 
+    # Public: Turn given number position index into a
+    #         position object which contains the 
+    #         column and row index info
+    #
+    # pos - position index of the source string
+    #
+    # Returns the position object
     def locate(pos)
       if @row && pos >= @lines[@row -1] && pos < @lines[@row]
         row = @row

data/lib/fdlint/parser.rb

@@ -0,0 +1,3 @@
+require 'fdlint/parser/base_parser'
+require 'fdlint/parser/parser_visitable'
+require 'fdlint/parser/encoding_error'

data/lib/fdlint/printer/base_printer.rb

@@ -0,0 +1,20 @@
+module Fdlint
+
+  module Printer
+
+    class BasePrinter
+
+      def initialize( opt={} )
+        @opt= opt
+      end
+
+      attr_accessor :file, :source, :results
+
+      def print( file, source, results )
+        @file, @source, @results = file, source, results || []
+      end
+    end
+
+  end
+
+end

data/lib/fdlint/printer/console_printer.rb

@@ -0,0 +1,80 @@
+require 'colored'
+
+module Fdlint 
+
+  module Printer
+
+    class ConsolePrinter < BasePrinter
+
+      def print( file, source, results )
+
+        super
+
+        if source
+          print_with_source
+        else
+          if @results && @results.empty?
+            puts "[OK] ".green << file.to_s
+          else
+            puts "[EE] ".red << file.to_s
+
+            @results.each do |r|
+              print_log_entry r
+            end
+          end
+        end
+      end
+
+      def print_with_source
+        if @results.empty?
+          puts "[OK] ".green << file.to_s
+        else
+          puts "[EE] ".red << file.to_s
+
+          @results.each do |r|
+            print_log_entry r
+          end
+        end
+        
+
+      end
+
+      def print_log_entry( entry )
+        if entry.row && entry.row > 0
+          col    = entry.column - 1
+          row    = entry.row - 1
+          left   = col - 50
+          right  = col + 50
+          left   = 0 if left < 0
+          indent = ' ' * ( col - left )
+
+          puts "     #{log_text entry}\n"
+          puts "       #{source.lines[row][left..right].gsub(/\t/, ' ')}"
+          puts "       #{indent}^"
+        else
+          puts "     #{log_text entry}\n"
+        end
+      end
+
+
+      def log_text( entry )
+        level = entry.level.to_s.upcase.ljust(5)
+        t = if entry.warn?
+              level.yellow
+            elsif entry.fatal?
+              level.white_on_red
+            elsif entry.error?
+              level.red
+            else
+              level
+            end
+        if entry.row
+          "[%s] %s %s" % [t, entry.pos, entry.message]
+        else
+          "[%s] %s" % [t, entry.message]
+        end
+      end
+    end
+
+  end
+end

data/lib/fdlint/printer/nocolor_printer.rb

@@ -0,0 +1,29 @@
+module Fdlint
+
+  module Printer
+
+    class NoColorPrinter < BasePrinter
+
+      def print( file, source, results )
+
+        super
+
+        if results.empty?
+          puts "[OK] #{file}"
+        else
+          prf = @opt[:prefix]
+          suf = @opt[:suffix]
+          out = @opt[:out]
+
+          puts "[EE] #{file}"
+
+          results.each do |r|
+            puts "#{prf}#{r}#{suf}"
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/fdlint/printer/vim_printer.rb

@@ -0,0 +1,21 @@
+module Fdlint
+
+  module Printer
+
+    class VimPrinter < BasePrinter
+
+      def print( file, source, results )
+        prf = ( file || '-' ).dup.utf8!
+        results.each do |r|
+          if r.row
+            puts "%s:[%s]:%d:%d:%s" % [prf, r.level, r.row, r.column, r.message]
+          else
+            puts "%s:[%s]:%d:%d:%s" % [prf, r.level, 0, 0, r.message]
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/fdlint/printer.rb

@@ -0,0 +1 @@
+require 'fdlint/printer/base_printer'

data/lib/fdlint/rule/dsl.rb

@@ -0,0 +1,83 @@
+module Fdlint; module Rule
+
+  module DSL 
+
+    extend self
+
+    # Public: Extend target class
+    #
+    # target - An String or Class object
+    def helpers( target, &block )
+      if target.is_a? String
+        target = Object.const_get target.capitalize
+      end
+      target.class_eval &block
+    end
+
+    def rules_for( *syntaxes, &block )
+      @syntaxes = syntaxes.map(&:intern)
+      yield if block_given?
+    end
+
+    def css_rules( &block )
+      rules_for( :css, &block )
+    end
+
+    def html_rules( &block )
+      rules_for( :html, &block )
+    end
+
+    def js_rules( &block )
+      rules_for( :js, &block )
+    end
+
+    def group( grp, &block )
+      @group = grp
+      yield if block_given?
+    end
+
+    def desc( description=nil )
+      @desc = description
+    end
+
+    def uri( u )
+      @uri = u
+    end
+
+    def check( node, &block )
+      @scope = node.intern
+      if block && block.arity > 0
+        rule &block
+      else
+        yield if block_given?
+      end
+    end
+
+    alias_method :review, :check
+
+    def rule( &block )
+      @syntaxes.each do |syntax|
+        ::Fdlint::Rule.add syntax, @scope, {
+          :block => block,
+          :desc  => @desc,
+          :uri   => @uri
+        }
+      end
+
+      @desc = nil
+      @uri  = nil
+    end
+
+    def before( element, &block )
+      @scope = :"before_parse_#{element}"
+      rule &block
+    end
+
+    def after( element, &block )
+      @scope = element.intern
+      rule &block
+    end
+
+  end
+
+end; end;