fdlint 0.1.3 → 0.2.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d9d6d40f7557d99e016ca0dfe7949ff1fa69d856
+  data.tar.gz: 558d82918d7b4f6e1b4901fa69201e5e7539056d
+SHA512:
+  metadata.gz: 50b3ac1298038655d9fd0a89295f22d865780f79528f9b77ed65f47d967ee07d13aa1ecb2d156b53ffc82db4939c94660bdb1c02191232b024138ad4e27333e6
+  data.tar.gz: 3f44299dbd47fdca59e2dbe0c5b6769f287bd20d865338f40669d41540479e4c024f2cd5b39a48e9958040e3daee29f32b46f04e5df248e0efd8331e80f74051

data/Gemfile

@@ -1,9 +1,2 @@
-source "https://rubygems.org"
-
-gem 'win32console', platform: :mswin
-
-group :development do
-  gem 'test-unit'
-  gem 'rake'
-  gem 'gem-this'
-end
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -1,15 +1,25 @@
+PATH
+  remote: .
+  specs:
+    fdlint (0.2.0.pre)
+      colored (~> 1.2)
+      gli (~> 2.9.0)
+      string_utf8 (~> 0.1.1)
+
 GEM
   remote: https://rubygems.org/
   specs:
-    gem-this (0.3.7)
+    colored (1.2)
+    gli (2.9.0)
     rake (0.9.2.2)
+    string_utf8 (0.1.1)
     test-unit (2.4.8)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  gem-this
-  rake
+  bundler
+  fdlint!
+  rake (~> 0.9.2.2)
   test-unit
-  win32console

data/Rakefile

@@ -1,92 +1,16 @@
-task :default => [:test]
+require 'rake/clean'
+require 'rubygems'
+require 'rubygems/package_task'
 
-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.3"
-  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"
+spec = eval(File.read('fdlint.gemspec'))
 
-  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"
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
 end
 
-desc 'Clear out RDoc and generated packages'
-task :clean => [:clobber_rdoc, :clobber_package] do
-  rm "#{spec.name}.gemspec"
-end
+task :default => [:test,:features]

data/bin/fdlint

@@ -1,14 +1,77 @@
 #!/usr/bin/env ruby
+require 'gli'
+begin # XXX: Remove this begin/rescue before distributing your app
+require 'fdlint'
+require 'fdlint/cli'
+rescue LoadError
+  STDERR.puts "In development, you need to use `bundle exec bin/fdlint` to run your app"
+  STDERR.puts "At install-time, RubyGems will make sure lib, etc. are in the load path"
+  STDERR.puts "Feel free to remove this message from bin/fdlint now"
+  exit 64
+end
+
+include GLI::App
+
+program_desc 'Code reviewer for web developing. Check your HTML/JS/CSS codes against bad smells.'
+
+version Fdlint::VERSION
+
+desc 'Print debug logs'
+switch [:d, :debug], negatable: false
+
+desc "review codes"
+arg_name 'path'
+command [:review, :check] do |c|
+
+  %w(css js html).each do |type|
+    c.desc "check #{type} files only" 
+    c.switch type.intern, negatable: false
+  end
+
+  c.desc "output format. Can be 'vim', 'console' or 'nocolor'."
+  c.default_value :console
+  c.flag :format, must_match: %w[console nocolor vim]
 
-unless Kernel.respond_to?(:require_relative)
-  module Kernel
-    def require_relative(path)
-      require File.expand_path(path.to_str, File.dirname(caller[0]))
+  c.desc "ignore minified files"
+  c.default_value false
+  c.switch [:m, :"ignore-min"], negatable: false
+
+  c.desc "shortcut for '--format=list'"
+  c.switch [:l, :list], negatable: false
+
+  c.desc "charset for reading files"
+  c.default_value 'utf-8'
+  c.flag [:c, :charset]
+
+  c.desc "the log level for filter results"
+  c.default_value 'warn'
+  c.flag [:loglevel], must_match: %s[warn error faltal]
+
+  c.action do |global, opt, args|
+
+    if args.empty?
+      if $stdin.tty?
+        help_now! 'files required'
+      else
+        source = ARGF.read
+      end
     end
+
+    options = {
+
+      :log_level => opt[:loglevel],
+      :format    => opt[:list] ? :nocolor : opt[:format],
+      :encoding  => opt[:encoding],
+      :syntax    => opt[:css]  ? :css :
+                    opt[:js]   ? :js  :
+                    opt[:html] ? :html : nil,
+      :debug     => global[:debug],
+      :files     => args,
+      :text      => source
+    }
+
+    Fdlint::CLI.run options
   end
 end
 
-require_relative '../lib/cmd_runner'
-
-trap("SIGINT") { puts "\nGoodbye!"; exit! }
-XRay::CMDRunner.run
+exit run(ARGV)

data/lib/fdlint/cli.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'find'
+require 'logger'
+require 'fdlint/printer'
+require 'fdlint/printer/vim_printer'
+require 'fdlint/printer/nocolor_printer'
+require 'fdlint/printer/console_printer'
+
+module Fdlint
+
+  module CLI
+
+    def self.run( options )
+      Runner.new( options ).run
+    end
+
+    class Runner
+
+      attr_reader :options, :files
+
+      def initialize( options={} )
+        @options = options
+        @files   = options[:files]
+      end
+
+      def run
+        # Windows 下默认是ANSI编码
+        # 我们需要使用 UTF-8 编码输出
+        IO.popen "chcp 65001" if ENV['OS'] =~ /windows/i
+
+        $logger = Logger.new(STDOUT).tap do |l|
+          l.level = options[:debug] ? Logger::DEBUG : Logger::FATAL
+        end
+
+        trap("SIGINT") { puts "\nGoodbye!"; exit! }
+
+        if text = @options[:text]
+          validate_content
+        elsif !@files.empty?
+          validate_files
+        end
+      end
+
+      protected
+
+        def validate_content
+          opt_for_validator = {
+            :code_type  => options[:code_type],
+            :text       => options[:text]
+          }
+          ::Fdlint::Validator.new( nil, opt_for_validator ).validate do |file, source, results|
+            printer.print( file, source, results )
+          end
+        end
+
+        def validate_files
+          files.each do |file|
+            validate_path file do |file, source, results|
+              printer.print( file, source, results )
+            end
+          end
+        end
+
+        def validate_path( path, &block )
+          if File.directory? path
+            validate_directory path
+          else
+            validate_file path
+          end
+        end
+
+        def validate_directory( dir )
+          Find.find dir do |f|
+            validate_file f unless File.directory? f
+          end
+        end
+
+        def validate_file( path )
+          ::Fdlint::Validator.new( path ).validate do |file, source, results|
+            printer.print( file, source, results )
+          end
+        end
+
+      private
+
+        def printer
+          @printer ||= printer_for( @options[:format] )
+        end
+
+        def printer_for format
+          mapping = {
+            :console => ::Fdlint::Printer::ConsolePrinter.new,
+            :nocolor => ::Fdlint::Printer::NoColorPrinter.new,
+            :vim     => ::Fdlint::Printer::VimPrinter.new
+          }.tap {|hash| hash.default = hash[:console] }
+          mapping[format]
+        end
+
+    end
+  end
+end

data/lib/fdlint/helper/code_type.rb

@@ -0,0 +1,55 @@
+module Fdlint
+  module Helper
+
+    class CodeType
+
+      class << self
+
+        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 html? text
+          return :css   if css? text
+          :js #TODO: support more code syntaxes
+        end
+
+        def style_file?(filename)
+          File.extname( filename ) =~ /(css|js|html?)$/i
+        end
+
+        def scope(filename)
+          filename =~ /[\\\/]lib[\\\/]/ ? 'lib' : 'page'
+        end
+
+        private
+
+          def html?(text)
+            /^\s*</m =~ text
+          end
+
+          def css?(text)
+            /^\s*@/m =~ text or /^\s*([-\*:\.#_\w]+\s*)+\{/ =~ text
+          end
+
+      end
+
+    end
+  end
+end

data/lib/fdlint/helper/file_reader.rb

@@ -0,0 +1,19 @@
+require 'string/utf8'
+
+module Fdlint
+  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={})
+        bin = File.read(path).utf8!
+        raise EncodingError.new unless bin.valid_encoding?
+        bin
+      end
+
+    end
+  end
+end

data/lib/fdlint/helper/logger.rb

@@ -0,0 +1,35 @@
+require 'logger'
+
+module Fdlint; module Helper
+
+  # Public: Module Logger handles the in-application
+  #         runtime logging. It helps user inspect
+  #         details of application running.
+  module Logger
+
+    LEVELS = [:debug, :info, :warn, :error, :fatal]
+
+    # Public: log message with specificated log level
+    #
+    # msg   - the message text to log
+    # level - debug / info / warn / error / fatal
+    #
+    # Returns nil
+    def log( msg, level = :info )
+      level = :info unless LEVELS.include?( level )
+      send level, msg
+    end
+
+    LEVELS.each do |method|
+      define_method method do |*args, &block|
+        logger.send method, *args, &block
+      end
+    end
+
+    def logger
+      $logger ||= ::Logger.new(STDOUT)
+    end
+
+  end
+
+end; end

data/lib/fdlint/log_entry.rb

@@ -0,0 +1,51 @@
+require 'colored'
+
+module Fdlint
+
+  class LogEntry < Struct.new(:message, :level, :row, :column)
+
+    attr_accessor :validation
+
+    def initialize(message, level, row = 0, colmn = 0)
+      super
+    end
+
+    def to_s
+      "[#{level.to_s.upcase}] #{pos} #{message}"
+    end
+
+    def pos
+      row.nil? ? "" : "[#{row},#{column}]"
+    end
+
+    def error?
+      level == :error
+    end
+
+    def warn?
+      level == :warn
+    end
+
+    def fatal?
+      level == :fatal
+    end
+
+    def info?
+      level == :info
+    end
+
+    def desc
+      validation && validation.long_desc
+    end
+
+
+  end
+
+  class InvalidFileEncoding < LogEntry
+    def initialize
+      super "文件编码错误，无法正常读取", :fatal
+    end
+  end
+
+
+end

data/lib/fdlint/parser/base_parser.rb

@@ -0,0 +1,151 @@
+require 'fdlint/parser/node'
+require 'fdlint/parser/parse_error'
+require 'fdlint/parser/position_info'
+require 'strscan'
+
+module Fdlint
+
+  module Parser
+    
+    class BaseParser
+
+      include ::Fdlint::Helper::Logger
+
+      attr_reader :source
+
+      def initialize(text)
+        @source    = text
+        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 scanner_pos
+        pos = @text_size - @scanner.rest.size
+        @pos_info.locate 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
+
+      def scanned_source
+        pos = @text_size - @scanner.rest.size
+        source[0..(pos-1)]
+      end
+
+      def rest_source
+        @scanner.rest
+      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
+        
+      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
+end