rcheck 0.1.0

data/lib/rcheck/command.rb

@@ -0,0 +1,158 @@
+module RCheck
+  class Command
+    # Command definition dictionary that stores named definitions
+    DEFINITIONS = {}
+    # Command definitions not included in listings
+    HIDDEN      = []
+
+    class << self
+      # Return the currently running RCheck command.
+      # RCheck may only be invoked once during the life cycle
+      # of the running Ruby interpreter.
+      def active
+        @active || raise("tried to look up command outside command")
+      end
+
+      # Hide a named command definition from listings
+      def hide(*args)   HIDDEN.push(*args.flatten)        end
+      # Find and return a named command definition
+      def find(name)    DEFINITIONS[name]                 end
+      # Returns true if a command has been invoked
+      def active?()     !!@active                         end
+
+      # Sets the invoked command. Can only be done once.
+      def active=(inv)
+        @active && raise('already invoked')
+        @active = inv
+      end
+
+      # Defines a named command
+      def define(name, *args)
+        DEFINITIONS[name] = new(name, *args)
+      end
+
+      # Returns an array of available commands
+      def available
+        DEFINITIONS.values.reject { |c| HIDDEN.include? c.name }
+      end
+
+      # Invokes an RCheck command by expanding and using
+      # the given commands and options.
+      def invoke!(*args)
+        args << :_default if args.none? {|a| a.is_a? Symbol } 
+        new(nil, '(main)', *(args.unshift(:_base))).invoke!
+      end
+    end
+
+    attr_reader(*%i(name desc implied_commands config))
+
+    def initialize(name, desc, *args)
+      @name             = name  # if this is a named command definition
+      @desc             = desc  # help text
+      @implied_commands = []
+      @config           = {}
+      @cache            = {}
+      expand args
+    end
+
+    def suite()
+      RCheck[self[:suite]] ||
+        raise(Errors::NoSuchSuite, "no suite called #{self[:suite]}")
+    end
+
+    def read(param)
+      @config[param].tap {|v| return v unless v.nil? }
+      @implied_commands.reverse.each do |name|
+        inv = self.class.find(name) ||
+          raise(Errors::InvocationName,
+                "unknown invocation #{name.inspect}")
+        inv.read(param).tap {|v| return v unless v.nil? }
+      end; nil
+    end
+
+    def [](param)
+      @cache[param] ||= OptionExpander[param, read(param)]
+      if @cache[param].nil?
+        raise(Errors::ConfigName,
+              "no configuration called #{param.inspect}")
+      end; @cache[param] # TODO
+    end
+
+    def invoke!
+      self.class.active = self
+      require_initializers
+      dispatch
+    end
+
+    def dispatch
+      %i(pry how).each do |option|
+        return send option if Conf[option]
+      end
+      run_tests
+    end
+
+    def how
+      print 'Command chain: '
+      print implied_commands.map(&:inspect).join(', ')
+      puts  ' ' + @config.inspect
+      puts
+      Options.names.each do |name|
+        puts "  %15s: #{self[name]}" % [name.to_s]
+      end
+    end
+
+    def pry
+      require 'pry'
+      RCheck.binding.pry
+    end
+
+    def run_tests
+      Colors.cputs :quiet, Array(self[:headers]).map(&:call)
+      puts if self[:progress].any?
+      require_test_files
+      %i(progress report).each {|v| make_space v }
+      suite.report!
+      exit %i(pass pending).include?(suite.severity(:total)) ?
+        self[:success_code] : self[:fail_code]
+    end
+
+    private
+
+    def make_space(for_what)
+      puts if self[for_what].any? && suite.total(:all).any?
+    end
+
+    def expand(args)
+      args.each do |arg|
+        case arg
+        when Hash   then @config.merge! arg
+        when Symbol then @implied_commands << arg
+        else raise Errors::Argument, "unexpected #{arg.inspect}"
+        end
+      end
+    end
+
+    def expand_globs(glob_name, randomizer=nil)
+      Array(self[glob_name]).map do |glob|
+        Dir[glob].map do |file|
+          File.expand_path File.join(
+            File.dirname(file), File.basename(file, '.*'))
+        end
+      end.flatten
+    end
+
+    def require_globs(glob_name, randomizer=nil)
+      files = expand_globs(glob_name)
+      files.shuffle!(random: randomizer) if randomizer
+      files.each {|path| require path }
+    end
+
+    def require_test_files
+      require_globs(:files, Random.new(self[:seed]))
+    end
+
+    def require_initializers
+      require_globs(:initializers)
+    end
+  end
+end

data/lib/rcheck/conf.rb

@@ -0,0 +1,11 @@
+module RCheck
+  module Conf
+    def self.[](name)
+      Command.active[name]
+    end
+
+    def self.valid_name?(param)
+      !Command.find(:_base).read(param).nil?
+    end
+  end
+end

data/lib/rcheck/debugging.rb

@@ -0,0 +1,32 @@
+module RCheck
+  module Debugging
+    module SuiteMethods
+      def debug(*args)
+        verify_not_done!
+        unless @assertions.any?
+          raise Errors::NoAssertions, 'debugger without a preceding assertion'
+        end
+        @assertions.last.debuggers << Debugger.new(*args)
+      end
+    end
+
+    class Debugger
+      attr_reader(*%i(items backtrace))
+
+      def initialize(*items)
+        @items      = items
+        @backtrace  = Backtrace.parse caller(3)
+      end
+
+      def join
+        @items.map do |data|
+          data.is_a?(String) ? data : data.inspect
+        end.join(' ')
+      end
+
+      def location
+        @backtrace.first
+      end
+    end
+  end
+end

data/lib/rcheck/default_commands.rb

@@ -0,0 +1,29 @@
+module RCheck
+  Command.hide %i(_base _default)
+
+  define :_base, 'used as a base for all other commands', Options::BASE
+  define :_default, 'used when nothing else given', Options::DEFAULT
+
+  define :quiet, 'turn off all reporting and headers',
+    headers: [], progress: [], report: []
+
+  define :tree, 'show all suites in a tree',
+    :quiet, report: ReportPrinters::Tree.new(show: :all)
+
+  define :list, 'show list of problematic assertions',
+    :quiet, report: ReportPrinters::List.new(show: :problematic)
+
+  define :all, 'list all assertions',
+    :quiet, report: ReportPrinters::List.new(show: :all)
+
+  define :numbers, 'show assertion counts',
+    :quiet, report: 'numbers'
+
+  # define(:html,
+  #   progress_printers:  %i(),
+  #   report_printers:    %i(Html)
+  # )
+
+  define :itself, 'run RCheck\'s own test suite',
+    :_default, files: "#{RCheck.which}/tests/**/*.rb"
+end

data/lib/rcheck/dsl.rb

@@ -0,0 +1,25 @@
+
+module RCheck
+  module DSL
+    class Scope
+      def initialize(suite)
+        @__suite__ = suite
+      end
+      extend Forwardable
+      def_delegators(:@__suite__,
+                     *%i(suite assert refute assert_safe assert_raises debug pending))
+
+      def respond_to?(name)
+        super || @__suite__.parent && @__suite__.parent.scope.respond_to?(name)
+      end
+
+      def method_missing(*args)
+        if @__suite__.parent
+          @__suite__.parent.scope.send(*args)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rcheck/errors.rb

@@ -0,0 +1,36 @@
+
+module RCheck
+  module Errors
+
+    # abstract
+    class Base < RuntimeError; end
+    class State < Base; end
+    class Argument < Base; end
+    class Name < Argument; end
+
+    # invalid arguments for invocation
+    class InvocationName < Name; end
+
+    # invalid arguments for invocation
+    class NoSuchSuite < Name; end
+
+    # invalid configuration parameter name
+    class ConfigName < Name; end
+
+    # invalid configuration parameter name
+    class ConfigParam < Name; end
+
+    # Tried to do something that requires an invocation
+    class NoInvocation < State; end
+
+    # tried to redefine suite after printing
+    class SuiteRedefinition < State; end
+
+    # tried to require same test more than once
+    class ReRequire < State; end
+
+    # tried to do something that requires assertions to be defined
+    # before they were defined
+    class NoAssertions < State; end
+  end
+end

data/lib/rcheck/filters.rb

@@ -0,0 +1,21 @@
+module RCheck
+  module Filters
+    def self.port_regex(str)
+      Regexp.new(str.gsub("/", File::SEPARATOR))
+    end
+
+    InstalledGems = port_regex('/lib\d*/ruby/')
+    Executables   = port_regex('bin/')
+    Rcheck        = port_regex('lib/rcheck')
+    Jruby         = port_regex('org/jruby/')
+
+    def self.gem(name)
+      sep = File::SEPARATOR
+      /#{sep}#{name}(-[^#{sep}]+)?#{sep}/
+    end
+
+    module Anti
+      Cwd = Regexp.new(Dir.getwd)
+    end
+  end
+end

data/lib/rcheck/formatting.rb

@@ -0,0 +1,58 @@
+module RCheck
+  module Formatting
+    def self.truncate(*lines)
+      lines.map do |line|
+        if line.length < Conf[:max_cols]
+          line
+        else
+          msg = ".. [#{line.length} c]"
+          "#{line[0..(Conf[:max_cols] - msg.length)]}#{msg}"
+        end
+      end
+    end
+  end
+
+  class Formatter
+
+    def trunc_cols(*lines)
+    end
+
+    def trunc_rows(*lines)
+      if lines.count < max_rows
+        lines
+      else
+        first     = lines[0..(max_rows/2)]
+        last      = lines[(max_rows/2), -1]
+        removed   = lines.count - (first + last).count
+        first + ["< ! #{removed} lines removed... >"] + last
+      end
+    end
+
+    def trunc(*lines)
+      trunc_cols(*trunc_rows(*lines))
+    end
+
+    def indent_with_opts(margin, bullet, bullet_all, *lines)
+      pad         = ' ' * margin
+      bullet_pad  = (' ' * (margin - 3)) + " #{bullet} "
+      result = []
+      result << bullet_pad + lines.shift if lines.any?
+      lines.each do |line|
+        result << (bullet_all ? bullet_pad : pad) + line
+      end
+      result
+    end
+
+    def format_with_bullet(margin, bullet, *lines)
+      trunc indent_with_opts(margin, bullet, false, *lines)
+    end
+
+    def format_with_bullets(margin, bullet, *lines)
+      trunc indent_with_opts(margin, bullet, true, *lines)
+    end
+
+    def format(margin, *lines)
+      trunc indent_with_opts(margin, ' ', false, *lines)
+    end
+  end
+end

data/lib/rcheck/headers.rb

@@ -0,0 +1,24 @@
+require 'date'
+
+module RCheck
+  module Headers
+    class Rcheck
+      def call
+        [RCheck.version, "#{Date.today.to_s} seed: #{Conf[:seed]}"]
+      end
+    end
+
+    class Platform
+      def call() "#{RUBY_PLATFORM}" end
+    end
+
+    class Commit
+      def call() [cwd_commit_hash].compact end
+
+      def cwd_commit_hash
+        path = File.expand_path File.join(*%w(.git refs heads master))
+        File.read(path).chomp if File.file? path
+      end
+    end
+  end
+end

data/lib/rcheck/option_expander.rb

@@ -0,0 +1,57 @@
+module RCheck
+  module OptionExpander
+    def self.constantize(name)
+      name.to_s.split('_').map(&:capitalize).join.to_sym
+    end
+
+    def self.[](name, value)
+      return [] if value == :none
+      case name
+      when :colors       then parse_theme value
+      when :progress     then to_instance(ProgressPrinters, *value)
+      when :report       then to_instance(ReportPrinters,   *value)
+      when :filters      then to_instance(Filters,          *value)
+      when :anti_filters then to_instance(Filters::Anti,    *value)
+      when :headers      then to_instance(Headers,          *value)
+      when :files, :initializers then parse_string_array value
+      when :seed, :fail_code, :success_code
+        value.to_s.to_i
+      else value
+      end
+    end
+
+    def self.to_instance(scope, *list)
+      list.map do |item|
+        case item
+        when Class          then item.new
+        when String, Symbol then safer_const_get(scope, item.to_sym)
+        else item
+        end
+      end
+    end
+
+    def self.safer_const_get(scope, item)
+      if scope.const_defined?(constantize item)
+        val = scope.const_get(constantize item)
+        val.respond_to?(:new) ? val.new : val
+      else
+        raise Errors::ConfigParam, "#{item.inspect} not found in "\
+          "#{scope.inspect}"
+      end
+    end
+
+    def self.parse_string_array(value)
+      Array(value).map(&:to_s)
+    end
+
+    def self.parse_theme(theme)
+      return theme if theme.is_a?(Hash)
+      name = :"#{theme.upcase}"
+      if Colors::Themes.const_defined?(name)
+        Colors::Themes.const_get(name)
+      else
+        raise "Invalid color theme: #{theme.inspect}"
+      end
+    end
+  end
+end