fdlint 0.1.0

data/lib/html/query.rb

@@ -0,0 +1,96 @@
+require 'strscan'
+
+module XRay
+  module HTML
+    
+    class Element
+      
+      WORD = /[A-Za-z][-_\w]*/
+      CLASS = %r(\.#{WORD})
+      ID = %r(##{WORD})
+      PROP_PAIR = %r(\s*,?\s*#{WORD}(==[^\s,])?)
+      PROP = %r(\[#{WORD}.*?\])
+
+      ###
+      # This method implemented CSS selector for
+      # HTML (like Sizzle) very simply. It is not
+      # fully supported CSS selector.
+      #
+      # TODO: support full CSS3 selector
+      ###
+      def match?(str)
+        return false if is_a?(TextElement)
+        obj = query_obj(str)
+        tag = obj[:tag]
+        cls = obj[:classes]
+        props = obj[:properties]
+        unless tag.nil? or tag_name_equal? tag
+          return false
+        end
+        classes = prop_value(:class)
+        cls.each { |c| return false unless classes.include? c }
+        props.each do |n, v|
+          if v.nil?
+            return false unless has_prop? n
+          else
+            return false unless prop_value(n) == v
+          end
+        end
+        true
+      end
+
+      alias_method :===, :match?
+
+      private
+      def query_obj(str)
+        classes = []
+        props = {}
+        sc  = StringScanner.new(str)
+        tag = sc.scan WORD
+        if sc.check ID
+          sc.skip /#/
+          id  = sc.scan WORD
+        end
+        while sc.check CLASS
+          sc.skip /\./
+          classes << (sc.scan WORD)
+        end
+        if sc.check PROP
+          sc.skip /\[/
+          while sc.check PROP_PAIR
+            sc.skip /\s*/
+            sc.skip /,/
+            sc.skip /\s*/
+            prop = sc.scan WORD
+            sc.skip /\==/
+            sc.skip /['"]/
+            value = sc.scan /[^\]]+/
+            props[prop] = value
+          end
+          sc.skip /\]/
+        end
+        props["id"] = id if id
+        {:tag => tag, :classes => classes, :properties => props }
+      end
+
+      public
+      def query( selector, &block )
+        ret = []
+        if match?(selector)
+          ret << self 
+          yield self if block_given?
+        end
+
+        children && children.each do |node|
+          ret += node.query(selector, &block)
+        end
+
+        ret
+      end
+      
+      alias_method :*, :query
+
+    end
+
+  end
+end

data/lib/html/rule/check_tag_rule.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+require_relative '../../rule'
+require_relative '../struct'
+require_relative '../query'
+require_relative '../../context'
+
+module XRay
+  module HTML
+    module Rule
+
+      class CheckTagRule
+
+        include ::XRay::Rule, Context
+
+        attr_reader :imported_scripts, :imported_css
+
+        def initialize(opt=nil)
+          @imported_scripts, @imported_css = [], []
+        end
+
+        def script_used?( src )
+          @imported_scripts.include? src
+        end
+
+        def style_used?( src )
+          @imported_css.include? src
+        end
+
+        def visit_doc(html)
+          check_html_doc html
+        end
+
+        def visit_dtd(dtd)
+          @have_dtd = true
+          check_html_dtd dtd
+        end
+
+        def visit_tag(tag)
+          results = check_html_tag tag
+          record_script(tag) or record_style(tag)
+          results
+        end
+
+        def visit_text(tag)
+          check_html_text tag
+        end
+
+        def visit_property(prop)
+          check_html_property prop
+        end
+
+        def record_script( tag )
+          if tag.tag_name_equal? 'script'
+            src = tag.prop_value(:src).to_s
+            unless src.empty? or script_used? src
+              @imported_scripts << src
+            end
+          end
+        end
+
+        def record_style( tag )
+          if tag.tag_name_equal? 'link' and tag.prop_value(:rel) =~ /stylesheet/i
+            src = tag.prop_value(:href).to_s
+            unless src.empty? or style_used? src
+              @imported_css << src
+            end
+          end
+        end
+
+        def has_dtd?
+          @have_dtd
+        end
+
+        alias_method :have_dtd?, :has_dtd?
+
+      end
+
+    end
+  end
+end

data/lib/html/struct.rb

@@ -0,0 +1,291 @@
+require_relative '../node'
+
+module XRay
+  module HTML
+
+    Node = XRay::Node
+    AUTO_CLOSE_TAGS = %w(area base basefont br col frame hr img input link meta param) 
+    INLINE_ELEMENTS = %w(a br label abbr legend address link 
+                         area mark audio meter bm nav cite optgroup 
+                         code option del q details small dfn select 
+                         command source datalist span em strong 
+                         font sub i summary iframe sup img tbody 
+                         input td ins time kbd var)
+
+    class Element < Node
+
+      attr_reader :tag, :props, :children
+      attr_accessor :parent, :close_type, :ending, :scopes
+
+      def initialize(tag, props=[], children=[], close_type=:after, ending=nil)
+        @tag, @props, @children, @close_type, @ending = tag, to_props(props), Array.[](children).flatten || [], close_type, ending
+        @position = @tag.position.dup if tag.is_a?(Node) and tag.position
+        @children.each { |el| el.parent = self }
+        @scopes = []
+      end
+
+      def has_scope?
+        !(parent.nil? and @scopes.empty?)
+      end
+
+      def in_scope?(scp)
+        if parent
+          parent.tag_name_equal? scp
+        else
+          scopes.include?(scp)
+        end
+      end
+
+      def text
+        children.inject("") do |s,child|
+          s + child.text
+        end
+      end
+
+      def tag_name
+        @tag.is_a?(Node) ? @tag.text : @tag.to_s
+      end
+
+      def tag_name_equal?(name)
+        tag_name.downcase == name.downcase
+      end
+
+      def inner_html
+        @children.inject('') { |s,c| s + c.outer_html }
+      end
+
+      def outer_html
+        if children.empty?
+          "<#{@tag}#{prop_text} />"
+        else
+          cls = ending || "</#{@tag}>"
+          "<#{@tag}#{prop_text}>#{inner_html}#{cls}"
+        end
+      end
+
+      def inner_text
+        @children.inject('') { |s,c| s + c.inner_text }
+      end
+
+      alias_method :text, :inner_text
+
+      def prop_text
+        props.inject('') { |s, p| s << " " << p.to_s }
+      end
+
+      def ==(other)
+        other.is_a?(Element) and tag_name == tag_name.to_s && prop_text == other.prop_text && inner_html == other.inner_html
+      end
+
+      def has_prop?(name)
+        @props.any? { |p| p.name_equal? name }
+      end
+
+      def prop(name)
+        @props.find { |p| p.name_equal? name }
+      end
+
+      def prop_value(*arg)
+        name, value = *arg
+        if arg.size > 1
+          unless @props.find { |p| p.value = value if p.name_equal? name }
+            @props << Property.new(name, value) 
+          end
+          nil
+        else
+          p = prop(name)
+          p.value if p
+        end
+      end
+
+      def to_s
+        "[HTML: #{outer_html}]"
+      end
+
+      def inline?
+        INLINE_ELEMENTS.include? tag_name.downcase
+      end
+
+      def auto_close?
+        AUTO_CLOSE_TAGS.include? tag_name.downcase
+      end
+
+      def closed?
+        @close_type != :none
+      end
+
+      def self_closed?
+        @close_type == :self
+      end
+
+      def each(&block)
+        children.each {|node| yield node }
+      end
+
+      def empty?
+        false
+      end
+
+      protected
+      def parse(text)
+        @outer_html = text
+      end
+
+      private
+
+      def to_props(src)
+        case src
+          when Array
+            src
+          when Hash
+            src.map do |n, v|
+              Property.new(n, v)
+            end
+          else
+            []
+          end
+      end
+
+    end
+
+
+    class Document < Element
+      def initialize( children=[] )
+        super(nil, {}, children || [])
+        @position = Position.new(0,0,0)
+      end
+
+      def ==(other)
+        if other.is_a?(Array)
+          return children == other
+        elsif other.is_a?(Document)
+          return children == other.children
+        else
+          super
+        end
+      end
+
+      def empty?
+        children.empty?
+      end
+
+    end
+
+    class TextElement < Element
+
+      def initialize(text="")
+        super(nil)
+        @text = text.to_s
+      end
+
+      def text; @text; end
+      def tag_name; nil; end
+
+      alias_method :inner_text, :text
+      alias_method :inner_html, :text
+      alias_method :outer_html, :text
+
+      def ==(other)
+        text == other.text
+      end
+
+      def tag_name_equal?(name); false; end
+      def inline?; true; end
+      def auto_close? ; false; end
+      def closed? ; true; end
+
+      def to_s
+        "[TEXT: #{text}]"
+      end
+
+    end
+
+
+    class CommentElement < Element
+      def initialize(text)
+        super(nil)
+        @text = text.to_s
+      end
+
+      def content; @text; end
+      def tag_name; nil; end
+
+      alias_method :inner_text, :text
+      alias_method :inner_html, :text
+      
+      def outer_html
+        "<!--#{text}-->"
+      end
+
+      def ==(other)
+        text == other.text
+      end
+
+      def tag_name_equal?(name); false; end
+      def inline? ; true; end
+      def auto_close? ; false; end
+      def closed? ; true; end
+
+      def to_s
+        "[Comment: #{text}]"
+      end
+
+    end
+
+    class DTDElement < Element
+
+      attr_accessor :type
+
+      def initialize(type, pre="DOCTYPE", pos=nil)
+        @type, @pre = type, pre
+        @position   = pos || Position.new(0,0,0)
+      end
+
+      def to_s
+        "<!#{@pre} #{type}>"
+      end
+
+      def inline?
+        true
+      end
+
+      alias_method :outer_html, :to_s
+
+      def ==(other)
+        other.is_a?(DTDElement) and other.type == type
+      end
+
+      def =~(other)
+        to_s =~ other
+      end
+
+    end
+
+    class Property < Node
+
+      attr_reader :name, :sep
+      attr_accessor :value
+
+      def initialize(name, value, sep='"')
+        @name, @value, @sep = name, value, sep
+      end
+
+      def position; name.position; end
+
+      def name_equal?(text)
+        @name.to_s.downcase == text.to_s.downcase
+      end
+
+      def to_s
+        if value.nil?
+          name.to_s
+        else
+          "#{name}=#{sep}#{value}#{sep}"
+        end
+      end
+
+    end
+
+
+  end
+end

data/lib/js/expr/expr.rb

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

data/lib/js/expr/left_hand.rb

@@ -0,0 +1,63 @@
+module XRay
+  module JS
+    module Expr
+      
+      module LeftHand
+        
+        def parse_expr_lefthand
+          log 'parse expr lefthand'
+          expr = check(/new\b/) ? parse_expr_new : parse_expr_member
+          expr.left_hand = true
+          expr 
+        end 
+
+        def parse_expr_new
+          log 'parse expr new'
+
+          pos = skip /new/
+          expr = check(/new\b/) ? parse_expr_new : parse_expr_member
+          args = check(/\(/) ? parse_arguments_list : nil
+
+          create_element Expression, 'new', expr, args, pos
+        end
+
+        def parse_expr_member
+          log 'parse expr member'
+          parse_expr_with_operate(:parse_expr_member_left) do
+            if check /[.]/
+              skip /[.]/
+              ['.', parse_expr_identifier]
+            elsif check /[\[]/
+              skip /\[/
+              expr = parse_expression
+              skip /\]/
+              ['[', expr]
+            elsif check /\(/
+              ['(', parse_arguments_list]
+            end
+          end
+        end
+
+        protected
+
+        def parse_expr_member_left
+          if check /function\b/
+            create_element FunctionExpression, parse_function_declaration(true)
+          else
+            parse_expr_primary
+          end 
+        end
+
+
+        def parse_arguments_list
+          log 'parse arguments list'
+          skip /\(/
+          params = batch :parse_expr_assignment, /\)/, /,/
+          skip /\)/
+          Elements.new params
+        end
+
+      end
+    end
+  end
+end

data/lib/js/expr/operate.rb

@@ -0,0 +1,92 @@
+module XRay
+  module JS
+    module Expr
+      
+      module Operate
+     
+        def parse_expr_postfix
+          log 'parse expr postfix'
+          expr = parse_expr_lefthand
+          if check(/[ \t]*(?:\+\+|--)/, true)
+            op = scan /\+\+|--/
+            expr = create_element Expression, op.text, expr
+          end
+          expr
+        end
+
+        def parse_expr_unary
+          log 'parse expr unary'
+          r = /delete|void|typeof|\+\+|--|\+|-|~|!/
+          if check r
+            op = scan r
+            create_element Expression, op.text, nil, parse_expr_unary
+          else
+            parse_expr_postfix
+          end
+        end
+
+        def parse_expr_mul
+          log 'parse expr mul'
+          parse_expr_with_operate :parse_expr_unary, /(?:\*|\/|%)(?!=)/
+        end
+
+        def parse_expr_add
+          log 'parse expr add'
+          parse_expr_with_operate :parse_expr_mul, /(?:\+|-)(?!=)/
+        end
+
+        def parse_expr_shift
+          log 'parse expr shift'
+          parse_expr_with_operate :parse_expr_add, /(?:<<|>>>|>>)(?!=)/
+        end
+
+        def parse_expr_relation
+          not_in = expr_operate_not_in?
+          log "parse expr relational#{not_in ? '(notin)' : ''}"
+          pattern = not_in ? (/>=|<=|>|<|\binstanceof\b/) : (/>=|<=|>|<|\binstanceof\b|\bin\b/)
+          parse_expr_with_operate :parse_expr_shift, pattern 
+        end
+
+        def parse_expr_equal
+          log 'parse expr equal'
+          parse_expr_with_operate :parse_expr_relation, /===|!==|==|!=/
+        end
+
+        def parse_expr_bit_and
+          log 'parse expr bit and'
+          parse_expr_with_operate :parse_expr_equal, /&(?![&=])/
+        end
+
+        def parse_expr_bit_xor
+          log 'parse expr bit xor'
+          parse_expr_with_operate :parse_expr_bit_and, /\^(?!=)/
+        end
+
+        def parse_expr_bit_or
+          log 'parse expr bit or'
+          parse_expr_with_operate :parse_expr_bit_xor, /\|(?![|=])/
+        end
+
+        def parse_expr_logical_and
+          log 'parse expr logical and'
+          parse_expr_with_operate :parse_expr_bit_or, /&&/
+        end
+
+        def parse_expr_logical_or
+          log 'parse expr logical or'
+          parse_expr_with_operate :parse_expr_logical_and, /\|\|/
+        end
+
+        def expr_operate_not_in?
+          @operate_not_in || false
+        end
+
+        def expr_operate_not_in=(value)
+          @operate_not_in = !!value
+        end
+        
+      end
+
+    end
+  end
+end