fdlint 0.1.0

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+gem 'win32console' if ENV['OS'] =~ /windows/i
+
+group :development do
+  gem 'test-unit'
+  gem 'rake'
+  gem 'gem-this'
+end

data/Gemfile.lock

@@ -0,0 +1,14 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    gem-this (0.3.7)
+    rake (0.9.2.2)
+    test-unit (2.4.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  gem-this
+  rake
+  test-unit

data/README.md

@@ -0,0 +1,68 @@
+fdlint -- 让前端code review更轻松
+=================================
+
+![fdlint-logo](http://q.pnq.cc/wp-content/uploads/2012/02/fdlint-logo-white.png)
+
+fdlint (开发代号xray) 是根据阿里巴巴前端开发checklist开发的自动代码扫描工具。
+可以扫描出前端程序中不符合开发规范的地方。
+
+[![Build Status](https://secure.travis-ci.org/qhwa/fdlint.png)](http://travis-ci.org/qhwa/fdlint)
+
+## 语言支持
+* html
+* css
+* javascript
+
+## 使用方式
+
+### 编辑器插件
+
+* [Nodepad++ 插件](https://github.com/ThinkBest/fdlint-notepad-plusplus)
+* [Vim 插件](https://github.com/qhwa/fdlint-vim)
+
+### 命令行工具
+
+#### ruby脚本
+适合安装了Ruby1.9+ 环境的Windows/\*nix系统
+
+运行方式
+
+    /path/to/fdlint [参数] <目标文件或目录>
+
+或者使用管道：
+
+    echo '* {}' | /path/to/fdlint
+
+参数列表：
+
+~~~
+Usage: fdlint
+        --css                        在扫描模式下仅检查CSS文件，在管道模式下指定内容为CSS
+        --js                         在扫描模式下仅检查JS文件，在管道模式下指定内容为JS
+        --html                       在扫描模式下仅检查HTML文件，在管道模式下指定内容为HTML
+    -c, --charset set                指定文件默认的编码(本参数已废弃，目前自动判断字符集)
+    -d, --debug                      输出调试信息
+    -l, --list                       无彩色输出，等同于 '--format=nocolor'
+    -m, --checkmin                   检查压缩后的js或css文件。如不指定改选项，会跳过*-min.css或*-min.js文件。
+                                      (e.g. *-min.js; *-min.css)
+        --format [type]              输出模式：console （默认）、nocolor 或 vim
+        --level [log_level]          输出时消息的过滤等级：warn（默认）、error 或 fatal
+~~~
+
+### Web
+
+[fdlint-host](https://github.com/qhwa/fdlint-host)
+
+
+## 源代码
+
+    git clone git://github.com/qhwa/fdlint.git
+
+## 开源协议
+
+[BSD协议](http://www.linfo.org/bsdlicense.html)
+
+## 附录
+
+[扫描规则](https://github.com/qhwa/fdlint/wiki/fdlint-%E6%89%AB%E6%8F%8F%E8%A7%84%E5%88%99)
+

data/Rakefile

@@ -0,0 +1,92 @@
+task :default => [:test]
+
+desc "run unit tests"
+task :test do
+  require_relative 'test/all_tests'
+end
+
+
+require "rubygems"
+require "rubygems/package_task"
+require "rdoc/task"
+
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+
+task :default => ["test"]
+
+# This builds the actual gem. For details of what all these options
+# mean, and other ones you can add, check the documentation here:
+#
+#   http://rubygems.org/read/chapter/20
+#
+spec = Gem::Specification.new do |s|
+
+  # Change these as appropriate
+  s.name              = "fdlint"
+  s.version           = "0.1.0"
+  s.summary           = "Code reviewer for web developing. Check your HTML/JS/CSS codes against bad codes."
+  s.author            = "qhwa,bencode"
+  s.email             = "qhwa@163.com,bencode@163.com"
+  s.homepage          = "https://github.com/qhwa/fdlint"
+
+  s.has_rdoc          = false
+  s.extra_rdoc_files  = %w(README.md)
+  s.rdoc_options      = %w(--main README.md)
+
+  # Add any extra files to include in the gem
+  s.files             = %w(README.md Rakefile Gemfile.lock Gemfile) + 
+                        Dir.glob("{bin,test,lib,rules.d}/**/*") -
+                        Dir.glob("test/fixtures/html/{cms,tmp}/**/*")
+  s.executables       = FileList["bin/**"].map { |f| File.basename(f) }
+  s.require_paths     = ["lib"]
+
+  # If you want to depend on other gems, add them here, along with any
+  # relevant versions
+  s.add_dependency("win32console")
+
+  # If your tests use any gems, include them here
+  s.add_development_dependency("rake")
+  s.add_development_dependency("test-unit")
+end
+
+# This task actually builds the gem. We also regenerate a static
+# .gemspec file, which is useful if something (i.e. GitHub) will
+# be automatically building a gem for this project. If you're not
+# using GitHub, edit as appropriate.
+#
+# To publish your gem online, install the 'gemcutter' gem; Read more 
+# about that here: http://gemcutter.org/pages/gem_docs
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Build the gemspec file #{spec.name}.gemspec"
+task :gemspec do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, "w") {|f| f << spec.to_ruby }
+end
+
+# If you don't want to generate the .gemspec file, just remove this line. Reasons
+# why you might want to generate a gemspec:
+#  - using bundler with a git source
+#  - building the gem without rake (i.e. gem build blah.gemspec)
+#  - maybe others?
+task :package => :gemspec
+
+# Generate documentation
+RDoc::Task.new do |rd|
+  rd.main = "README.md"
+  rd.rdoc_files.include("README.md", "lib/**/*.rb")
+  rd.rdoc_dir = "rdoc"
+end
+
+desc 'Clear out RDoc and generated packages'
+task :clean => [:clobber_rdoc, :clobber_package] do
+  rm "#{spec.name}.gemspec"
+end

data/bin/fdlint

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.expand_path(path.to_str, File.dirname(caller[0]))
+    end
+  end
+end
+
+require_relative '../lib/cmd_runner'
+
+if __FILE__ == $0
+  trap("SIGINT") { puts "\nGoodbye!"; exit! }
+  XRay::CMDRunner.run
+end
+

data/lib/base_parser.rb

@@ -0,0 +1,143 @@
+require 'strscan'
+
+require_relative 'node'
+require_relative 'parse_error'
+require_relative 'position_info'
+
+module XRay
+  
+  class BaseParser
+
+    attr_reader :log
+
+    def initialize(text, log = nil)
+      @log = log
+      text = filter_text(prepare_text(text))
+      @pos_info = PositionInfo.new text
+      @scanner = StringScanner.new text
+      @text_size = text.size
+    end
+
+    def skip_empty
+      @scanner.skip(/\s*/)
+    end
+      
+    def skip(pattern, not_skip_empty = false)
+      not_skip_empty || skip_empty
+      pos = scanner_pos
+      unless @scanner.skip pattern
+        parse_error pattern
+      end
+      after_skip pattern
+      pos
+    end
+
+    def check(pattern, not_skip_empty = false)
+      skip_empty = !not_skip_empty
+      if skip_empty && @scanner.check(/\s+/)
+        last_pos = @scanner.pos
+        @scanner.skip /\s+/
+      end
+      ret = @scanner.check pattern
+      @scanner.pos = last_pos if last_pos
+      ret
+    end
+      
+    def scan(pattern, not_skip_empty = false)
+      node = raw_scan pattern, not_skip_empty
+      after_scan pattern
+      node
+    end
+
+    def raw_scan(pattern, not_skip_empty = false)
+      not_skip_empty || skip_empty
+      pos = scanner_pos
+      text = @scanner.scan pattern
+      text ? Node.new(text, pos) : parse_error(pattern)
+    end
+      
+    def batch(name, stop = nil, skip_pattern = nil, not_skip_empty = false, &block)
+      first = true
+      result = []
+      while !@scanner.eos? && 
+          (stop ? batch_check(stop, skip_pattern, not_skip_empty, first) : 
+              block ? block.call : true) && 
+          item = send(name)
+        result << item
+        first = false
+      end
+      result
+    end
+    
+    def to_s
+      self.class.to_s
+    end
+    
+    def reset
+      @scanner.reset
+    end
+
+    def eos?
+      @scanner.eos?
+    end
+
+    protected
+    
+    def filter_text(text)
+      text
+    end
+
+    def after_skip(pattern)
+    end
+
+    def after_scan(pattern)
+    end
+    
+    def parse_warn(message)
+      pos = scanner_pos
+      log "#{message}#{pos}", :warn
+    end
+
+    def parse_error(pattern)
+      if pattern.respond_to?(:source)
+        message = "should be #{pattern.source} here"
+      else
+        message = pattern.to_s
+      end
+      pos = scanner_pos
+      log "#{message} #{pos}", :error
+      raise ParseError.new(message, pos)
+    end
+      
+    def log(message, level = :info)
+      @log && @log.send("#{level}?") &&
+          @log.send(level, self.to_s + ': ' + message)
+    end
+
+    def scanner_pos
+      pos = @text_size - @scanner.rest.size
+      @pos_info.locate pos    
+    end
+
+    private
+
+    def prepare_text(text)
+      if text.respond_to? :encode!
+        text.encode! 'utf-8', :invalid => :replace, :universal_newline => true
+      else
+        text.gsub(/\r\n/, "\n").gsub(/\r/, "\n")
+      end
+    end
+    
+    def batch_check(stop, skip_pattern, not_skip_empty, first)
+      if check stop, not_skip_empty
+        false
+      else
+        !first && skip_pattern && skip(skip_pattern) 
+        true
+      end
+    end
+
+  end
+
+end

data/lib/cmd_runner.rb

@@ -0,0 +1,145 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'find'
+require_relative 'runner'
+require_relative 'printer/vim_printer'
+require_relative 'printer/console_printer'
+require_relative 'printer/nocolor_printer'
+
+module XRay
+
+  Version = "0.1"
+
+  class CMDOptions
+
+    def self.parse( args )
+      files = []
+      options = {
+        :encoding   => 'gb2312',
+        :colorful   => true,
+        :type       => nil,
+        :check_min  => false,
+        :format     => :console
+      }
+
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: fdlint"
+        %w(css js html).each do |type|
+          opts.on("--#{type}", "check #{type} files only") do
+            options[:type] = type.intern
+          end
+        end
+        opts.on("--charset set", "-c", "file charset") do |enc|
+          options[:encoding] = enc
+        end
+        opts.on("--debug", "-d", "print debug info") do
+          options[:debug] = true
+        end
+        opts.on("--list", "-l", "list results without source, the same as '--format=nocolor'") do
+          options[:format] = :nocolor
+        end
+        opts.on("--checkmin", "-m", "check minified files too. (e.g. *-min.js; *-min.css)") do
+          options[:check_min] = true
+        end
+        opts.on("--format [type]", [:console, :nocolor, :vim], "output format. Can be 'vim', 'console' or 'nocolor'. Default is 'console'") do |f|
+          options[:format] = f.intern
+        end
+        opts.on("--level [log_level]", [:warn, :error, :fatal], "determine the log level. Can be 'warn', 'error' or 'fatal'") do |level|
+          options[:log_level] = level
+        end
+      end
+
+      begin
+        rest = opts.parse! args
+        files.concat rest
+
+        if files.empty?
+          unless $stdin.tty?
+            str = ARGF.read
+            options[:text] = str
+          else
+            raise ArgumentError.new("") 
+          end
+        end
+
+      rescue => e
+        puts e.message.capitalize + "\n\n"
+        puts opts
+        exit 1
+      end
+      [options, files]
+
+    end
+
+  end
+
+  class CMDRunner
+
+    def self.run
+      self.new.run
+    end
+
+    def run
+      options, files = XRay::CMDOptions.parse ARGV
+      @core_runner = XRay::Runner.new(options)
+
+      unless files.empty?
+        files.each do |file|
+          check_file file, options
+        end
+      else
+        method = options[:type] ? :"check_#{options[:type]}" : :check
+        print @core_runner.send(method, options[:text].utf8!), options
+      end
+    end
+
+    private
+    def check_file( file, opt)
+
+      if File.directory? file
+        Find.find(file) do |f|
+          check_file(f, opt) unless File.directory? f
+        end
+        return
+      end
+
+      if @core_runner.valid_file? file
+        print @core_runner.check_file( file ), opt.merge( :file => file.to_s )
+      end
+    end
+
+    def print( results, opt={} )
+      print_results(
+        results, 
+        opt.merge({
+          :prefix   => ' ' * 5,
+          :source   => @core_runner.source
+        })
+      )
+    end
+
+    def print_results( results, opt={} )
+      IO.popen "chcp 65001" if ENV['OS'] =~ /windows/i
+      print_class = case opt[:format]
+        when :vim
+          'VimPrinter'
+        when :nocolor
+          'NoColorPrinter'
+        else 
+          'ConsolePrinter'
+      end
+      XRay.register_printer XRay.const_get( print_class )
+      XRay.printer.new( results, opt ).print
+    end
+
+    def print_type(format)
+      format || 'base'
+    end
+
+  end
+
+end
+
+if $0 == __FILE__
+  XRay::CMDRunner.run
+end

data/lib/context.rb

@@ -0,0 +1,31 @@
+module XRay
+
+  module Context
+
+    attr_accessor :scope
+
+    def lib?
+      scope == :lib
+    end
+
+    def page_level?
+      scope == :page
+    end
+
+    def in_page?
+      scope == :in_page
+    end
+
+  end
+
+  class DefaultContext
+
+    include Context
+
+    def initialize
+      @scope = :page
+    end
+  end
+
+
+end

data/lib/css/parser.rb

@@ -0,0 +1,186 @@
+require_relative '../base_parser'
+require_relative 'struct'
+
+module XRay
+  module CSS
+    
+    class Parser < XRay::BaseParser
+      TERM = %q([^;{}'"])
+      TERM2 = %q([^;{}'",])
+      QUOT_EXPR = "'[^']*'"
+      DQUOT_EXPR = '"[^"]*"'
+
+      R_IDENT = /-?[_a-z][_a-z0-9-]*/
+      R_ANY = %r"((?:#{TERM})|(?:#{QUOT_EXPR})|(?:#{DQUOT_EXPR}))+"
+      R_SELECTOR = %r"((?:#{TERM2})|(?:#{QUOT_EXPR})|(?:#{DQUOT_EXPR}))+"
+      R_PROPERTY = /[*_+\\]?-?[_a-z\\][\\_a-z0-9-]*/
+      
+      attr_reader :comments
+
+      def initialize(css, logger)
+        super
+        @comments = []
+      end
+
+      def parse_stylesheet(inner = false)
+        log 'parse stylesheet'
+        
+        do_parse_comment
+
+        stats = batch(:parse_statement) do 
+          skip_empty
+          !(inner ? check(/\}/) : eos?)
+        end
+        
+        StyleSheet.new stats
+      end
+
+      alias_method :parse, :parse_stylesheet
+
+      # ruleset or directive
+      def parse_statement
+        log 'parse statement'
+
+        if check /@/
+          parse_directive
+        else
+          parse_ruleset
+        end
+      end
+
+      def parse_directive
+        log 'parse directive'
+
+        skip /@/
+        keyword = scan R_IDENT 
+        skip_empty
+        
+        expr = check(/\{/) || check(/;/) ? nil : 
+            scan(R_ANY)
+
+        block = nil
+        if check /\{/
+          skip /\{/
+          block = parse_stylesheet true
+          skip /\}/
+        end
+
+        unless block
+          skip /;/ 
+        end
+
+        log "  keyword: #{keyword} #{keyword.position}"
+        log("  expression: #{expr} #{expr.position}") if expr
+        log("  block:\n#{block}\n#{block.position}") if block
+        Directive.new keyword, expr, block
+      end
+      
+      def parse_ruleset
+        log 'parse ruleset'
+
+        selector = check(/\{/) ? nil : parse_selector
+        skip /\{/
+        declarations = do_parse_declarations
+        skip /\}/
+        
+        RuleSet.new selector, declarations
+      end
+      
+      def parse_selector
+        log ' parse selector'
+        simple_selectors = batch(:parse_simple_selector, /\{/, /,/)
+        Selector.new simple_selectors
+      end
+
+      def parse_simple_selector
+        log '  parse simple selector'
+        selector = scan R_SELECTOR 
+        log "   #{selector} #{selector.position}"
+        selector
+      end
+      
+      def parse_declarations
+        first = true
+        batch(:parse_declaration) do
+          if check /\}/
+            false
+          else 
+            skip(first ? /[;\s]*/ : /[;\s]+/)
+            first = false
+            !check /\}/
+          end
+        end
+      end
+      
+      def parse_declaration
+        log '   parse declaration'
+        
+        property = parse_property
+        skip /:/
+        value = parse_value
+        
+        Declaration.new(property, value)
+      end
+      
+      def parse_property
+        log '    parse property'
+        property = scan R_PROPERTY 
+        log "     #{property} #{property.position}"
+        property
+      end
+      
+      def parse_value
+        log '    parse value'
+
+        value = scan R_ANY 
+        log "     #{value} #{value.position}"
+        value 
+      end
+
+      def parse_comment
+        log 'pare comment'
+        comment =  raw_scan /\/\*[^*]*\*+([^\/*][^*]*\*+)*\//
+        log "  #{comment}" 
+        comment
+      end
+     
+      protected 
+
+      #override
+      def after_scan(pattern)
+        do_parse_comment
+      end
+
+      def after_skip(pattern)
+        do_parse_comment
+      end
+
+      private
+
+      def do_parse_declarations
+        first = true
+        batch(:parse_declaration) do
+          if check /\}/
+            false
+          else 
+            skip(first ? /[;\s]*/ : /[;\s]+/)
+            first = false
+            !check /\}/
+          end
+        end
+      end
+
+      def do_parse_comment
+        while true
+          if check /\/\*/
+            @comments << parse_comment
+          else
+            break
+          end
+        end
+      end
+      
+    end
+    
+  end
+end