fdlint 0.1.3 → 0.2.0.pre

data/lib/base_parser.rb

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

@@ -1,145 +0,0 @@
-#!/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

@@ -1,31 +0,0 @@
-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/reader.rb

@@ -1,30 +0,0 @@
-require_relative '../encoding_error'
-require_relative '../helper/file_reader'
-
-module XRay
-  module CSS
-    
-    class Reader
-      
-      include XRay::Helper
-
-      def self.read( file, opt = {} )
-        source, enc = FileReader::readfile(file)
-        declare = get_encoding_declaration(file)
-        if declare and enc != declare
-          raise EncodingError.new
-        end
-        source
-      end
-
-      def self.get_encoding_declaration( file )
-        begin
-          File.open(file, &:readline)[/@charset\s+(['"])(.*?)\1/, 2]
-        rescue
-        end
-      end
-    end
-
-  end
-
-end

data/lib/css/rule/check_compression_rule.rb

@@ -1,48 +0,0 @@
-# encoding: utf-8
-require_relative '../../log_entry'
-
-module XRay
-  module CSS
-    module Rule
-
-      class CompressionChecker
-        
-        def initialize( opt={} )
-          @opt = opt.dup
-        end
-        
-        def check_file( name )
-          check_items([
-            :has_minified_in_same_folder
-          ], name)
-        end
-
-        def check_has_minified_in_same_folder( name )
-          unless is_min_file?(name) or is_merge_file?(name) or File.exist?( name.sub(/\.css$/,'-min.css') )
-            [LogEntry.new('发布上线的文件需要压缩，命名规则如a.js->a-min.js，且两者在同一目录下', :error)]
-          end
-        end
-
-        protected
-        def check_items( items, name )
-          results = []
-          items.each do |i|
-            r = self.send(:"check_#{i}", name)
-            results.concat r if Array === r
-          end
-          results
-        end
-
-        def is_merge_file?( name )
-          name =~ /merge\.css$/
-        end
-
-        def is_min_file?( name )
-          name =~ /min\.css$/
-        end
-
-      end
-
-    end
-  end
-end

data/lib/css/rule/checklist.rb

@@ -1,45 +0,0 @@
-# encoding: utf-8
-
-require_relative '../../rule'
-require_relative '../../context'
-
-module XRay
-  module CSS
-    module Rule
-
-      class CheckListRule
-
-        attr_reader :options
-
-        include ::XRay::Rule, Context
-
-        def initialize(options = {}) 
-          @options = options
-        end
-
-        def visit_simple_selector(selector)
-          check_css_selector selector
-        end
-        
-        def visit_declaration(dec)
-          check_declaration dec
-        end
-
-        def visit_ruleset(ruleset)
-          check_css_ruleset ruleset
-        end
-
-        def visit_property(property)
-          check_css_property property
-        end
-
-        def visit_value(value)
-          check_css_value value
-        end
-
-
-      end
-
-    end
-  end
-end

data/lib/helper/code_type.rb

@@ -1,50 +0,0 @@
-class CodeType
-
-  class << self
-
-    public
-    def guess(text, filename=nil)
-      if filename && !filename.empty?
-        guess_by_name filename
-      else
-        guess_by_content text
-      end
-    end
-
-    def guess_by_name( filename )
-      case File.extname( filename )
-      when /\.css$/i
-        :css
-      when /\.js$/i
-        :js
-      else
-        :html #TODO: support more suffix
-      end
-    end
-
-    def guess_by_content(text)
-      return :html  if is_html? text
-      return :css   if is_css? text
-      :js #TODO: support more code syntaxes
-    end
-
-    def is_style_file?(filename)
-      File.extname( filename ) =~ /(css|js|html?)$/i
-    end
-
-    def scope(filename)
-      filename =~ /[\\\/]lib[\\\/]/ ? 'lib' : 'page'
-    end
-
-    private
-    def is_html?(text)
-      /^\s*</m =~ text
-    end
-
-    def is_css?(text)
-      /^\s*@/m =~ text or /^\s*([-\*:\.#_\w]+\s*)+\{/ =~ text
-    end
-
-  end
-
-end

data/lib/helper/color_string.rb

@@ -1,44 +0,0 @@
-class ColorString
-
-  @@colors = %w(black red green yellow blue magenta cyan white)
-
-  def self.colors
-    @@colors
-  end
-
-  def initialize(str, color=nil, bg=nil)
-    @str, @color, @bg = str, color, bg
-  end
-
-  def to_s
-    return @str if @color.nil? and @bg.nil?
-    s = []
-    s << "3#{@color}" unless @color.nil?
-    s << "4#{@bg}" unless @bg.nil?
-    "\e[#{s.join(';')}m" << @str << "\e[0m"
-  end
-
-  def inspect
-    "#<ColorString \"#{@str}\", color:#{@color}, bg:#{@bg}>"
-  end
-
-  String.public_instance_methods.each do |m|
-    unless self.respond_to? m
-      define_method(m) { |*arg| to_s.send( m, *arg ) }
-    end
-  end
-
-  @@colors.each_with_index do |color, i|
-    String.class_eval do
-      define_method(color) { ColorString.new(self, i) }
-      define_method(color << '_bg') { ColorString.new(self, nil, i) }
-    end
-
-    ColorString.class_eval do
-      define_method(color) { @color = i; self }
-      define_method(color << '_bg') { @bg = i; self }
-    end
-
-  end
-end
-

data/lib/helper/file_reader.rb

@@ -1,22 +0,0 @@
-require_relative 'strenc'
-
-module XRay
-  module Helper
-    module FileReader
-      extend self
-
-      # auto detect file encoding and read it.
-      # return with an array containing string
-      # and encoding
-      def readfile(path, opt={})
-        if File.readable?(path)
-          bin = File.read(path).utf8!
-          [bin, bin.former_enc ||'ascii-8bit' ]
-        else
-          raise ArgumentError.new("File is not readable!")
-        end
-      end
-
-    end
-  end
-end

data/lib/helper/strenc.rb

@@ -1,65 +0,0 @@
-# encoding: utf-8
-
-class String
-
-  @@encs = %w(ascii utf-8 gb18030 gbk gb2312 cp936 big5)
-
-  class << self
-    def encs; @@encs; end
-    def encs=(arr); @@encs = arr; end
-  end
-
-  if public_instance_methods.include? :encode!
-    def try_convert to, from
-      encode!( to, from ).force_encoding( to )
-      valid_encoding?
-    end
-  else
-    # for ruby 1.8
-    require 'iconv'
-    def try_convert to, from
-      text = Iconv.new(to, from).iconv(self)
-      replace(text) if self =~ /./
-    end
-  end
-
-  attr_reader :former_enc
-
-  def enc!(encoding)
-
-    if respond_to? :force_encoding
-      force_encoding encoding
-      if valid_encoding?
-        @former_enc = encoding
-        return self 
-      end
-    end
-    
-    @@encs.each do |c|
-      begin
-        if send :try_convert, encoding, c
-          @former_enc = c
-          break
-        end
-      rescue
-      end
-    end
-    self
-  end
-
-  @@encs.each do |tar|
-    mtd = tar.gsub(/-/, '') << "!"
-    define_method mtd do
-      enc! tar
-    end
-    public mtd
-  end
-
-  private :try_convert
-
-end
-
-
-if __FILE__ == $0
-  puts File.read('test/fixtures/html/1-1.html').utf8!
-end

data/lib/js/expr/expr.rb

@@ -1,66 +0,0 @@
-require_relative 'primary'
-require_relative 'left_hand'
-require_relative 'operate'
-
-
-module XRay
-  module JS
-    module Expr 
-
-      module Expr
-        include Primary, LeftHand, Operate
-        
-        def parse_expression
-          log 'parse expression'
-          parse_expr_with_operate :parse_expr_assignment, /,/ 
-        end
-
-        def parse_expr_assignment
-          log 'parse expr assignment'
-
-          expr = parse_expr_condition
-
-          r = /=|\*=|\/=|%=|\+=|-=|<<=|>>=|>>>=|&=|\^=|\|=/
-          if expr.left_hand? && check(r)
-            op = scan r
-            expr = create_element Expression, op.text, expr, parse_expr_assignment
-          end
-          expr
-        end
-
-        def parse_expr_condition
-          log 'parse expr condition'
-          expr = parse_expr_logical_or
-          if check /\?/
-            skip /\?/
-            left = parse_expr_assignment
-            skip /:/
-            right = parse_expr_assignment
-
-            expr = create_element ConditionExpression, expr, left, right
-          end
-          expr
-        end
-
-        protected
-
-        def parse_expr_with_operate(left, pattern = nil, &block)
-          block = block || lambda {
-            if check pattern
-              op = scan pattern
-              [op.text, self.send(left)]
-            end
-          }
-
-          expr = self.send left
-          while (ret = block.call) 
-            expr = create_element Expression, ret[0], expr, ret[1]
-          end 
-          expr
-        end
-         
-      end
-
-    end
-  end
-end