lucid 0.0.4 → 0.0.5

data/lib/lucid/cli/profile.rb

@@ -0,0 +1,101 @@
+require 'yaml'
+
+module Lucid
+  module CLI
+    class Profile
+
+      def initialize
+        @lucid_yml = nil
+      end
+
+      def args_from(profile)
+        unless lucid_yml.has_key?(profile)
+          raise(ProfileNotFound, <<-END_OF_ERROR)
+Could not find profile: '#{profile}'
+
+Defined profiles in lucid.yml:
+  * #{lucid_yml.keys.sort.join("\n  * ")}
+        END_OF_ERROR
+        end
+
+        args_from_yml = lucid_yml[profile] || ''
+
+        case(args_from_yml)
+          when String
+            raise YmlLoadError, ["The '#{profile}' profile in lucid.yml was blank. You must define",
+                                 "command line arguments if you are are going to include a profile",
+                                 "in lucid.yml.\n"].join("\n") if args_from_yml =~ /^\s*$/
+            if(Lucid::WINDOWS)
+              args_from_yml = args_from_yml.split
+              args_from_yml = args_from_yml.collect {|x| x.gsub(/^\"(.*)\"/,'\1') }
+            else
+              require 'shellwords'
+              args_from_yml = Shellwords.shellwords(args_from_yml)
+            end
+          when Array
+            raise YmlLoadError, ["The '#{profile}' profile in lucid.yml contained an empty array.",
+                                 "You must define any command line arguments within the array.\n"].join("\n") if args_from_yml.empty?
+          else
+            raise YmlLoadError, ["The '#{profile}' profile in lucid.yml was a #{args_from_yml.class}.",
+                                 "A profile must be a a String or an Array."].join("\n")
+        end
+        args_from_yml
+      end
+
+      def has_profile?(profile)
+        lucid_yml.has_key?(profile)
+      end
+
+      def lucid_yml_defined?
+        lucid_file && File.exist?(lucid_file)
+      end
+
+    private
+
+      # Loads the profile, processing it through ERB and YAML, and returns it as a hash.
+      def lucid_yml
+        return @lucid_yml if @lucid_yml
+        unless lucid_yml_defined?
+          raise ProfilesNotDefinedError, ["A lucid.yml file was not found. The current directory is #{Dir.pwd}.",
+                                          "Refer to Lucid's documentation on defining profiles in lucid.yml.",
+                                          "You must define a 'default' profile to use the lucid command without",
+                                          "any arguments.\nType 'lucid --help' for usage.\n"].join("\n")
+        end
+
+        require 'erb'
+        require 'yaml'
+        begin
+          @lucid_erb = ERB.new(IO.read(lucid_file)).result(binding)
+        rescue Exception => e
+          raise YmlLoadError, ["A lucid.yml file was found, but could not be parsed. Double-check",
+                               "the contents of the file. Refer to Lucid's documentation on correct",
+                               "profile usage.\n#{$!.inspect}"].join("\n")
+        end
+
+        begin
+          @lucid_yml = YAML::load(@lucid_erb)
+        rescue StandardError => e
+          raise YmlLoadError, ["A lucid.yml file was found, but could not be parsed. Double-check",
+                               "the contents of the file. Refer to Lucid's documentation on correct",
+                               "profile usage.\n"].join("\n")
+        end
+
+        if @lucid_yml.nil? || !@lucid_yml.is_a?(Hash)
+          raise YmlLoadError, ["The lucid.yml file was found, but was blank or malformed. Please",
+                               "refer to Lucid's documentation on defining profiles in lucid.yml.\n"].join("\n")
+        end
+
+        return @lucid_yml
+      end
+
+      # Locates lucid.yml file. The file can end in .yml or .yaml, and be
+      # located in the current directory (e.g., project root) or in a
+      # .config/ or config/ subdirectory of the current directory.
+      def lucid_file
+        @lucid_file ||= Dir.glob('{,.config/,config/}lucid{.yml,.yaml}').first
+      end
+
+    end
+  end
+end
+

data/lib/lucid/configuration.rb

@@ -0,0 +1,53 @@
+module Lucid
+  # The base class for configuring settings for a Lucid run.
+  class Configuration
+    def self.default
+      new
+    end
+
+    def self.parse(argument)
+      return new(argument) if argument.is_a?(Hash)
+      argument
+    end
+
+    def initialize(user_options = {})
+      @options = default_options.merge(user_options)
+    end
+
+    def dry_run?
+      @options[:dry_run]
+    end
+
+    def guess?
+      @options[:guess]
+    end
+
+    def strict?
+      @options[:strict]
+    end
+
+    def expand?
+      @options[:expand]
+    end
+
+    def spec_source
+      @options[:spec_source]
+    end
+
+    def autoload_code_paths
+      @options[:autoload_code_paths]
+    end
+
+    def matcher_type
+      @options[:matcher_type]
+    end
+
+  private
+
+    def default_options
+      {
+        :autoload_code_paths => ['common', 'steps']
+      }
+    end
+  end
+end

data/lib/lucid/core_ext/disable_autorunners.rb

@@ -0,0 +1,15 @@
+begin
+  require 'test/unit'
+
+  if defined?(Test::Unit::AutoRunner.need_auto_run?)
+    # For test-unit gem >= 2.4.9
+    Test::Unit::AutoRunner.need_auto_run = false
+  elsif defined?(Test::Unit.run?)
+    # For test-unit gem < 2.4.9
+    Test::Unit.run = true
+  elsif defined?(Test::Unit::Runner)
+    # For test/unit bundled in Ruby >= 1.9.3
+    Test::Unit::Runner.module_eval("@@stop_auto_run = true")
+  end
+rescue LoadError => ignore
+end

data/lib/lucid/core_ext/instance_exec.rb

@@ -0,0 +1,70 @@
+require 'lucid/platform'
+
+module Lucid
+  # Raised if the number of a StepDefinition's Regexp match groups
+  # is different from the number of Proc arguments.
+  class ArityMismatchError < StandardError
+  end
+end
+
+class Object #:nodoc:
+  # TODO: Move most of this stuff out to an InstanceExecutor class.
+  def lucid_instance_exec(check_arity, pseudo_method, *args, &block)
+    lucid_run_with_backtrace_filtering(pseudo_method) do
+      if check_arity && !lucid_compatible_arity?(args, block)
+        instance_exec do
+          ari = block.arity
+          ari = ari < 0 ? (ari.abs-1).to_s+"+" : ari
+          s1 = ari == 1 ? "" : "s"
+          s2 = args.length == 1 ? "" : "s"
+          raise Lucid::ArityMismatchError.new(
+            "Your block takes #{ari} argument#{s1}, but the regexp matched #{args.length} argument#{s2}."
+          )
+        end
+      else
+        instance_exec(*args, &block)
+      end
+    end
+  end
+
+  private
+
+  def lucid_compatible_arity?(args, block)
+    return true if block.arity == args.length
+    if block.arity < 0
+      return true if args.length >= (block.arity.abs - 1)
+    end
+    false
+  end
+
+  def lucid_run_with_backtrace_filtering(pseudo_method)
+    begin
+      yield
+    rescue Exception => e
+      instance_exec_invocation_line = "#{__FILE__}:#{__LINE__ - 2}:in `lucid_run_with_backtrace_filtering'"
+      replace_instance_exec_invocation_line!((e.backtrace || []), instance_exec_invocation_line, pseudo_method)
+      raise e
+    end
+  end
+
+  INSTANCE_EXEC_OFFSET = (Lucid::RUBY_2_0 || Lucid::RUBY_1_9 || Lucid::JRUBY) ? -3 : -4
+
+  def replace_instance_exec_invocation_line!(backtrace, instance_exec_invocation_line, pseudo_method)
+    return if Lucid.use_full_backtrace
+
+    instance_exec_pos = backtrace.index(instance_exec_invocation_line)
+    if instance_exec_pos
+      replacement_line = instance_exec_pos + INSTANCE_EXEC_OFFSET
+      backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
+
+      depth = backtrace.count { |line| line == instance_exec_invocation_line }
+      end_pos = depth > 1 ? instance_exec_pos : -1
+
+      backtrace[replacement_line+1..end_pos] = nil
+      backtrace.compact!
+    else
+      # This happens with rails, because they screw up the backtrace
+      # before we get here (injecting erb stacktrace and such)
+    end
+  end
+end

data/lib/lucid/core_ext/proc.rb

@@ -0,0 +1,36 @@
+# Proc extension to get more location info out of a proc
+require 'lucid/platform'
+class Proc #:nodoc:
+  PROC_PATTERN = /[\d\w]+@(.+):(\d+).*>/
+  PWD = Dir.pwd
+
+  def to_comment_line
+    "# #{file_colon_line}"
+  end
+
+  def backtrace_line(name)
+    "#{file_colon_line}:in `#{name}'"
+  end
+
+  if Proc.new{}.to_s =~ PROC_PATTERN
+    def file_colon_line
+      path, line = *to_s.match(PROC_PATTERN)[1..2]
+      path = File.expand_path(path)
+      pwd = File.expand_path(PWD)
+      pwd.force_encoding(path.encoding)
+      if path.index(pwd)
+        path = path[pwd.length+1..-1]
+      elsif path =~ /.*\/gems\/(.*\.rb)$/
+        path = $1
+      end
+      "#{path}:#{line}"
+    end
+  else
+    # This Ruby implementation doesn't implement Proc#to_s correctly
+    STDERR.puts "*** THIS RUBY IMPLEMENTATION DOESN'T REPORT FILE AND LINE FOR PROCS ***"
+
+    def file_colon_line
+      "UNKNOWN:-1"
+    end
+  end
+end

data/lib/lucid/core_ext/string.rb

@@ -0,0 +1,9 @@
+class String #:nodoc:
+  def indent(n)
+    if n >= 0
+      gsub(/^/, ' ' * n)
+    else
+      gsub(/^ {0,#{-n}}/, "")
+    end
+  end
+end

data/lib/lucid/errors.rb

@@ -0,0 +1,40 @@
+module Lucid
+  # Raised when there is no matching StepDefinition for a step.
+  class Undefined < StandardError
+    attr_reader :step_name
+
+    def initialize(step_name)
+      super %{Undefined step: "#{step_name}"}
+      @step_name = step_name
+    end
+
+    def nested!
+      @nested = true
+    end
+
+    def nested?
+      @nested
+    end
+  end
+
+  # Raised when a StepDefinition's block invokes Domain#pending
+  class Pending < StandardError
+  end
+
+  # Raised when a step matches 2 or more StepDefinitions
+  class Ambiguous < StandardError
+    def initialize(step_name, step_definitions, used_guess)
+      message = "Ambiguous match of \"#{step_name}\":\n\n"
+      message << step_definitions.map{|sd| sd.backtrace_line}.join("\n")
+      message << "\n\n"
+      message << "You can run again with --guess to make Lucid be a little more smart about it.\n" unless used_guess
+      super(message)
+    end
+  end
+
+  class TagExcess < StandardError
+    def initialize(messages)
+      super(messages.join("\n"))
+    end
+  end
+end

data/lib/lucid/factory.rb

@@ -0,0 +1,43 @@
+module Lucid
+  module ObjectFactory #:nodoc:
+    def create_object_of(phrase)
+      try = 0
+      begin
+        try += 1
+        names = phrase.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = ::Object
+        names.each do |name|
+          constant = provide_object_name(constant, name)
+        end
+        constant
+      rescue NameError => e
+        require underscore(phrase)
+        if try < 2
+          retry
+        else
+          raise e
+        end
+      end
+    end
+
+    def underscore(phrase)
+      phrase.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+    private
+
+    def provide_object_name(constant, name)
+      if constant.const_defined?(name, false)
+        constant.const_get(name, false)
+      else
+        constant.const_missing(name)
+      end
+    end
+  end
+end

data/lib/lucid/formatter/ansicolor.rb

@@ -0,0 +1,168 @@
+require 'lucid/platform'
+require 'lucid/term/ansicolor'
+
+if Lucid::IRONRUBY
+  begin
+    require 'iron-term-ansicolor'
+  rescue LoadError
+    STDERR.puts %{*** WARNING: You must "igem install iron-term-ansicolor" to get coloured ouput in on IronRuby}
+  end
+end
+
+if Lucid::WINDOWS_MRI
+  unless ENV['ANSICON']
+    STDERR.puts %{*** WARNING: You must use ANSICON 1.31 or higher (https://github.com/adoxa/ansicon/) to get coloured output on Windows}
+    Lucid::Term::ANSIColor.coloring = false
+  end
+end
+
+Lucid::Term::ANSIColor.coloring = false if !STDOUT.tty? && !ENV.has_key?("AUTOTEST")
+
+module Lucid
+  module Formatter
+    # Defines aliases for coloured output. You don't invoke any methods from this
+    # module directly, but you can change the output colours by defining
+    # a <tt>CUCUMBER_COLORS</tt> variable in your shell, very much like how you can
+    # tweak the familiar POSIX command <tt>ls</tt> with
+    # <a href="http://mipsisrisc.com/rambling/2008/06/27/lscolorsls_colors-now-with-linux-support/">$LSCOLORS/$LS_COLORS</a>
+    #
+    # The colours that you can change are:
+    #
+    # * <tt>undefined</tt>     - defaults to <tt>yellow</tt>
+    # * <tt>pending</tt>       - defaults to <tt>yellow</tt>
+    # * <tt>pending_param</tt> - defaults to <tt>yellow,bold</tt>
+    # * <tt>failed</tt>        - defaults to <tt>red</tt>
+    # * <tt>failed_param</tt>  - defaults to <tt>red,bold</tt>
+    # * <tt>passed</tt>        - defaults to <tt>green</tt>
+    # * <tt>passed_param</tt>  - defaults to <tt>green,bold</tt>
+    # * <tt>outline</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>outline_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>skipped</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>skipped_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>comment</tt>       - defaults to <tt>grey</tt>
+    # * <tt>tag</tt>           - defaults to <tt>cyan</tt>
+    #
+    # For instance, if your shell has a black background and a green font (like the
+    # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
+    # steps to be white instead of green.
+    #
+    # Although not listed, you can also use <tt>grey</tt>.
+    #
+    # Examples: (On Windows, use SET instead of export.)
+    #
+    #   export CUCUMBER_COLORS="passed=white"
+    #   export CUCUMBER_COLORS="passed=white,bold:passed_param=white,bold,underline"
+    #
+    # To see what colours and effects are available, just run this in your shell:
+    #
+    #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Lucid::Term::ANSIColor.attributes"
+    #
+    module ANSIColor
+      include Lucid::Term::ANSIColor
+
+      ALIASES = Hash.new do |h,k|
+        if k.to_s =~ /(.*)_param/
+          h[$1] + ',bold'
+        end
+      end.merge({
+        'undefined' => 'yellow',
+        'pending'   => 'yellow',
+        'failed'    => 'red',
+        'passed'    => 'green',
+        'outline'   => 'cyan',
+        'skipped'   => 'cyan',
+        'comment'   => 'grey',
+        'tag'       => 'cyan'
+      })
+
+      if ENV['CUCUMBER_COLORS'] # Example: export CUCUMBER_COLORS="passed=red:failed=yellow"
+        ENV['CUCUMBER_COLORS'].split(':').each do |pair|
+          a = pair.split('=')
+          ALIASES[a[0]] = a[1]
+        end
+      end
+
+      # Eval to define the color-named methods required by Term::ANSIColor.
+      #
+      # Examples:
+      #
+      #   def failed(string=nil, &proc)
+      #     red(string, &proc)
+      #   end
+      #
+      #   def failed_param(string=nil, &proc)
+      #     red(bold(string, &proc)) + red
+      #   end
+      ALIASES.each_key do |method_name|
+        unless method_name =~ /.*_param/
+          code = <<-EOF
+          def #{method_name}(string=nil, &proc)
+            #{ALIASES[method_name].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method_name].split(",").length}
+          end
+          # This resets the colour to the non-param colour
+          def #{method_name}_param(string=nil, &proc)
+            #{ALIASES[method_name+'_param'].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method_name+'_param'].split(",").length} + #{ALIASES[method_name].split(",").join(' + ')}
+          end
+          EOF
+          eval(code)
+        end
+      end
+
+      def self.define_grey #:nodoc:
+        begin
+          gem 'genki-ruby-terminfo'
+          require 'terminfo'
+          case TermInfo.default_object.tigetnum("colors")
+          when 0
+            raise "Your terminal doesn't support colours."
+          when 1
+            ::Lucid::Term::ANSIColor.coloring = false
+            alias grey white
+          when 2..8
+            alias grey white
+          else
+            define_real_grey
+          end
+        rescue Exception => e
+          if e.class.name == 'TermInfo::TermInfoError'
+            STDERR.puts "*** WARNING ***"
+            STDERR.puts "You have the genki-ruby-terminfo gem installed, but you haven't set your TERM variable."
+            STDERR.puts "Try setting it to TERM=xterm-256color to get grey colour in output."
+            STDERR.puts "\n"
+            alias grey white
+          else
+            define_real_grey
+          end
+        end
+      end
+
+      def self.define_real_grey #:nodoc:
+        def grey(string) #:nodoc:
+          if ::Lucid::Term::ANSIColor.coloring?
+            "\e[90m#{string}\e[0m"
+          else
+            string
+          end
+        end
+      end
+
+      define_grey
+
+      def cukes(n)
+        ("(::) " * n).strip
+      end
+
+      def green_cukes(n)
+        blink(green(cukes(n)))
+      end
+
+      def red_cukes(n)
+        blink(red(cukes(n)))
+      end
+
+      def yellow_cukes(n)
+        blink(yellow(cukes(n)))
+      end
+    end
+  end
+end