fdlint 0.1.0

data/lib/parser_visitable.rb

@@ -0,0 +1,138 @@
+require 'observer'
+
+require_relative 'log_entry'
+
+module XRay
+  
+  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
+    
+    include Observable
+
+    def self.included(klass)
+      klass.public_instance_methods(true).each do |method|
+        wrap(klass, method)
+      end
+
+      def klass.method_added(method)
+        unless @flag
+          @flag = true
+          ParserVisitable.wrap(self, method)
+          @flag = false
+        end
+      end
+    end
+
+    def self.wrap(klass, method)
+      method = method.to_s
+      unless method.index 'parse_'
+        return
+      end
+
+      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 ||= []
+        @results << LogEntry.new(e.to_s, :fatal, e.position.row, e.position.column)
+      end
+      root
+    end
+
+    def add_visitor(visitor)
+      @visitors ||= {}
+      
+      visitor.class.public_instance_methods(true).each do |method|
+        method = method.to_s
+        if method.index('visit_') == 0 || 
+            method.index('before_parse_') == 0
+          cache = @visitors[method] ||= []
+          cache << visitor
+        end 
+      end
+    end
+
+    def add_visitors(visitors)
+      visitors.each { |visitor| add_visitor visitor }
+    end
+
+    def results
+      @results || []
+    end
+
+    private 
+
+    def visit(name, node)
+      walk(name, 'visit_', node) do |result|
+        result && notify(node, result)
+      end
+    end
+
+    def before(name, *args)
+      walk name, 'before_parse_', *args
+    end
+
+    def walk(name, prefix, *args, &block)
+      unless @visitors
+        return
+      end
+
+      method = prefix + name 
+      visitors = @visitors[method]
+      visitors && visitors.each do |visitor|
+        result = visitor.send method, *args
+        block && block.call(result)
+      end
+    end
+
+    def notify(node, results)
+      @results ||= []
+      if results.is_a?(Array) && results.size > 0
+        if results[0].is_a? Array
+          results.each do |ret|
+            do_notify node, ret, ret.is_a?(VisitResult)
+          end
+        else
+          do_notify node, results
+        end
+      elsif results.is_a? VisitResult
+        do_notify node, results, true 
+      end
+    end
+
+    def do_notify(node, ret, flag = false)
+      ret = VisitResult.new(node, ret[0], ret[1]) unless flag
+      @results << ret
+      self.changed
+      notify_observers ret, self
+    end
+
+  end
+
+end

data/lib/position_info.rb

@@ -0,0 +1,46 @@
+module XRay
+
+  Position = Struct.new(:pos, :row, :column)
+  class Position
+    def to_s
+        "[#{row},#{column}]"
+    end
+  end
+
+  class PositionInfo
+  
+    def initialize(text)
+      lines = text.split(/\n/)
+
+      @lines = []
+      num = 0
+      lines.each do |line|
+        num += line.length + 1
+        @lines << num
+      end
+
+      @len = lines.length
+    end
+
+    def locate(pos)
+      if @row && pos >= @lines[@row -1] && pos < @lines[@row]
+        row = @row
+      else
+        row = @row = find(0, @len - 1, pos)
+      end
+      col = row > 0 ? pos - @lines[row - 1] : pos
+      Position.new(pos, row + 1, col + 1)
+    end
+
+    private
+
+    def find(low, high, pos)
+      return low unless low < high
+
+      mid = (low + high) / 2
+      pos < @lines[mid] ? find(low, mid, pos) :
+        find(mid + 1, high, pos)
+    end
+
+  end
+end

data/lib/printer/base_printer.rb

@@ -0,0 +1,24 @@
+module XRay
+
+  def self.printer
+    @@printer
+  end
+
+  def self.register_printer(klass)
+    @@printer = klass
+  end
+
+  class BasePrinter
+  
+    XRay.register_printer self
+
+    def initialize(results, opt)
+      @results, @opt = results, opt
+    end
+
+    def print
+    end
+
+  end
+
+end

data/lib/printer/console_printer.rb

@@ -0,0 +1,66 @@
+require_relative 'base_printer'
+
+if ENV['OS'] =~ /windows/i
+  require 'win32console' 
+end
+
+
+module XRay
+
+  class ConsolePrinter < BasePrinter
+
+    XRay.register_printer self
+
+    def print
+      if @opt[:source]
+        print_with_source
+      else
+        if @results.empty?
+          puts "[OK]".white.green_bg << " #{@opt[:file]}"
+        else
+          prf = @opt[:prefix]
+          suf = @opt[:suffix]
+
+          puts ""
+          puts "[EE] #{@opt[:file]}".white.magenta_bg
+
+          @results.each do |r|
+            puts "#{prf}#{r.to_color_s}#{suf}"
+          end
+        end
+      end
+    end
+
+
+    def print_with_source
+      if @results.empty?
+        puts "[OK]".white.green_bg << " #{@opt[:file]}"
+      else
+        source = @opt[:source]
+        lines = source.split(/\r\n|\n|\r/)
+        prf = @opt[:prefix]
+        suf = @opt[:suffix]
+
+        puts "[EE] #{@opt[:file]}".white.magenta_bg
+
+        @results.each do |r|
+          if r.row && r.row > 0
+            col = r.column - 1
+            row = r.row - 1
+            left = col - 50
+            right = col + 50
+            left = 0 if left < 0
+
+            puts "#{prf}#{lines[row][left..right].gsub(/\t/, ' ')}"
+            puts "#{prf}#{' ' * (col - left)}^ #{r.to_color_s}"
+            puts "\n"
+          else
+            puts "#{r.to_color_s}#{suf}\n"
+          end
+        end
+      end
+      
+    end
+  end
+
+end

data/lib/printer/nocolor_printer.rb

@@ -0,0 +1,27 @@
+require_relative 'base_printer'
+
+module XRay
+
+  class NoColorPrinter < BasePrinter
+
+    XRay.register_printer self
+
+    def print
+      if @results.empty?
+        puts "[OK] #{@opt[:file]}"
+      else
+        prf = @opt[:prefix]
+        suf = @opt[:suffix]
+        out = @opt[:out]
+
+        puts "[EE] #{@opt[:file]}"
+
+        @results.each do |r|
+          puts "#{prf}#{r}#{suf}"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/printer/vim_printer.rb

@@ -0,0 +1,19 @@
+require_relative 'base_printer'
+
+module XRay
+
+  class VimPrinter < BasePrinter
+
+    XRay.register_printer self
+
+    def print
+      prf = (@opt[:file]||'-').dup.utf8!
+      @results.each do |r|
+        puts "#{prf}:[#{r.level}]:#{r.row},#{r.column}:#{r.message}"
+      end
+      
+    end
+
+  end
+
+end

data/lib/rule.rb

@@ -0,0 +1,241 @@
+require 'find'
+require_relative 'js/parser'
+require_relative 'html/parser'
+require_relative 'css/parser'
+require_relative 'helper/file_reader'
+require_relative 'node'
+
+module XRay
+
+  module Rule
+
+    STYLE_TYPES = [:css, :js, :html]
+
+    def self.methods_to_keywords(klass)
+      klass.instance_methods.grep( /^parse_/ ).map {|m| m[/^parse_(.*)/,1]}
+    end
+
+    RULE_PATH = File.expand_path '../rules.d', File.dirname(__FILE__)
+    KEYWORDS = %w(file merge_importing merge_file)
+
+    KEYWORDS.concat methods_to_keywords(XRay::JS::Parser)
+    KEYWORDS.concat methods_to_keywords(XRay::CSS::Parser)
+    KEYWORDS.concat methods_to_keywords(XRay::HTML::Parser)
+
+    @@common_rules = []
+    @@context = nil
+
+    def syntax(*type)
+      if type.empty?
+        @syntax || 'common'
+      else
+        @syntax = type.first
+      end
+    end
+
+    def common(&block)
+      syntax nil
+      yield if block_given?
+    end
+
+    KEYWORDS.each do |kw|
+      eval <<-RUBY
+      def #{kw}_rules
+        @@common_rules.select {|r| r[:name].to_s.include? "#{kw}" }
+      end
+
+      def check_#{kw}( *target, &block )
+        if block_given?
+          self.send :"add_\#{syntax}_rule", :check_#{kw}, &block
+        elsif target.size > 0
+          do_check #{kw}_rules, *target
+        end
+      end
+
+      RUBY
+
+      STYLE_TYPES.each do |syn|
+        eval <<-RUBY
+        def #{syn}_#{kw}_rules
+          #{syn}_rules.select {|r| r[:name].to_s.include? "#{kw}" }
+        end
+
+        def only_#{syn}_#{kw}_rules
+          only_#{syn}_rules.select {|r| r[:name].to_s.include? "#{kw}" }
+        end
+
+        def check_#{syn}_#{kw}( *target, &block )
+          if block_given?
+            self.send :"add_#{syn}_rule", :check_#{syn}_#{kw}, &block
+          elsif target.size > 0
+            do_check #{syn}_#{kw}_rules, *target
+          end
+        end
+
+        RUBY
+      end
+    end
+
+    STYLE_TYPES.each do |syn|
+
+      eval <<-RUBY
+
+        @@#{syn}_rules = []
+
+        def #{syn}
+          syntax #{syn.inspect}
+          yield if block_given?
+        end
+
+        def add_#{syn}_rule( name, &block )
+          @@#{syn}_rules << { :name => name, :block => block }
+        end
+
+        def #{syn}_rules
+          @@common_rules + @@#{syn}_rules
+        end
+
+        def only_#{syn}_rules
+          @@#{syn}_rules
+        end
+
+        def clear_#{syn}_rules
+          @@#{syn}_rules.clear
+        end
+      RUBY
+    end
+
+    def clear_all_rules
+      @@imported.clear
+      @@common_rules.clear
+      STYLE_TYPES.each { |syn| send(:"clear_#{syn}_rules") }
+    end
+
+    def do_check( rules, *args )
+      @@context = self
+      target = args.first
+      rules.inject([]) do |results, r|
+        result = r[:block].call(*args)
+        results << result if result
+        results
+      end
+    end
+
+    def context
+      @@context
+    end
+
+    def method_missing( name , *args, &block )
+      if cmd = cmd_name(name) and self.respond_to? cmd 
+        send(cmd, name, &block )
+        def_rule_cmd(cmd, name, &block) if block_given?
+      else
+        super
+      end
+    end
+
+    def def_rule_cmd(cmd, name, &block)
+      XRay::Rule.instance_eval do 
+        define_method(name) do |*tar, &b|
+          if tar.size > 0
+            @@context = self
+            block.call *tar
+          else
+            send cmd, name, &b
+          end
+        end
+      end
+    end
+    private :def_rule_cmd
+
+    def cmd_name(name)
+      name = name.to_s
+      KEYWORDS.each do |kw| 
+        if name.start_with? "check_#{kw}" 
+          return :"check_#{kw}"
+        else 
+          STYLE_TYPES.each do |s| 
+            cmd = "check_#{s}_#{kw}"
+            return cmd if name.start_with? cmd
+          end
+        end
+      end
+      nil
+    end
+
+    def add_common_rule( name, &block )
+      @@common_rules << { :name => name , :block => block }
+    end
+
+    alias :add_rule :add_common_rule
+
+
+
+    @@imported = []
+
+    def import( name )
+      if name.is_a? Symbol
+        path = File.join(RULE_PATH, "#{name}.rule")
+      else
+        path = name
+      end
+      path = File.expand_path path
+      unless imported? path
+        @@imported << path
+        src, enc = ::XRay::Helper::FileReader.readfile path
+        instance_eval src
+      end
+    end
+
+    def import_all
+      Find.find( RULE_PATH ) do |rule|
+        import rule if rule.end_with? '.rule'
+      end
+    end
+
+    def self.import_all
+      "".extend(self).import_all
+    end
+
+    def imported?(path)
+      @@imported.include? path
+    end
+
+    def imported
+      @@imported
+    end
+
+  end
+
+end
+
+
+if __FILE__ == $0
+
+  extend XRay::Rule
+
+  ## Rule DSL example
+  css {
+    check_file_without_min { |file|
+      ['should not be min file', :error] if file =~ /-min\.css$/
+    }
+
+  }
+
+  common {
+    check_file { |file| 
+      ['should use "-" instead of "_"', :warn] if file =~ /_/
+    }
+  }
+
+  ## Test
+  import_all
+
+  puts file_rules
+  puts css_file_rules
+
+  puts check_file_without_min('test-min.css').inspect
+  puts check_css_file('test_a-min.css').inspect
+  puts check_css_value('expression(test)\0').inspect
+
+end

data/lib/rule_helper.rb

@@ -0,0 +1,14 @@
+module XRay
+  module RuleHelper
+    
+    def dispatch(items, node)
+      results = []
+      items.each do |item|
+        result = self.send(item, node)
+        result && (results << result.flatten)
+      end
+      results
+    end
+
+  end
+end