mobiusloop 0.1.2

data/lib/cucumber/multiline_argument/doc_string.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  module MultilineArgument
+    class DocString < SimpleDelegator
+      def append_to(array)
+        array << self.to_s
+      end
+    end
+  end
+end

data/lib/cucumber/platform.rb

@@ -0,0 +1,27 @@
+# Detect the platform we're running on so we can tweak behaviour
+# in various places.
+require 'rbconfig'
+require 'cucumber/core/platform'
+
+module Cucumber
+  unless defined?(Cucumber::VERSION)
+    VERSION       = File.read(File.expand_path("../version", __FILE__))
+    BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/mobiusloop')
+    LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
+    RAILS         = defined?(Rails)
+    RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+    RUBY_2_2      = RUBY_VERSION =~ /^2\.2/
+    RUBY_2_1      = RUBY_VERSION =~ /^2\.1/
+    RUBY_2_3      = RUBY_VERSION =~ /^2\.3/
+
+    class << self
+      attr_accessor :use_full_backtrace
+
+      # @private
+      def file_mode(m, encoding="UTF-8")
+        "#{m}:#{encoding}"
+      end
+    end
+    self.use_full_backtrace = false
+  end
+end

data/lib/cucumber/project_initializer.rb

@@ -0,0 +1,82 @@
+module Cucumber
+
+  # Generates generic file structure for a cucumber project
+  class ProjectInitializer
+    def run
+      # normal cucumber init, replacing /features for /goals
+      create_directory('goals')
+      create_directory('goals/step_definitions')
+      create_directory('goals/support')
+      create_file('goals/support/env.rb')
+
+      # extra mobiusloop initiialization
+      copy_step_defs('mobius_steps.rb', 'goals/step_definitions') # install mobius_steps.rb step definition
+      copy_gherkin_languages('gherkin-languages.json')    # copy modified gherkin-languages.json file to gherkin gem(s)
+      copy_example_file('total_articles_scale.rb', 'goals/step_definitions')
+      copy_example_file('total_readers_scale.rb', 'goals/step_definitions')
+      copy_example_file('increase_readers.goal', 'goals')
+    end
+
+    private
+
+    def copy_step_defs(spec_file, target)
+      gem_dir = `gem environment gemdir`
+      steps_file = gem_dir.gsub("\n","") + "/gems/mobiusloop-?.?.?/lib/mobiusloop/" + spec_file
+      report_copying(spec_file, target)
+      copy_file(steps_file, target)
+    end
+
+    def copy_gherkin_languages(gherkin_file)
+      gem_dir = `gem environment gemdir`
+      source_gherkin = gem_dir.gsub("\n","") + "/gems/mobiusloop-?.?.?/" + gherkin_file
+      target_gherkin = gem_dir.gsub("\n","") + "/gems/gherkin-?.?.?/lib/gherkin/"
+      report_copying(gherkin_file, target_gherkin)
+      copy_file(source_gherkin, target_gherkin)
+    end
+
+    def copy_example_file(file, target)
+      gem_dir = `gem environment gemdir`
+      steps_file = gem_dir.gsub("\n","") + "/gems/mobiusloop-?.?.?/examples/mobiusloop/" + file
+      report_copying(file, target)
+      copy_file(steps_file, target)
+    end
+
+    # TODO: Fix this to work with Windows. FileUtils does not parse ? in file path like Unix
+    def copy_file(source, target)
+      `cp -rf #{source} #{target}`
+    end
+
+    def create_directory(dir_name)
+      create_directory_or_file dir_name, true
+    end
+
+    def create_file(file_name)
+      create_directory_or_file file_name, false
+    end
+
+    def create_directory_or_file(file_name, directory)
+      file_type = if directory
+                    :mkdir_p
+                  else
+                    :touch
+                  end
+
+      report_exists(file_name) || return if File.exists?(file_name)
+
+      report_creating(file_name)
+      FileUtils.send file_type, file_name
+    end
+
+    def report_exists(file)
+      puts "   exist   #{file}"
+    end
+
+    def report_creating(file)
+      puts "  create   #{file}"
+    end
+
+    def report_copying(source, target)
+      puts "  copy     #{source} => #{target}"
+    end
+  end
+end

data/lib/cucumber/rake/task.rb

@@ -0,0 +1,168 @@
+require 'cucumber/platform'
+require 'cucumber/gherkin/formatter/ansi_escapes'
+begin
+  # Support Rake > 0.8.7
+  require 'rake/dsl_definition'
+rescue LoadError
+end
+
+module Cucumber
+  module Rake
+    # Defines a Rake task for running features.
+    #
+    # The simplest use of it goes something like:
+    #
+    #   Cucumber::Rake::Task.new
+    #
+    # This will define a task named <tt>cucumber</tt> described as 'Run Cucumber features'.
+    # It will use steps from 'features/**/*.rb' and features in 'features/**/*.feature'.
+    #
+    # To further configure the task, you can pass a block:
+    #
+    #   Cucumber::Rake::Task.new do |t|
+    #     t.cucumber_opts = %w{--format progress}
+    #   end
+    #
+    # See the attributes for additional configuration possibilities.
+    class Task
+      include Cucumber::Gherkin::Formatter::AnsiEscapes
+      include ::Rake::DSL if defined?(::Rake::DSL)
+
+      class InProcessCucumberRunner #:nodoc:
+        include ::Rake::DSL if defined?(::Rake::DSL)
+
+        attr_reader :args
+
+        def initialize(libs, cucumber_opts, feature_files)
+          raise "libs must be an Array when running in-process" unless Array === libs
+          libs.reverse.each{|lib| $LOAD_PATH.unshift(lib)}
+          @args = (
+            cucumber_opts +
+            feature_files
+          ).flatten.compact
+        end
+
+        def run
+          require 'cucumber/cli/main'
+          failure = Cucumber::Cli::Main.execute(args)
+          raise "Cucumber failed" if failure
+        end
+      end
+
+      class ForkedCucumberRunner #:nodoc:
+        include ::Rake::DSL if defined?(::Rake::DSL)
+
+        def initialize(libs, cucumber_bin, cucumber_opts, bundler, feature_files)
+          @libs          = libs
+          @cucumber_bin  = cucumber_bin
+          @cucumber_opts = cucumber_opts
+          @bundler       = bundler
+          @feature_files = feature_files
+        end
+
+        def load_path(libs)
+          ['"%s"' % @libs.join(File::PATH_SEPARATOR)]
+        end
+
+        def quoted_binary(cucumber_bin)
+          ['"%s"' % cucumber_bin]
+        end
+
+        def use_bundler
+          @bundler.nil? ? File.exist?("./Gemfile") && bundler_gem_available? : @bundler
+        end
+
+        def bundler_gem_available?
+          Gem::Specification.find_by_name('bundler')
+        rescue Gem::LoadError
+          false
+        end
+
+        def cmd
+          if use_bundler
+            [ Cucumber::RUBY_BINARY, '-S', 'bundle', 'exec', 'cucumber', @cucumber_opts,
+            @feature_files ].flatten
+          else
+            [ Cucumber::RUBY_BINARY, '-I', load_path(@libs), quoted_binary(@cucumber_bin),
+            @cucumber_opts, @feature_files ].flatten
+          end
+        end
+
+        def run
+          sh cmd.join(" ") do |ok, res|
+            if !ok
+              exit res.exitstatus
+            end
+          end
+        end
+      end
+
+      # Directories to add to the Ruby $LOAD_PATH
+      attr_accessor :libs
+
+      # Name of the cucumber binary to use for running features. Defaults to Cucumber::BINARY
+      attr_accessor :binary
+
+      # Extra options to pass to the cucumber binary. Can be overridden by the CUCUMBER_OPTS environment variable.
+      # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
+      attr_accessor :cucumber_opts
+      def cucumber_opts=(opts) #:nodoc:
+        @cucumber_opts = String === opts ? opts.split(' ') : opts
+      end
+
+      # Whether or not to fork a new ruby interpreter. Defaults to true. You may gain
+      # some startup speed if you set it to false, but this may also cause issues with
+      # your load path and gems.
+      attr_accessor :fork
+
+      # Define what profile to be used.  When used with cucumber_opts it is simply appended
+      # to it. Will be ignored when CUCUMBER_OPTS is used.
+      attr_accessor :profile
+
+      # Whether or not to run with bundler (bundle exec). Setting this to false may speed
+      # up the execution. The default value is true if Bundler is installed and you have
+      # a Gemfile, false otherwise.
+      #
+      # Note that this attribute has no effect if you don't run in forked mode.
+      attr_accessor :bundler
+
+      # Define Cucumber Rake task
+      def initialize(task_name = "cucumber", desc = "Run Cucumber features")
+        @task_name, @desc = task_name, desc
+        @fork = true
+        @libs = ['lib']
+        @rcov_opts = %w{--rails --exclude osx\/objc,gems\/}
+        yield self if block_given?
+        @binary = binary.nil? ? Cucumber::BINARY : File.expand_path(binary)
+        define_task
+      end
+
+      def define_task #:nodoc:
+        desc @desc
+        task @task_name do
+          runner.run
+        end
+      end
+
+      def runner(task_args = nil) #:nodoc:
+        cucumber_opts = [(ENV['CUCUMBER_OPTS'] ? ENV['CUCUMBER_OPTS'].split(/\s+/) : nil) || cucumber_opts_with_profile]
+        if(@fork)
+          return ForkedCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files)
+        end
+        InProcessCucumberRunner.new(libs, cucumber_opts, feature_files)
+      end
+
+      def cucumber_opts_with_profile #:nodoc:
+        Array(cucumber_opts).concat Array(@profile).flat_map {|p| ["--profile", p] }
+      end
+
+      def feature_files #:nodoc:
+        make_command_line_safe(FileList[ ENV['FEATURE'] || [] ])
+      end
+
+      def make_command_line_safe(list)
+        list.map{|string| string.gsub(' ', '\ ')}
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_dsl.rb

@@ -0,0 +1,119 @@
+module Cucumber
+  module RbSupport
+    # This module defines the methods you can use to define pure Ruby
+    # Step Definitions and Hooks. This module is mixed into the toplevel
+    # object.
+    module RbDsl
+      class << self
+        attr_writer :rb_language
+
+        def alias_adverb(adverb)
+          alias_method adverb, :register_rb_step_definition
+        end
+
+        def build_rb_world_factory(world_modules, proc)
+          @rb_language.build_rb_world_factory(world_modules, proc)
+        end
+
+        def register_rb_hook(phase, tag_names, proc)
+          @rb_language.register_rb_hook(phase, tag_names, proc)
+        end
+
+        def register_rb_transform(regexp, proc)
+          @rb_language.register_rb_transform(regexp, proc)
+        end
+
+        def register_rb_step_definition(regexp, proc_or_sym, options = {})
+          @rb_language.register_rb_step_definition(regexp, proc_or_sym, options)
+        end
+      end
+
+      # Registers any number of +world_modules+ (Ruby Modules) and/or a Proc.
+      # The +proc+ will be executed once before each scenario to create an
+      # Object that the scenario's steps will run within. Any +world_modules+
+      # will be mixed into this Object (via Object#extend).
+      #
+      # This method is typically called from one or more Ruby scripts under
+      # <tt>features/support</tt>. You can call this method as many times as you
+      # like (to register more modules), but if you try to register more than
+      # one Proc you will get an error.
+      #
+      # Cucumber will not yield anything to the +proc+. Examples:
+      #
+      #    World do
+      #      MyClass.new
+      #    end
+      #
+      #    World(MyModule)
+      #
+      def World(*world_modules, &proc)
+        RbDsl.build_rb_world_factory(world_modules, proc)
+      end
+
+      # Registers a proc that will run before each Scenario. You can register as many
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def Before(*tag_expressions, &proc)
+        RbDsl.register_rb_hook('before', tag_expressions, proc)
+      end
+
+      # Registers a proc that will run after each Scenario. You can register as many
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def After(*tag_expressions, &proc)
+        RbDsl.register_rb_hook('after', tag_expressions, proc)
+      end
+
+      # Registers a proc that will be wrapped around each scenario. The proc
+      # should accept two arguments: two arguments: the scenario and a "block"
+      # argument (but passed as a regular argument, since blocks cannot accept
+      # blocks in 1.8), on which it should call the .call method. You can register
+      # as many  as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def Around(*tag_expressions, &proc)
+        RbDsl.register_rb_hook('around', tag_expressions, proc)
+      end
+
+      # Registers a proc that will run after each Step. You can register as
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def AfterStep(*tag_expressions, &proc)
+        RbDsl.register_rb_hook('after_step', tag_expressions, proc)
+      end
+
+      # Registers a proc that will be called with a step definition argument if it
+      # matches the pattern passed as the first argument to Transform. Alternatively, if
+      # the pattern contains captures then they will be yielded as arguments to the
+      # provided proc. The return value of the proc is consequently yielded to the
+      # step definition.
+      def Transform(regexp, &proc)
+        RbDsl.register_rb_transform(regexp, proc)
+      end
+
+      # Registers a proc that will run after Cucumber is configured. You can register as
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      # TODO: Deprecate this
+      def AfterConfiguration(&proc)
+        RbDsl.register_rb_hook('after_configuration', [], proc)
+      end
+
+      # Registers a new Ruby StepDefinition. This method is aliased
+      # to <tt>Given</tt>, <tt>When</tt> and <tt>Then</tt>, and
+      # also to the i18n translations whenever a feature of a
+      # new language is loaded.
+      #
+      # If provided, the +symbol+ is sent to the <tt>World</tt> object
+      # as defined by #World. A new <tt>World</tt> object is created
+      # for each scenario and is shared across step definitions within
+      # that scenario. If the +options+ hash contains an <tt>:on</tt>
+      # key, the value for this is assumed to be a proc. This proc
+      # will be executed in the context of the <tt>World</tt> object
+      # and then sent the +symbol+.
+      #
+      # If no +symbol+ if provided then the +&proc+ gets executed in
+      # the context of the <tt>World</tt> object.
+      def register_rb_step_definition(regexp, symbol = nil, options = {}, &proc)
+        proc_or_sym = symbol || proc
+        RbDsl.register_rb_step_definition(regexp, proc_or_sym, options)
+      end
+    end
+  end
+end
+
+extend(Cucumber::RbSupport::RbDsl)

data/lib/cucumber/rb_support/rb_hook.rb

@@ -0,0 +1,19 @@
+module Cucumber
+  module RbSupport
+    # Wrapper for Before, After and AfterStep hooks
+    class RbHook
+      attr_reader :tag_expressions, :location
+
+      def initialize(rb_language, tag_expressions, proc)
+        @rb_language = rb_language
+        @tag_expressions = tag_expressions
+        @proc = proc
+        @location = Cucumber::Core::Ast::Location.from_source_location(*@proc.source_location)
+      end
+
+      def invoke(pseudo_method, arguments, &block)
+        @rb_language.current_world.cucumber_instance_exec(false, pseudo_method, *[arguments, block].flatten.compact, &@proc)
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_language.rb

@@ -0,0 +1,216 @@
+require 'cucumber/core_ext/instance_exec'
+require 'cucumber/rb_support/rb_dsl'
+require 'cucumber/rb_support/rb_world'
+require 'cucumber/rb_support/rb_step_definition'
+require 'cucumber/rb_support/rb_hook'
+require 'cucumber/rb_support/rb_transform'
+require 'cucumber/rb_support/snippet'
+require 'cucumber/gherkin/i18n'
+require 'multi_test'
+require 'cucumber/step_match'
+require 'cucumber/step_definition_light'
+
+module Cucumber
+  module RbSupport
+    # Raised if a World block returns Nil.
+    class NilWorld < StandardError
+      def initialize
+        super("World procs should never return nil")
+      end
+    end
+
+    # Raised if there are 2 or more World blocks.
+    class MultipleWorld < StandardError
+      def initialize(first_proc, second_proc)
+        message = "You can only pass a proc to #World once, but it's happening\n"
+        message << "in 2 places:\n\n"
+        message << RbSupport.backtrace_line(first_proc, 'World') << "\n"
+        message << RbSupport.backtrace_line(second_proc, 'World') << "\n\n"
+        message << "Use Ruby modules instead to extend your worlds. See the Cucumber::RbSupport::RbDsl#World RDoc\n"
+        message << "or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.\n\n"
+        super(message)
+      end
+    end
+
+    # The Ruby implementation of the programming language API.
+    class RbLanguage
+      attr_reader :current_world,
+                  :step_definitions
+
+      all_keywords = ::Gherkin::DIALECTS.keys.map do |dialect_name|
+        dialect = ::Gherkin::Dialect.for(dialect_name)
+        dialect.given_keywords + dialect.when_keywords + dialect.then_keywords + dialect.and_keywords + dialect.but_keywords
+      end
+      Cucumber::Gherkin::I18n.code_keywords_for(all_keywords.flatten.uniq.sort).each do |adverb|
+        RbDsl.alias_adverb(adverb.strip)
+      end
+
+      def initialize(runtime, configuration)
+        @runtime = runtime
+        @step_definitions = []
+        RbDsl.rb_language = self
+        @world_proc = @world_modules = nil
+        configuration.register_snippet_generator(Snippet::Generator.new)
+      end
+
+      def step_matches(name_to_match)
+        @step_definitions.reduce([]) { |result, step_definition|
+          if (arguments = step_definition.arguments_from(name_to_match))
+            result << StepMatch.new(step_definition, name_to_match, arguments)
+          end
+          result
+        }
+      end
+
+      def begin_rb_scenario(scenario)
+        create_world
+        extend_world
+        connect_world(scenario)
+      end
+
+      def register_rb_hook(phase, tag_expressions, proc)
+        add_hook(phase, RbHook.new(self, tag_expressions, proc))
+      end
+
+      def register_rb_transform(regexp, proc)
+        add_transform(RbTransform.new(self, regexp, proc))
+      end
+
+      def register_rb_step_definition(regexp, proc_or_sym, options)
+        step_definition = RbStepDefinition.new(self, regexp, proc_or_sym, options)
+        @step_definitions << step_definition
+        step_definition
+      end
+
+      def build_rb_world_factory(world_modules, proc)
+        if(proc)
+          raise MultipleWorld.new(@world_proc, proc) if @world_proc
+          @world_proc = proc
+        end
+        @world_modules ||= []
+        @world_modules += world_modules
+      end
+
+      def load_code_file(code_file)
+        return unless File.extname(code_file) == ".rb"
+        load File.expand_path(code_file) # This will cause self.add_step_definition, self.add_hook, and self.add_transform to be called from RbDsl
+      end
+
+      def begin_scenario(scenario)
+        begin_rb_scenario(scenario)
+      end
+
+      def end_scenario
+        @current_world = nil
+      end
+
+      def after_configuration(configuration)
+        hooks[:after_configuration].each do |hook|
+          hook.invoke('AfterConfiguration', configuration)
+        end
+      end
+
+      def execute_transforms(args)
+        args.map do |arg|
+          matching_transform = transforms.detect {|transform| transform.match(arg) }
+          matching_transform ? matching_transform.invoke(arg) : arg
+        end
+      end
+
+      def add_hook(phase, hook)
+        hooks[phase.to_sym] << hook
+        hook
+      end
+
+      def clear_hooks
+        @hooks = nil
+      end
+
+      def add_transform(transform)
+        transforms.unshift transform
+        transform
+      end
+
+      def hooks_for(phase, scenario) #:nodoc:
+        hooks[phase.to_sym].select{|hook| scenario.accept_hook?(hook)}
+      end
+
+      def unmatched_step_definitions
+        available_step_definition_hash.keys - invoked_step_definition_hash.keys
+      end
+
+      def available_step_definition(regexp_source, file_colon_line)
+        available_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
+      end
+
+      def invoked_step_definition(regexp_source, file_colon_line)
+        invoked_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
+      end
+
+      private
+
+      def available_step_definition_hash
+        @available_step_definition_hash ||= {}
+      end
+
+      def invoked_step_definition_hash
+        @invoked_step_definition_hash ||= {}
+      end
+
+      def hooks
+        @hooks ||= Hash.new{|h,k| h[k] = []}
+      end
+
+      def transforms
+        @transforms ||= []
+      end
+
+      def create_world
+        if(@world_proc)
+          @current_world = @world_proc.call
+          check_nil(@current_world, @world_proc)
+        else
+          @current_world = Object.new
+        end
+      end
+
+      def extend_world
+        @current_world.extend(RbWorld)
+        MultiTest.extend_with_best_assertion_library(@current_world)
+        (@world_modules || []).each do |mod|
+          @current_world.extend(mod)
+        end
+      end
+
+      def connect_world(scenario)
+        @current_world.__cucumber_runtime = @runtime
+        @current_world.__natural_language = scenario.language
+      end
+
+      def check_nil(o, proc)
+        if o.nil?
+          begin
+            raise NilWorld.new
+          rescue NilWorld => e
+            e.backtrace.clear
+            e.backtrace.push(RbSupport.backtrace_line(proc, "World"))
+            raise e
+          end
+        else
+          o
+        end
+      end
+
+      def self.cli_snippet_type_options
+        Snippet::SNIPPET_TYPES.keys.sort_by(&:to_s).map do |type|
+          Snippet::SNIPPET_TYPES[type].cli_option_string(type)
+        end
+      end
+    end
+
+    def self.backtrace_line(proc, name)
+      location = Cucumber::Core::Ast::Location.from_source_location(*proc.source_location)
+      "#{location.to_s}:in `#{name}'"
+    end
+  end
+end