fuzzr 0.9.6

data/lib/fuzz/fuzzers/check_whitespace.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+# -------------------------------------------------------------------
+# check_whitespace.rb - TAOX11 whitespace checker
+#
+# Author: Martin Corino
+#
+# Copyright (c) Remedy IT Expertise BV
+# -------------------------------------------------------------------
+
+module Fuzzers
+  class WhitespaceChecker
+    include Fuzz::Fzzr
+    def initialize
+      @fuzz_id = :check_whitespace
+      @description = 'checks for trailing whitespace, incorrect line endings and tabs'
+    end
+
+    def setup(optparser)
+      optparser.on('--wsc:tab-spacing=NUM', Integer,
+                   'Fuzzers::WhitespaceChecker - defines tab spacing to use for TAB replacement when --apply-fix is enabled.',
+                   "Default: #{tab_spacing}") {|v| self.options[:tabspacing] = v }
+    end
+
+    def applies_to?(object)
+      Fuzz::FileObject === object && !is_excluded?(object)
+    end
+
+    def run(object, apply_fix)
+      _tws = []
+      _tabs = []
+      object.iterate(fuzz_id) do |lnptr|
+        if lnptr.text =~ /(\s\n|[\ \t\f\r\x0B])\Z/
+          if apply_fix
+            Fuzz.log_verbose(%Q{#{object.path}:#{lnptr.line_nr} - stripping trailing whitespace})
+            lnptr.text.rstrip!
+            lnptr.text << "\n" if $1.end_with?("\n")
+          else
+            _tws << lnptr.line_nr
+          end
+        end
+        if lnptr.text =~ /\t/
+          if apply_fix
+            Fuzz.log_warning(%Q{#{object.path}:#{lnptr.line_nr} - replacing tabs})
+            lnptr.text.gsub!(/\t/, ' ' * tab_spacing)
+          else
+            _tabs << lnptr.line_nr
+          end
+        end
+      end
+      Fuzz.log_error(%Q{#{object.path}:[#{_tws.join(',')}] trailing whitespace or incorrect line ending detected}) unless _tws.empty?
+      Fuzz.log_error(%Q{#{object.path}:[#{_tabs.join(',')}] tab(s) detected}) unless _tabs.empty?
+      return (_tws.empty? && _tabs.empty?)
+    end
+
+  private
+    def tab_spacing
+      self.options[:tabspacing] || 2
+    end
+  end
+
+  Fuzz.register_fzzr(WhitespaceChecker.new)
+end

data/lib/fuzz/fzzr.rb

@@ -0,0 +1,258 @@
+# encoding: utf-8
+# -------------------------------------------------------------------
+# fuzzr.rb - TAOX11 Fuzzer bases
+#
+# Author: Martin Corino
+#
+# Copyright (c) Remedy IT Expertise BV
+# -------------------------------------------------------------------
+
+module Fuzz
+  ##
+  # Fuzzers are objects having the following readonly attributes:
+  #   #fuzz_id    : id of fuzzer (Symbol)
+  #   #description: (String)
+  #   #errormsg   : (String)
+  #
+  # and having the following methods:
+  #   #applies_to?(object)  : checks if the test applies to the object passed
+  #                           (Fuzz::DirObject or Fuzz::FileObject)
+  #   #run(object,apply_fix): runs the fzzr test on the object passed
+  #                           (Fuzz::DirObject or Fuzz::FileObject)
+  #                           when apply_fix == true Fuzzer is directed to
+  #                           attempt to fix any problems found (future)
+  #
+  # Fuzz::Fzzr is provided as a convenience Mixin for fuzzers
+  #
+  # Fuzzers can inspect the options passed to fuzz.rb by referencing Fuzz::OPTIONS
+  ##
+
+  module Fzzr
+    attr_reader :fuzz_id, :description, :errormsg
+
+    def applies_to?(object)
+      !is_excluded?(object)
+    end
+
+    def setup(optparser)
+    end
+
+    def run(object, apply_fix)
+      true
+    end
+
+    def is_excluded?(object)
+      # force excludes to be parsed
+      _excludes
+      # now examine
+      ((!_is_included?(object)) || _excludes.any? { |excl| (object.fullpath =~ /#{excl}/) })
+    end
+
+    def options
+      Fuzz::OPTIONS[:config][:fzzr_opts][self.fuzz_id] ||= {}
+    end
+
+    private
+
+    def _is_included?(object)
+      Fuzz::DirObject === object || _includes.empty? || _includes.any? { |incl| (object.fullpath =~ /#{incl}/) }
+    end
+
+    def _includes
+      @_includes ||= Fuzz.includes.dup
+    end
+
+    def _excludes
+      unless @_excludes
+        @_excludes = []
+        @_excludes.concat(Fuzz.excludes)
+        Fuzz::OPTIONS[:config][:fzzr_paths].each do |fzzrpath|
+          fzzr_excl_file = File.join(fzzrpath, "#{self.fuzz_id}.excludes")
+          if File.readable?(fzzr_excl_file)
+            lns = IO.readlines(fzzr_excl_file).collect { |l| l.strip }
+            @_excludes.concat(lns.select {|l| !(l.empty? || l[0] == '!') })
+            _includes.concat(lns.select {|l| !(l.empty? || l[0] != '!') }.collect {|l| l[1,l.size].strip })
+          else
+            false
+          end
+        end
+      end
+      @_excludes
+    end
+  end # Fzzr
+
+  class DirObject
+    attr_reader :path, :fullpath, :name, :ext
+    def initialize(path)
+      @path = path
+      @fullpath = File.expand_path(path)
+      @name = File.basename(path)
+      @ext = File.extname(path).sub(/^\./,'')
+    end
+
+    def changed?
+      false
+    end
+
+    def iterate(fzzr_id, &block)
+      # nothing to iterate over
+      true
+    end
+
+    def to_s
+      "Dir:#{path}"
+    end
+  end # DirObject
+
+  class FileObject
+    EXTS = [
+      'h', 'hxx', 'hpp', 'c', 'cc', 'cxx', 'cpp', 'H', 'C', 'inl', 'asm',
+      'rb', 'erb', 'pl', 'pm', 'py',
+      'idl', 'pidl',
+      'mwc', 'mpc', 'mpb', 'mpt', 'mpd',
+      'cdp', 'xml', 'conf', 'html',
+      'asc', 'adoc'
+      ]
+    FILES = [
+      'ChangeLog', 'README'
+      ]
+
+    def self.extensions
+      EXTS
+    end
+
+    def self.filenames
+      FILES
+    end
+
+    class LinePointer
+      attr_reader :err_lines
+
+      FZZR_ENABLE_RE = /X11_FUZZ\: enable ([^\s]+)/
+      FZZR_DISABLE_RE = /X11_FUZZ\: disable ([^\s]+)/
+
+      def initialize(lines, fzzr_id)
+        @lines = lines
+        @fzzr_id = fzzr_id.to_s
+        @err_lines = []
+        reset
+      end
+      def fzzr_disabled?
+        @fzzr_disabled
+      end
+      def line_nr
+        @line_nr+1
+      end
+      def text_at(offs)
+        ln = @line_nr+offs
+        if ln>=0 && ln<@lines.size
+          return @lines[ln]
+        end
+        nil
+      end
+      def set_text_at(offs, txt)
+        ln = @line_nr+offs
+        if ln>=0 && ln<@lines.size
+          return (@lines[ln] = txt)
+        end
+        nil
+      end
+      def text
+        text_at(0)
+      end
+      def text=(txt)
+        set_text_at(0, txt)
+      end
+      def move(offs)
+        if offs < 0
+          _backward(-offs) unless bof?
+        else
+          _forward(offs) unless eof?
+        end
+        self.line_nr
+      end
+      def reset
+        @line_nr = 0
+        @fzzr_disabled = false
+        _check_fzzr_escape
+      end
+      def to_eof
+        _forward(@lines.size - @line_nr)
+      end
+      def eof?
+        @line_nr >= @lines.size
+      end
+      def bof?
+        @line_nr <= 0
+      end
+      def mark_error(ln = nil)
+        @err_lines << (ln || (@line_nr+1))
+      end
+
+      private
+
+      def _forward(distance)
+        distance.times do
+          @line_nr += 1
+          break if eof?
+          _check_fzzr_escape
+        end
+      end
+
+      def _backward(distance)
+        distance.times do
+          break if bof?
+          @line_nr -= 1
+          _check_fzzr_escape(false)
+        end
+      end
+
+      def _check_fzzr_escape(forward = true)
+        begin
+          if FZZR_ENABLE_RE =~ @lines[@line_nr]
+            @fzzr_disabled = !forward if $1 == @fzzr_id
+          elsif FZZR_DISABLE_RE =~ @lines[@line_nr]
+            @fzzr_disabled = forward if $1 == @fzzr_id
+          end
+        rescue
+          Fuzz.log_error(%Q{ERROR: Exception while checking fzzr escapes in line #{@line_nr+1} - #{$!}\n#{@lines[@line_nr]}})
+          raise
+        end
+      end
+    end # LinePointer
+
+    attr_reader :path, :fullpath, :name, :ext, :lines
+
+    def initialize(path)
+      @path = path
+      @fullpath = File.expand_path(path)
+      @name = File.basename(path)
+      @ext = File.extname(path).sub(/^\./,'')
+      @lines = nil
+      @pointer = nil
+      @changed = false
+    end
+
+    def changed?
+      @changed
+    end
+
+    def iterate(fzzr_id, &block)
+      @lines ||= IO.readlines(fullpath)
+      lines_copy = @lines.collect {|l| l.dup }
+      pointer = LinePointer.new(@lines, fzzr_id)
+      begin
+        block.call(pointer) unless pointer.fzzr_disabled?
+        pointer.move(1)
+      end while !pointer.eof?
+      Fuzz.log_error(%Q{#{self.path}[#{pointer.err_lines.join(',')}] #{Fuzz.get_fzzr(fzzr_id).errormsg}}) unless pointer.err_lines.empty?
+      @changed |= (@lines != lines_copy)
+      lines_copy = nil
+      return pointer.err_lines.empty?
+    end
+
+    def to_s
+      "File:#{fullpath}"
+    end
+  end # FileObject
+end # Fuzz

data/lib/fuzz/log.rb

@@ -0,0 +1,97 @@
+#--------------------------------------------------------------------
+# @file    log.rb
+# @author  Martin Corino
+#
+# @brief   Fuzz logging support
+#
+# @copyright Copyright (c) Remedy IT Expertise BV
+#--------------------------------------------------------------------
+require 'fuzz/console'
+
+module Fuzz
+
+  #
+  # Default Reporting/Logging
+  #
+  class Reporter
+    def initialize(output = Fuzz::Console)
+      @output = output
+      klass = class << self; self; end
+      klass.__send__(:include, @output.colorizer_include)
+    end
+
+    attr_reader :output
+
+    def log_error(msg)
+      output.error_println 'Fuzz - ', red(bold 'ERROR'), ' : ', msg
+    end
+
+    def log_warning(msg)
+      output.error_println 'Fuzz - ', yellow(bold 'WARNING'), ' : ', msg
+    end
+
+    def log_info(msg)
+      output.println 'Fuzz - ', msg
+    end
+
+    def show_error(msg)
+      log_error(msg)
+    end
+
+    def show_warning(msg)
+      log_error(msg)
+    end
+
+    def show_msg(msg)
+      log(msg)
+    end
+  end
+
+  module LogMethods
+    def log_fatal(msg, rc=1)
+      Fuzz.reporter.log_error(msg)
+      exit rc
+    end
+
+    def log_error(msg)
+      Fuzz.reporter.log_error(msg)
+    end
+
+    def log_warning(msg)
+      Fuzz.reporter.log_warning(msg)
+    end
+
+    def log_info(msg)
+      Fuzz.reporter.log_info(msg)
+    end
+
+    def log(lvl, msg)
+      Fuzz.reporter.log_info(msg) if lvl <= verbosity
+    end
+
+    def show_error(msg)
+      Fuzz.reporter.show_error(msg)
+    end
+
+    def show_warning(msg)
+      Fuzz.reporter.show_warning(msg)
+    end
+
+    def show_msg(msg)
+      Fuzz.reporter.show_msg(msg)
+    end
+
+    def verbosity
+      Fuzz.verbosity
+    end
+
+    def verbose?
+      verbosity > 1
+    end
+
+    def silent?
+      verbosity < 1
+    end
+  end
+
+end # Fuzz

data/lib/fuzz/options.rb

@@ -0,0 +1,208 @@
+#--------------------------------------------------------------------
+# @file    options.rb
+# @author  Martin Corino
+#
+# @brief   Options module for fuzz
+#
+# @copyright Copyright (c) Remedy IT Expertise BV
+#--------------------------------------------------------------------
+
+require 'ostruct'
+require 'yaml'
+require 'fuzz/log'
+
+module Fuzz
+
+  FUZZRC = '.fuzzrc'
+  FUZZRC_GLOBAL = File.expand_path(File.join(ENV['HOME'] || ENV['HOMEPATH'] || '~', FUZZRC))
+
+  OPTIONS = OpenStruct.new
+
+  class << OPTIONS
+
+    include Fuzz::LogMethods
+
+    def options
+      self
+    end
+
+    class Config < OpenStruct
+
+      include Fuzz::LogMethods
+
+      def initialize(hash=nil)
+        super
+        @table = _merge(_defaults, @table)
+      end
+
+      def options
+        Fuzz.options
+      end
+
+      def merge(from)
+        _merge(@table, from)
+        self
+      end
+
+      def load(rcpath)
+        log(3, "Loading #{FUZZRC} from #{rcpath}")
+        _cfg = YAML.load(IO.read(rcpath))
+        log(4, "Read from #{rcpath}: [#{_cfg}]")
+        # handle automatic env var expansion in fzzr_paths
+        _cfg[:fzzr_paths] = (_cfg[:fzzr_paths] || []).collect do |p|
+          log(5, "Examining fzzr_path [#{p}]")
+          # for paths coming from rc files environment vars are immediately expanded and
+          p.gsub!(/\$([^\s\/]+)/) { |m| ENV[$1] }
+          log(6, "Expanded fzzr_path [#{p}]")
+          # resulting relative paths converted to absolute paths
+          if File.directory?(p)   # relative to working dir?
+            p = File.expand_path(p)
+          else                    # relative to rc location?
+            _fp = File.expand_path(File.join(File.dirname(rcpath), p))
+            log(4, "Ignoring invalid fuzzer search path #{p} configured in #{rcpath}") unless File.directory?(_fp)
+            p = _fp
+          end
+          log(4, "Adding fuzzer search path: #{p}")
+          p
+        end
+        merge(_cfg)
+      end
+
+      def save(rcpath)
+        File.open(rcpath, 'w') {|f| f << YAML.dump(@table) }
+      end
+
+      protected
+
+      def _defaults
+        {
+          :brix_paths => []
+        }
+      end
+
+      def _merge(to, from)
+        from.each_pair do |(k,v)|
+          k = k.to_sym
+          if to.has_key?(k)
+            case to[k]
+            when Array
+              to[k].concat v
+            when Hash
+              to[k].merge!(v)
+            when OpenStruct
+              _merge(to[k].__send__(:table), v)
+            else
+              to[k] = v
+            end
+          else
+            to[k] = v
+          end
+        end
+        to
+      end
+
+    end
+
+    protected
+
+    def _defaults
+      {
+        :verbose => (ENV['FUZZ_VERBOSE'] || 1).to_i,
+        :recurse => true,
+        :apply_fix => false,
+        :config => Config.new({
+          :follow_symlink => true,
+          :exts => [],
+          :filenames => [],
+          :excludes => [],
+          :add_files => false,
+          :fzzr_paths => [],
+          :fzzr_opts => {},
+          :fzzr_excludes => []
+        })
+      }
+    end
+
+    def _rc_paths
+      @rc_paths ||= []
+    end
+    def _loaded_rc_paths
+      @loaded_rc_paths ||= []
+    end
+
+    def _add_rcpath(path)
+      if _loaded_rc_paths.include?(File.expand_path(path))
+        log(3, "ignoring already loaded rc : #{path}")
+      else
+        log(3, "adding rc path : #{path}")
+        _rc_paths << path
+      end
+      _rc_paths
+    end
+
+    public
+
+    def reset
+      @table.clear
+      @table.merge!(_defaults)
+      _rc_paths.clear
+      _rc_paths << FUZZRC_GLOBAL
+      _loaded_rc_paths.clear
+      (ENV['FUZZRC'] || '').split(/:|;/).each do |p|
+        _add_rcpath(p)
+      end
+    end
+
+    def load_config
+      # first collect config from known (standard and configured) locations
+      _rc_paths.collect {|path| File.expand_path(path) }.each do |rcp|
+        log(3, "Testing rc path #{rcp}")
+        if File.readable?(rcp) && !_loaded_rc_paths.include?(rcp)
+          _cfg = Config.new.load(rcp)
+          self[:config].merge(_cfg)
+          _loaded_rc_paths << rcp
+        else
+          log(3, "Ignoring #{File.readable?(rcp) ? 'already loaded' : 'inaccessible'} rc path #{rcp}")
+        end
+      end
+      # now scan working path for any rc files unless specified otherwise
+      unless self[:no_rc_scan]
+        _cwd = File.expand_path(Dir.getwd)
+        log(3, "scanning working path #{_cwd} for rc files")
+        # first collect any rc files found
+        _rcpaths = []
+        begin
+          _rcp = File.join(_cwd, FUZZRC)
+          if File.readable?(_rcp) && !_loaded_rc_paths.include?(_rcp)
+            _rcpaths << _rcp
+          else
+            log(3, "Ignoring #{File.readable?(_rcp) ? 'already loaded' : 'inaccessible'} rc path #{_rcp}")
+          end
+          break if /\A(.:(\\|\/)|\.|\/)\Z/ =~ _cwd
+          _cwd = File.dirname(_cwd)
+        end while true
+        # now load them in reverse order
+        _rcpaths.reverse.each do |_rcp|
+          _cfg = Config.new.load(_rcp)
+          self[:config].merge(_cfg)
+          _loaded_rc_paths << _rcp
+        end
+      end
+      # lastly merge config specified by user on commandline
+      self[:config].merge(user_config)
+    end
+
+    def add_config(rcpath)
+      log_fatal("inaccessible rc path specified : #{rcpath}") unless File.readable?(rcpath)
+      _add_rcpath(rcpath)
+    end
+
+    def user_config
+      @user_config ||= Config.new
+    end
+
+  end # OPTIONS class
+
+  OPTIONS.reset # initialize
+
+end # Fuzz