fdlint 0.1.3 → 0.2.0.pre

data/lib/parser_visitable.rb

@@ -1,138 +0,0 @@
-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/printer/base_printer.rb

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

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

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

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

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

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