mobiusloop 0.1.2

data/features/lib/step_definitions/language_steps.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+Then(/^cucumber lists all the supported languages$/) do
+  sample_languages = ["Arabic", "български", "Pirate", "English", "日本語"]
+  sample_languages.each do |language|
+    expect(all_output.force_encoding('utf-8')).to include(language)
+  end
+end

data/features/lib/step_definitions/profile_steps.rb

@@ -0,0 +1,15 @@
+Given /^the following profiles? (?:are|is) defined:$/ do |profiles|
+  write_file 'cucumber.yml', profiles
+end
+
+Then /^the (.*) profile should be used$/ do |profile|
+  step 'the stdout should contain:', profile
+end
+
+Then /^exactly these files should be loaded:\s*(.*)$/ do |files|
+  expect(all_stdout.scan(/^  \* (.*\.rb)$/).flatten).to eq files.split(/,\s+/)
+end
+
+Then /^exactly these features should be run:\s*(.*)$/ do |files|
+  expect(all_stdout.scan(/^  \* (.*\.feature)$/).flatten).to eq files.split(/,\s+/)
+end

data/features/lib/step_definitions/retry_steps.rb

@@ -0,0 +1,35 @@
+Given /^a scenario "([^\"]*)" that fails once, then passes$/ do |name|
+  write_file "features/#{name}.feature",
+  <<-FEATURE
+  Feature: #{name}
+    Scenario: #{name}
+      Given it fails once, then passes
+  FEATURE
+
+  write_file "features/step_defnitions/#{name}_steps.rb",
+  <<-STEPS
+  Given(/^it fails once, then passes$/) do
+    $#{name.downcase} ||= 0
+    $#{name.downcase} += 1
+    expect($#{name.downcase}).to eql 2
+  end
+  STEPS
+end
+
+Given /^a scenario "([^\"]*)" that fails twice, then passes$/ do |name|
+  write_file "features/#{name}.feature",
+  <<-FEATURE
+  Feature: #{name}
+    Scenario: #{name}
+      Given it fails twice, then passes
+  FEATURE
+
+  write_file "features/step_definitions/#{name}_steps.rb",
+  <<-STEPS
+  Given(/^it fails twice, then passes$/) do
+    $#{name.downcase} ||= 0
+    $#{name.downcase} += 1
+    expect($#{name.downcase}).to eql 3
+  end
+  STEPS
+end

data/features/lib/step_definitions/ruby_steps.rb

@@ -0,0 +1,3 @@
+When(/^I run the following Ruby code:$/) do |code|
+  run_simple %{ruby -e "#{code}"}
+end

data/features/lib/step_definitions/wire_steps.rb

@@ -0,0 +1,58 @@
+Given /^there is a wire server (running |)on port (\d+) which understands the following protocol:$/ do |running, port, table|
+  protocol = table.hashes.map do |table_hash|
+    table_hash['response'] = table_hash['response'].gsub(/\n/, '\n')
+    table_hash
+  end
+
+  @server = FakeWireServer.new(port.to_i, protocol)
+  start_wire_server if running.strip == "running"
+end
+
+Given /^the wire server takes (.*) seconds to respond to the invoke message$/ do |timeout|
+  @server.delay_response(:invoke, timeout.to_f)
+  start_wire_server
+end
+
+Given /^I have environment variable (\w+) set to "([^"]*)"$/ do |variable, value|
+  set_env(variable, value)
+end
+
+Then(/^the wire server should have received the following messages:$/) do |expected_messages|
+  expect(messages_received).to eq expected_messages.raw.flatten
+end
+
+module WireHelper
+  attr_reader :messages_received
+
+  def start_wire_server
+    @messages_received = []
+    reader, writer = IO.pipe
+    @wire_pid = fork { 
+      reader.close
+      @server.run(writer)
+    }
+    writer.close
+    Thread.new do
+      while message = reader.gets
+        @messages_received << message.strip
+      end
+    end
+    at_exit { stop_wire_server }
+  end
+
+  def stop_wire_server
+    return unless @wire_pid
+    Process.kill('KILL', @wire_pid)
+    Process.wait(@wire_pid)
+  rescue Errno::ESRCH
+    # No such process - wire server has already been stopped by the After hook
+  end
+end
+
+Before('@wire') do
+  extend(WireHelper)
+end
+
+After('@wire') do
+  stop_wire_server
+end

data/features/lib/support/env.rb

@@ -0,0 +1,21 @@
+require 'aruba/cucumber'
+require 'aruba/in_process'
+require 'aruba/spawn_process'
+require 'cucumber/cli/main'
+
+Before('@spawn') do
+  Aruba.process = Aruba::SpawnProcess
+end
+
+Before('~@spawn') do
+  Aruba::InProcess.main_class = Cucumber::Cli::Main
+  Aruba.process = Aruba::InProcess
+end
+
+Before do
+  # Make sure bin/cucumber runs with SimpleCov enabled
+  # set_env('SIMPLECOV', 'true')
+
+  # Set a longer timeout for aruba, and a really long one if running on JRuby
+  @aruba_timeout_seconds = Cucumber::JRUBY ? 35 : 15
+end

data/features/lib/support/fake_wire_server.rb

@@ -0,0 +1,80 @@
+require 'multi_json'
+require 'socket'
+
+class FakeWireServer
+  def initialize(port, protocol_table)
+    @port, @protocol_table = port, protocol_table
+    @delays = {}
+  end
+
+  def run(io)
+    @server = TCPServer.open(@port)
+    loop { handle_connections(io) }
+  end
+
+  def delay_response(message, delay)
+    @delays[message] = delay
+  end
+
+  private
+
+  def handle_connections(io)
+    Thread.start(@server.accept) { |socket| open_session_on socket, io }
+  end
+
+  def open_session_on(socket, io)
+    begin
+      on_message = lambda { |message| io.puts message }
+      SocketSession.new(socket, @protocol_table, @delays, on_message).start
+    rescue Exception => e
+      raise e
+    ensure
+      socket.close
+    end
+  end
+
+  class SocketSession
+    def initialize(socket, protocol, delays, on_message)
+      @socket = socket
+      @protocol = protocol
+      @delays = delays
+      @on_message = on_message
+    end
+
+    def start
+      while message = @socket.gets
+        handle(message)
+      end
+    end
+
+    private
+
+    def handle(data)
+      if protocol_entry = response_to(data.strip)
+        sleep delay(data)
+        @on_message.call(MultiJson.load(protocol_entry['request'])[0])
+        send_response(protocol_entry['response'])
+      else
+        serialized_exception = { :message => "Not understood: #{data}", :backtrace => [] }
+        send_response(['fail', serialized_exception ].to_json)
+      end
+    rescue => e
+      send_response(['fail', { :message => e.message, :backtrace => e.backtrace, :exception => e.class } ].to_json)
+    end
+
+    def response_to(data)
+      @protocol.detect do |entry|
+        MultiJson.load(entry['request']) == MultiJson.load(data)
+      end
+    end
+
+    def send_response(response)
+      @socket.puts response + "\n"
+    end
+
+    def delay(data)
+      message = MultiJson.load(data.strip)[0]
+      @delays[message.to_sym] || 0
+    end
+  end
+end

data/features/lib/support/feature_factory.rb

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+module FeatureFactory
+  def create_feature(name = generate_feature_name)
+    gherkin = <<-GHERKIN
+Feature: #{name}
+#{yield}
+    GHERKIN
+    write_file filename(name), gherkin
+  end
+
+  def create_feature_ja(name = generate_feature_name)
+    gherkin = <<-GHERKIN
+# language: ja
+機能: #{name}
+#{yield}
+    GHERKIN
+    write_file filename(name), gherkin
+  end
+
+  def create_scenario(name = generate_scenario_name)
+    <<-GHERKIN
+  Scenario: #{name}
+  #{yield}
+    GHERKIN
+  end
+
+  def create_scenario_ja(name = generate_scenario_name)
+    <<-GHERKIN
+  シナリオ: #{name}
+  #{yield}
+    GHERKIN
+  end
+
+  def create_step_definition
+    write_file generate_step_definition_filename, yield
+  end
+
+  def generate_feature_name
+    "Test Feature #{next_increment(:feature)}"
+  end
+
+  def generate_scenario_name
+    "Test Scenario #{next_increment(:scenario)}"
+  end
+
+  def next_increment(label)
+    @increments ||= {}
+    @increments[label] ||= 0
+    @increments[label] += 1
+  end
+
+  def generate_step_definition_filename
+    "features/step_definitions/steps#{next_increment(:step_defs)}.rb"
+  end
+
+  def filename(name)
+    "features/#{name.downcase.gsub(' ', '_')}.feature"
+  end
+
+  def features
+    in_current_dir do
+      Dir['features/*.feature']
+    end
+  end
+end
+
+World(FeatureFactory)

data/features/lib/support/normalise_output.rb

@@ -0,0 +1,50 @@
+# override aruba to filter out some stuff
+module NormaliseArubaOutput
+  def all_stdout
+    normalise_output(super)
+  end
+
+  def normalise_output(out)
+    out = out.gsub(/#{Dir.pwd}\/tmp\/aruba/, '.') # Remove absolute paths
+    out = out.gsub(/tmp\/aruba\//, '')            # Fix aruba path
+    out = out.gsub(/^.*cucumber_process\.rb.*$\n/, '')
+    out = out.gsub(/^\d+m\d+\.\d+s$/, '0m0.012s') # Make duration predictable
+    out = out.gsub(/Coverage report generated .+$\n/, '') # Remove SimpleCov message
+  end
+
+  def normalise_json(json)
+    #make sure duration was captured (should be >= 0)
+    #then set it to what is "expected" since duration is dynamic
+    json.each do |feature|
+      elements = feature.fetch('elements') { [] }
+      elements.each do |scenario|
+        scenario['steps'].each do |step|
+          ['steps', 'before', 'after'].each do |type|
+            if scenario[type]
+              scenario[type].each do |step_or_hook|
+                normalise_json_step_or_hook(step_or_hook)
+                if step_or_hook['after']
+                  step_or_hook['after'].each do |hook|
+                    normalise_json_step_or_hook(hook)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def normalise_json_step_or_hook(step_or_hook)
+    if step_or_hook['result']
+      if step_or_hook['result']['duration']
+        expect(step_or_hook['result']['duration']).to be >= 0
+        step_or_hook['result']['duration'] = 1
+      end
+    end
+  end
+
+end
+
+World(NormaliseArubaOutput)

data/gem_tasks/contributors.rake

@@ -0,0 +1,15 @@
+# encoding: utf-8
+desc 'List contributors'
+task :contributors do
+  contributors = `git log --pretty=short --no-merges | git shortlog -ne | egrep -ve '^ +' | egrep -ve '^$'`.split("\n")
+  puts contributors
+  puts "Total: #{contributors.length}"
+end
+
+task :codeswarm do
+  sh "code_swarm --reload" rescue nil # Fails because of encoding - which we'll fix
+  sh "iconv -f latin1 -t utf-8 .git/.code_swarm/log.xml > tmp.xml && mv tmp.xml .git/.code_swarm/log.xml"
+  sh "sed -e 's/Aslak\ Hellesøy@.BEKK.no/aslak.hellesoy@gmail.com/g' .git/.code_swarm/log.xml > tmp.xml && mv tmp.xml .git/.code_swarm/log.xml"
+  sh "sed -e 's/josephwilk@joesniff.co.uk/joe@josephwilk.net/g' .git/.code_swarm/log.xml > tmp.xml && mv tmp.xml .git/.code_swarm/log.xml"
+  sh "code_swarm"
+end

data/gem_tasks/cov.rake

@@ -0,0 +1,5 @@
+desc 'Run all tests and collect code coverage'
+task :cov do
+  ENV['SIMPLECOV'] = 'features'
+  Rake::Task['default'].invoke
+end

data/gem_tasks/cucumber.rake

@@ -0,0 +1,25 @@
+require 'cucumber/rake/task'
+require 'cucumber/platform'
+
+class Cucumber::Rake::Task
+  def set_profile_for_current_ruby
+    self.profile = if Cucumber::JRUBY
+      Cucumber::WINDOWS ? 'jruby_win' : 'jruby'
+    elsif Cucumber::WINDOWS_MRI
+      'windows_mri'
+    elsif Cucumber::RUBY_1_9
+      'ruby_1_9'
+    elsif Cucumber::RUBY_2_0
+      'ruby_2_0'
+    elsif Cucumber::RUBY_2_1
+      'ruby_2_1'
+    end
+  end
+end
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.fork = true
+  t.set_profile_for_current_ruby
+end
+
+task :cucumber => :features

data/gem_tasks/downloads.rb

@@ -0,0 +1,7 @@
+require 'httparty'
+require 'multi_json'
+
+IO.read(File.dirname(__FILE__) + '/versions.txt').each_line do |version|
+  json = HTTParty.get("http://rubygems.org/api/v1/downloads/cucumber-#{version.strip}.json")
+  puts MultiJson.load(json.body)['version_downloads']
+end

data/gem_tasks/environment.rake

@@ -0,0 +1,7 @@
+task :ruby_env do
+  RUBY_APP = if RUBY_PLATFORM =~ /java/
+    "jruby"
+  else
+    "ruby"
+  end unless defined? RUBY_APP
+end

data/gem_tasks/examples.rake

@@ -0,0 +1,11 @@
+desc 'Run all exmples'
+task :examples do
+  Dir['examples/*'].each do |example_dir|
+    next if !File.directory?(example_dir) || %w{examples/i18n examples/tcl examples/python examples/ruby2python}.index(example_dir)
+    puts "Running #{example_dir}"
+    Dir.chdir(example_dir) do
+      raise "No Rakefile in #{Dir.pwd}" unless File.file?('Rakefile')
+      sh "rake cucumber"
+    end
+  end
+end

data/gem_tasks/fix_cr_lf.rake

@@ -0,0 +1,10 @@
+desc 'Make all files use UNIX (\n) line endings'
+task :fix_cr_lf do
+  files = FileList['**/*']
+  files.each do |f|
+    next if File.directory?(f) || f =~ /dos/
+    s = IO.read(f)
+    s.gsub!(/\r?\n/, "\n")
+    File.open(f, "w") { |io| io.write(s) }
+  end
+end

data/gem_tasks/flog.rake

@@ -0,0 +1,4 @@
+desc "Run flog over significant files"
+task :flog do
+  sh "find lib/cucumber -name \\*.rb | grep -v parser\/feature\\.rb | xargs flog"
+end