mobiusloop 0.1.2

data/lib/cucumber/cli/profile_loader.rb

@@ -0,0 +1,91 @@
+require 'yaml'
+
+module Cucumber
+  module Cli
+
+    class ProfileLoader
+
+      def initialize
+        @cucumber_yml = nil
+      end
+
+      def args_from(profile)
+        unless cucumber_yml.has_key?(profile)
+          raise(ProfileNotFound, <<-END_OF_ERROR)
+Could not find profile: '#{profile}'
+
+Defined profiles in cucumber.yml:
+  * #{cucumber_yml.keys.sort.join("\n  * ")}
+        END_OF_ERROR
+        end
+
+        args_from_yml = cucumber_yml[profile] || ''
+
+        case(args_from_yml)
+          when String
+            raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was blank.  Please define the command line arguments for the '#{profile}' profile in cucumber.yml.\n" if args_from_yml =~ /^\s*$/
+            if(Cucumber::WINDOWS)
+              #Shellwords treats backslash as an escape character so here's a rudimentary approximation of the same code
+              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 cucumber.yml was empty.  Please define the command line arguments for the '#{profile}' profile in cucumber.yml.\n" if args_from_yml.empty?
+          else
+            raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was a #{args_from_yml.class}. It must be a String or Array"
+        end
+        args_from_yml
+      end
+
+      def has_profile?(profile)
+        cucumber_yml.has_key?(profile)
+      end
+
+      def cucumber_yml_defined?
+        cucumber_file && File.exist?(cucumber_file)
+      end
+
+    private
+
+      # Loads the profile, processing it through ERB and YAML, and returns it as a hash.
+      def cucumber_yml
+        return @cucumber_yml if @cucumber_yml
+        unless cucumber_yml_defined?
+          raise(ProfilesNotDefinedError,"cucumber.yml was not found.  Current directory is #{Dir.pwd}.  Please refer to cucumber's documentation on defining profiles in cucumber.yml.  You must define a 'default' profile to use the cucumber command without any arguments.\nType 'cucumber --help' for usage.\n")
+        end
+
+        require 'erb'
+        require 'yaml'
+        begin
+          @cucumber_erb = ERB.new(IO.read(cucumber_file), nil, '%').result(binding)
+        rescue Exception => e
+          raise(YmlLoadError,"cucumber.yml was found, but could not be parsed with ERB.  Please refer to cucumber's documentation on correct profile usage.\n#{$!.inspect}")
+        end
+
+        begin
+          @cucumber_yml = YAML::load(@cucumber_erb)
+        rescue StandardError => e
+          raise(YmlLoadError,"cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentation on correct profile usage.\n")
+        end
+
+        if @cucumber_yml.nil? || !@cucumber_yml.is_a?(Hash)
+          raise(YmlLoadError,"cucumber.yml was found, but was blank or malformed. Please refer to cucumber's documentation on correct profile usage.\n")
+        end
+
+        return @cucumber_yml
+      end
+
+      # Locates cucumber.yml file. The file can end in .yml or .yaml,
+      # and be located in the current directory (eg. project root) or
+      # in a .config/ or config/ subdirectory of the current directory.
+      def cucumber_file
+        @cucumber_file ||= Dir.glob('{,.config/,config/}cucumber{.yml,.yaml}').first
+      end
+
+    end
+  end
+end
+

data/lib/cucumber/cli/rerun_file.rb

@@ -0,0 +1,29 @@
+module Cucumber
+  module Cli
+    class RerunFile
+      attr_reader :path
+
+      def self.can_read?(path)
+        path[0] == '@' && File.file?(real_path(path))
+      end
+
+      def self.real_path(path)
+        path[1..-1] # remove leading @
+      end
+
+      def initialize(path)
+        @path = self.class.real_path(path)
+      end
+
+      def features
+        lines.map { |l| l.scan(/(?:^| |)(.*?\.feature(?:(?::\d+)*))/) }.flatten
+      end
+
+      private
+
+      def lines
+        IO.read(@path).split("\n")
+      end
+    end
+  end
+end

data/lib/cucumber/configuration.rb

@@ -0,0 +1,268 @@
+require 'cucumber/constantize'
+require 'cucumber/cli/rerun_file'
+require 'cucumber/events'
+require 'forwardable'
+require 'cucumber/core/gherkin/tag_expression'
+
+module Cucumber
+  # The base class for configuring settings for a Cucumber run.
+  class Configuration
+    include Constantize
+    extend Forwardable
+
+    def self.default
+      new
+    end
+
+    # Subscribe to an event.
+    #
+    # See {Cucumber::Events} for the list of possible events.
+    #
+    # @param event_id [Symbol, Class, String] Identifier for the type of event to subscribe to
+    # @param handler_object [Object optional] an object to be called when the event occurs
+    # @yield [Object] Block to be called when th event occurs
+    # @method on_event
+    def_instance_delegator :event_bus, :register, :on_event
+
+    # @private
+    def_instance_delegator :event_bus, :notify
+
+    def initialize(user_options = {})
+      @options = default_options.merge(Cucumber::Hash(user_options))
+    end
+
+    def with_options(new_options)
+      self.class.new(@options.merge(new_options))
+    end
+
+    # TODO: Actually Deprecate???
+    def options
+      warn("Deprecated: Configuration#options will be removed from the next release of Cucumber. Please use the configuration object directly instead.")
+      Marshal.load(Marhal.dump(@options))
+    end
+
+    def out_stream
+      @options[:out_stream]
+    end
+
+    def error_stream
+      @options[:error_stream]
+    end
+
+    def randomize?
+      @options[:order] == 'random'
+    end
+
+    def seed
+      Integer(@options[:seed] || rand(0xFFFF))
+    end
+
+    def dry_run?
+      @options[:dry_run]
+    end
+
+    def fail_fast?
+      @options[:fail_fast]
+    end
+
+    def retry_attempts
+      @options[:retry]
+    end
+
+    def guess?
+      @options[:guess]
+    end
+
+    def strict?
+      @options[:strict]
+    end
+
+    def wip?
+      @options[:wip]
+    end
+
+    def expand?
+      @options[:expand]
+    end
+
+    def paths
+      @options[:paths]
+    end
+
+    def formats
+      @options[:formats]
+    end
+
+    def autoload_code_paths
+      @options[:autoload_code_paths]
+    end
+
+    def snippet_type
+      @options[:snippet_type]
+    end
+
+    def feature_dirs
+      dirs = paths.map { |f| File.directory?(f) ? f : File.dirname(f) }.uniq
+      dirs.delete('.') unless paths.include?('.')
+      with_default_features_path(dirs)
+    end
+
+    # todo: remove
+    def tag_expression
+      Cucumber::Core::Gherkin::TagExpression.new(@options[:tag_expressions])
+    end
+
+    def tag_limits
+      tag_expression.limits.to_hash
+    end
+
+    def tag_expressions
+      @options[:tag_expressions]
+    end
+
+    def name_regexps
+      @options[:name_regexps]
+    end
+
+    def filters
+      @options[:filters]
+    end
+
+    def feature_files
+      potential_feature_files = with_default_features_path(paths).map do |path|
+        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
+        path = path.chomp('/')
+
+        # TODO: Move to using feature loading strategies stored in
+        # options[:feature_loaders]
+        if File.directory?(path)
+          Dir["#{path}/**/*.goal"].sort
+        elsif Cli::RerunFile.can_read?(path)
+          Cli::RerunFile.new(path).features
+        else
+          path
+        end
+      end.flatten.uniq
+      remove_excluded_files_from(potential_feature_files)
+      potential_feature_files
+    end
+
+    def support_to_load
+      support_files = all_files_to_load.select {|f| f =~ %r{/support/} }
+      env_files = support_files.select {|f| f =~ %r{/support/env\..*} }
+      other_files = support_files - env_files
+      @options[:dry_run] ? other_files : env_files + other_files
+    end
+
+    def all_files_to_load
+      files = require_dirs.map do |path|
+        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
+        path = path.gsub(/\/$/, '') # Strip trailing slash.
+        File.directory?(path) ? Dir["#{path}/**/*"] : path
+      end.flatten.uniq
+      remove_excluded_files_from(files)
+      files.reject! {|f| !File.file?(f)}
+      files.reject! {|f| File.extname(f) == '.goal' }
+      files.reject! {|f| f =~ /^http/}
+      files.sort
+    end
+
+    def step_defs_to_load
+      all_files_to_load.reject {|f| f =~ %r{/support/} }
+    end
+
+    def formatter_factories
+      @options[:formats].map do |format_and_out|
+        format = format_and_out[0]
+        path_or_io = format_and_out[1]
+        begin
+          factory = formatter_class(format)
+          yield factory, path_or_io, Cli::Options.new(STDOUT, STDERR, @options)
+        rescue Exception => e
+          e.message << "\nError creating formatter: #{format}"
+          raise e
+        end
+      end
+    end
+
+    def formatter_class(format)
+      if(builtin = Cli::Options::BUILTIN_FORMATS[format])
+        constantize(builtin[0])
+      else
+        constantize(format)
+      end
+    end
+
+    def to_hash
+      @options
+    end
+
+    # An array of procs that can generate snippets for undefined steps. These procs may be called if a
+    # formatter wants to display snippets to the user.
+    #
+    # Each proc should take the following arguments:
+    # 
+    #  - keyword
+    #  - step text
+    #  - multiline argument
+    #  - snippet type
+    #
+    def snippet_generators
+      @options[:snippet_generators] ||= []
+    end
+
+    def register_snippet_generator(generator)
+      snippet_generators << generator
+      self
+    end
+
+  private
+
+    def default_options
+      {
+        :autoload_code_paths => ['goals/support', 'goals/step_definitions'],
+        :filters             => [],
+        :strict              => false,
+        :require             => [],
+        :dry_run             => false,
+        :fail_fast           => false,
+        :formats             => [],
+        :excludes            => [],
+        :tag_expressions     => [],
+        :name_regexps        => [],
+        :env_vars            => {},
+        :diff_enabled        => true,
+        :snippets            => true,
+        :source              => true,
+        :duration            => true,
+        :event_bus           => Events::Bus.new(Cucumber::Events)
+      }
+    end
+
+    def event_bus
+      @options[:event_bus]
+    end
+
+
+    def default_features_paths
+      ["goals"]
+    end
+
+    def with_default_features_path(paths)
+      return default_features_paths if paths.empty?
+      paths
+    end
+
+    def remove_excluded_files_from(files)
+      files.reject! {|path| @options[:excludes].detect {|pattern| path =~ pattern } }
+    end
+
+    def require_dirs
+      if @options[:require].empty?
+        default_features_paths + Dir['vendor/{gems,plugins}/*/mobiusloop']
+      else
+        @options[:require]
+      end
+    end
+  end
+end

data/lib/cucumber/constantize.rb

@@ -0,0 +1,45 @@
+require 'cucumber/platform'
+module Cucumber
+  module Constantize #:nodoc:
+    def constantize(camel_cased_word)
+      try = 0
+      begin
+        try += 1
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = ::Object
+        names.each do |name|
+          constant = constantize_name(constant, name)
+        end
+        constant
+      rescue NameError => e
+        require underscore(camel_cased_word)
+        if try < 2
+          retry
+        else
+          raise e
+        end
+      end
+    end
+
+    # Snagged from active_support
+    def underscore(camel_cased_word)
+      camel_cased_word.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 constantize_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/cucumber/core_ext/instance_exec.rb

@@ -0,0 +1,70 @@
+require 'cucumber/platform'
+
+module Cucumber
+  # 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 cucumber_instance_exec(check_arity, pseudo_method, *args, &block)
+    cucumber_run_with_backtrace_filtering(pseudo_method) do
+      if check_arity && !cucumber_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 Cucumber::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 cucumber_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 cucumber_run_with_backtrace_filtering(pseudo_method)
+    begin
+      yield
+    rescue Exception => e
+      instance_exec_invocation_line = "#{__FILE__}:#{__LINE__ - 2}:in `cucumber_run_with_backtrace_filtering'"
+      replace_instance_exec_invocation_line!((e.backtrace || []), instance_exec_invocation_line, pseudo_method)
+      raise e
+    end
+  end
+
+  INSTANCE_EXEC_OFFSET = -3
+
+  def replace_instance_exec_invocation_line!(backtrace, instance_exec_invocation_line, pseudo_method)
+    return if Cucumber.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