fdlint 0.1.0

data/lib/css/reader.rb

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

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

@@ -0,0 +1,45 @@
+# 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/css/struct.rb

@@ -0,0 +1,111 @@
+require_relative '../node'
+
+module XRay
+  module CSS
+    Node = XRay::Node
+    
+    class StyleSheet < Node
+      attr_reader :statements
+
+      def initialize(statements)
+        @statements = statements
+      end
+
+      def text
+        rulesets.collect(&:text).join("\n")
+      end
+
+      def position
+        rulesets.empty? ? nil : rulesets[0].position
+      end
+
+      def directives
+        statements.select { |elm| elm.is_a? Directive }
+      end
+
+      def rulesets
+        statements.select { |elm| elm.is_a? RuleSet }
+      end
+
+      alias :at_rules :directives
+    end
+
+    class Directive < Node
+      attr_reader :keyword, :expression, :block
+
+      def initialize(keyword, expression, block = nil)
+        @keyword, @expression, @block = keyword, expression, block 
+      end
+
+      def text
+        t = "@#{keyword}"
+        if expression
+          t += "#{expression}"
+        end
+        if block
+          t += "{\n#{block}\n}\n"
+        else
+          t += ';'
+        end
+        t
+      end
+
+      def position
+        keyword.position
+      end
+    end
+
+    class RuleSet < Node
+      attr_reader :selector, :declarations
+
+      def initialize(selector, declarations)
+        @selector, @declarations = selector, declarations
+      end
+
+      def text
+        decs_text = declarations.collect { |dec|
+          "#{' ' * 4}#{dec};"
+        }.join("\n")
+        
+        "#{selector} {\n#{decs_text}\n}"
+      end
+
+      def position
+        selector.position
+      end
+    end
+
+    class Selector < Node
+      attr_reader :simple_selectors
+
+      def initialize(simple_selectors)
+        @simple_selectors = simple_selectors
+      end
+
+      def text
+        @simple_selectors.collect(&:text).join(', ')
+      end
+
+      def position
+        simple_selectors.empty? ? nil : simple_selectors[0].position
+      end
+    end
+
+    class Declaration < Node
+      attr_reader :property, :value
+
+      def initialize(property, value)
+        @property, @value = property, value
+      end
+
+      def text
+        "#{property}: #{value}"
+      end
+
+      def position
+        property.position
+      end
+    end
+
+  end
+end

data/lib/encoding_error.rb

@@ -0,0 +1,6 @@
+module XRay
+
+  class EncodingError < RuntimeError
+  end
+
+end

data/lib/file_validator.rb

@@ -0,0 +1,38 @@
+module XRay
+  
+  class FileValidator
+    def initialize( options )
+      @options = options
+      @validators = []
+    end
+
+    def add_validator( val )
+      @validators << val
+    end
+
+    def add_validators( vals)
+      vals.each { |val| add_validator val }
+    end
+
+    def check( file )
+      results = []
+      @validators.each do |val|
+        if val.respond_to? :check_file
+          val_results = val.check_file(file)
+          if val_results
+            if val_results.is_a? Array
+              results.concat val_results
+            else
+              results << val_results
+            end
+          end
+        end
+      end
+      results
+    end
+
+    alias_method :validate, :check
+
+  end
+
+end

data/lib/helper/code_type.rb

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

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

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

@@ -0,0 +1,65 @@
+# 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/html/parser.rb

@@ -0,0 +1,212 @@
+require_relative '../base_parser'
+require_relative '../css/parser'
+require_relative '../js/parser'
+require_relative 'struct'
+
+module XRay; module HTML
+
+  class Parser < BaseParser
+
+    def self.parse(src, &block)
+      parser = self.new(src)
+      doc = parser.parse
+      yield doc if block_given? 
+      doc
+    end
+
+    TEXT            = /[^<]+/m
+    PROP_NAME       = %r/\w[-:\w]*/m
+    PROP_VALUE      = %r/'([^']*)'|"([^"]*)"|([^\s>]+)/m
+    PROP            = %r/#{PROP_NAME}\s*(?:=\s*#{PROP_VALUE})?/m
+    TAG_NAME        = /\w[^>\(\)\/\s]*/ 
+    TAG_START       = %r/<(#{TAG_NAME})/m
+    TAG_END         = %r/<\/#{TAG_NAME}\s*>/m
+    TAG             = %r/#{TAG_START}(\s+#{PROP})*\s*>/m
+    SELF_CLOSE_TAG  = %r/#{TAG_START}(\s+#{PROP})*\s*\/>/m
+    DTD             = /\s*<!(doctype)\s+(.*?)>/im
+    COMMENT         = /<!--(.*?)-->/m
+
+    def parse
+      parse_doc
+    end
+
+    def parse_doc
+      nodes = batch(:parse_element)
+      case nodes.size
+        when 0 then nil
+        when 1 then nodes[0]
+        else 
+          ::XRay::HTML::Document.new( nodes )
+      end
+    end
+
+    def parse_element
+      if @scanner.check(DTD) and !@dtd_checked
+        @dtd_checked = true
+        parse_dtd
+      elsif @scanner.check(COMMENT)
+        parse_comment
+      elsif @scanner.check(TAG_START)
+        parse_tag
+      elsif !text_end?
+        parse_text
+      else
+        parse_error('Invalid HTML struct')
+      end
+    end
+
+    def parse_dtd
+      node = scan(DTD)
+      DTDElement.new(@scanner[2], @scanner[1], node.position)
+    end
+
+    def parse_comment
+      scan COMMENT
+      CommentElement.new(@scanner[1])
+    end
+
+    def parse_text
+      text = ''
+      until text_end? do
+        text << '<' if @scanner.skip(/</)
+        text << "#{@scanner.scan(TEXT)}"
+
+        # TODO: make this detection a rule
+        parse_warn "'#{$~}' not escaped" if text =~ /<|>/
+      end
+      TextElement.new text
+    end
+
+    def parse_tag
+      if @scanner.check DTD
+        parse_dtd_tag
+      elsif @scanner.check SELF_CLOSE_TAG
+        parse_self_ending_tag
+      elsif @scanner.check TAG
+        parse_normal_tag
+      else
+        parse_error('Invalid HTML struct')
+      end
+    end
+
+    def parse_properties
+      skip_empty
+      props = []
+      until prop_search_done? do
+        prop = parse_property
+        props << prop if prop
+        skip_empty
+      end
+      props
+    end
+
+    def parse_property
+      name = parse_prop_name
+      if @scanner.check( /\s*=/ )
+        skip /[=]/
+        sep = @scanner.check(/['"]/)
+        value = parse_prop_value
+      end
+      Property.new name, value, sep
+    end
+
+    def parse_prop_name
+      scan PROP_NAME
+    end
+
+    def parse_prop_value
+      scan PROP_VALUE
+      "#{@scanner[1]}#{@scanner[2]}#{@scanner[3]}"
+    end
+
+    protected
+    def prop_search_done?
+      @scanner.check(/\/>|>/) or @scanner.eos?
+    end
+
+    def parse_normal_tag
+      skip /</
+      tag, prop = scan(TAG_NAME), parse_properties
+      @parsing_script = tag =~ /^script$/i
+      skip />/
+
+      scopes << tag.text
+
+      children = []
+      ending = nil
+      begin
+        end_tag = %r(<#{tag.text.sub(/^(?!=\/)/, '\/')}>)i
+      rescue
+        raise ::XRay::ParseError.new("invalid tag name: #{tag.text}", scanner_pos)
+      end
+
+      if auto_close?(tag.text) and !@scanner.check(end_tag)
+        close_type = :none
+      else
+        until @scanner.check(TAG_END) or @scanner.eos? do
+          child = parse_element
+          children << child if child
+        end
+        begin
+          ending = scan(end_tag).text
+          close_type = :after
+        rescue => e
+          close_type = :none
+          raise e
+        end
+      end
+      @parsing_script = false
+
+      scopes.pop
+
+      el = Element.new(tag, prop, children, close_type, ending)
+      el.scopes = scopes.dup
+      el
+    end
+
+    def scopes
+      @scopes ||= []
+    end
+
+    def parse_dtd_tag
+      scan DTD
+    end
+
+    def parse_self_ending_tag
+      skip /</
+      tag = scan(TAG_NAME)
+      prop = parse_properties
+      skip /\/>/
+      el = Element.new(tag, prop, [], :self)
+      el.scopes = scopes.dup
+      el
+    end
+
+    def auto_close?(tag)
+      XRay::HTML::AUTO_CLOSE_TAGS.include?(tag.to_s.downcase)
+    end
+
+    def text_end?
+
+      return true if @scanner.eos?
+
+      if @parsing_script
+        @scanner.check(/<\/script\s*>/)
+      else
+        @scanner.check(%r(#{TAG}|#{SELF_CLOSE_TAG}|#{TAG_END}|#{COMMENT}))
+      end
+    end
+
+  end
+
+
+end; end
+
+if __FILE__ == $0
+  XRay::HTML::Parser.parse(%q(<div class="info" checked>information</div>)) { |e| puts e.outer_html }
+  XRay::HTML::Parser.parse(%q(<img width="100" height='150' id=img > <center>text</center>)) { |e| puts e.first.outer_html }
+  XRay::HTML::Parser.parse(%q(<center><div><div><center>text</center></div></div></center>)) { |e| puts e.outer_html }
+  XRay::HTML::Parser.parse(%q(<center ns:name="value"><div><div><center>text</center></div></div></center>)) { |e| puts e.outer_html }
+  begin; XRay::HTML::Parser.parse(%q(<center><div></center></div>)) { |e| puts e.outer_html }; rescue; end
+  XRay::HTML::Parser.parse('<br/>') { |e| puts e.outer_html }
+end