gurke 1.0.1 → 2.0.0.dev.1.b17

data/features/support/steps/file_steps.rb

@@ -0,0 +1,32 @@
+#
+module FileSteps
+  def _write_file(path, content)
+    file = @__root.join(path)
+
+    FileUtils.mkdir_p(File.dirname(file))
+    File.write(file, content)
+  end
+
+  def _read_file(path)
+    file = @__root.join(path)
+
+    File.read(file)
+  end
+
+  step(/I am in a project using gurke/) do
+    _write_file 'Gemfile', <<-EOS
+      source 'https://rubygems.org'
+      gem 'gurke', path: '#{File.dirname(Gurke.root)}'
+    EOS
+  end
+
+  step(/a file "(.*?)" with the following content exists/) do |path, step|
+    _write_file(path, step.doc_string)
+  end
+
+  # Then(/a file "(.*?)" with the following content exists/) do |path, step|
+  #   expect(_read_file(path)).to eq step.doc_string
+  # end
+end
+
+Gurke.config.include FileSteps

data/gurke.gemspec

@@ -1,25 +1,29 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gurke/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'gurke'
-  spec.version       = '1.0.1'
+  spec.version       = Gurke::VERSION
   spec.authors       = ['Jan Graichen']
   spec.email         = %w(jg@altimos.de)
-  spec.description   = %q{A description}
-  spec.summary       = %q{A summary}
+  spec.description   = %q{An alternative gherkin feature runner inspired by rspec and turnip.}
+  spec.summary       = %q{An alternative gherkin feature runner inspired by rspec and turnip.}
   spec.homepage      = 'https://github.com/jgraichen/gurke'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = Dir['**/*'].grep(%r{^((bin|lib|test|spec|features)/|.*\.gemspec|.*LICENSE.*|.*README.*|.*CHANGELOG.*)})
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = %w(lib)
 
-  spec.add_dependency 'cucumber'
-  spec.add_dependency 'activesupport'
+  spec.add_dependency 'trollop'
+  spec.add_dependency 'gherkin'
+  spec.add_dependency 'colorize'
 
   spec.add_development_dependency 'bundler', '~> 1.3'
-  spec.add_development_dependency 'rake'
+
+  # Append travis build number for auto-releases
+  spec.version = "#{spec.version}.1.b#{ENV['TRAVIS_BUILD_NUMBER']}" if ENV['TRAVIS_BUILD_NUMBER']
 end

data/lib/gurke.rb

@@ -1,30 +1,57 @@
-require 'cucumber'
+require 'gurke/version'
 
-require 'gurke/patch/cucumber_cli_configuration'
-require 'gurke/formatter'
+#
+module Gurke
+  require 'gurke/feature'
+  require 'gurke/background'
+  require 'gurke/scenario'
+  require 'gurke/step'
+  require 'gurke/tag'
 
-require 'gurke/current'
-require 'gurke/hooks'
+  require 'gurke/dsl'
+  require 'gurke/builder'
+  require 'gurke/configuration'
+  require 'gurke/runner'
+  require 'gurke/steps'
+  require 'gurke/step_definition'
+  require 'gurke/reporter'
 
+  class Error < StandardError; end
+  class StepPending < Error; end
+  class StepAmbiguous < Error; end
 
-module Gurke
   class << self
-    def current
-      @current ||= Gurke::Current.instance
+    #
+    # Return path to features directory.
+    #
+    # @return [Path] Feature directory.
+    #
+    def root
+      @root ||= Pathname.new(Dir.getwd).join('features')
     end
 
-    def before(stage, &block)
-      Hooks.before.add stage, &block
+    # Return configuration object.
+    #
+    # @return [Configuration] Configuration object.
+    #
+    def config
+      @config ||= Configuration.new
     end
 
-    def after(stage, &block)
-      Hooks.after.add stage, &block
+    # Yield configuration object.
+    #
+    # @yield [config] Yield configuration object.
+    # @yieldparam config [Configuration] Configuration object.
+    #
+    def configure
+      yield config if block_given?
     end
 
-    def step!(opts = {})
-      if (fmt = Gurke::Formatter.instance)
-        fmt.manual_step current.step, opts
-      end
+    # @api private
+    def world
+      @world ||= const_set('World', Module.new)
     end
   end
 end
+
+::Module.send(:include, Gurke::DSL)

data/lib/gurke/background.rb

@@ -0,0 +1,33 @@
+module Gurke
+  #
+  class Background
+    #
+    # Return path to file containing this background.
+    #
+    # @return [String] File path.
+    #
+    attr_reader :file
+
+    # Return line number where this background is defined.
+    #
+    # @return [Fixnum] Line number.
+    #
+    attr_reader :line
+
+    # @api private
+    attr_reader :raw
+
+    # @api private
+    def initialize(file, line, raw)
+      @file, @line, @raw = file, line, raw
+    end
+
+    # Return list of steps this background specifies.
+    #
+    # @return [Array<Step>] Steps.
+    #
+    def steps
+      @steps ||= []
+    end
+  end
+end

data/lib/gurke/builder.rb

@@ -0,0 +1,107 @@
+require 'gherkin'
+
+module Gurke
+  #
+  class Builder
+    #
+    attr_reader :features, :options
+
+    def initialize(options)
+      @options  = options
+      @features = []
+      @language = 'en'
+      @parser   = Gherkin::Parser::Parser.new(
+        self, true, 'root', false, @language)
+
+      @keywords = {}
+      Gherkin::I18n::LANGUAGES[@language].each do |k, v|
+        v.split('|').map(&:strip).each do |str|
+          @keywords[str] = k.to_sym if str != '*'
+        end
+      end
+    end
+
+    def parse(feature_file)
+      @parser.parse(File.read(feature_file), feature_file, 0)
+    end
+
+    def uri(raw)
+      @file = raw.to_s
+    end
+
+    def feature(raw)
+      tags = raw.tags.map{|t| Tag.new(@file, t.line, t) }
+
+      @current_feature = Feature.new(@file, raw.line, tags, raw)
+      @features << @current_feature
+    end
+
+    def background(raw)
+      @current_context = Background.new(@file, raw.line, raw)
+      @current_feature.backgrounds << @current_context
+    end
+
+    def scenario(raw)
+      tags = raw.tags.map{|t| Tag.new(@file, t.line, t) }
+      tags += @current_feature.tags
+
+      @current_context = Scenario.new(@file, raw.line, tags, raw)
+
+      unless filtered?(@current_context)
+        @current_feature.scenarios << @current_context
+      end
+    end
+
+    def step(raw)
+      type = get_type(raw.keyword.strip)
+
+      @current_context.steps << Step.new(@file, raw.line, type, raw)
+    end
+
+    def eof(*)
+      @features.reject!{|f| f.scenarios.empty? }
+      @current_context = nil
+      @current_feature = nil
+      @file            = nil
+    end
+
+    def get_type(keyword)
+      case (kw = @keywords.fetch(keyword))
+        when :and, :but
+          if (step = @current_context.steps.last)
+            step.type
+          else
+            nil
+          end
+        else
+          kw
+      end
+    end
+
+    def filter_sets
+      @filter_sets ||= options[:tags].map do |list|
+        list.strip.split(/[,+\s]\s*/).map{|t| Filter.new(t) }
+      end
+    end
+
+    def filtered?(scenario)
+      !filter_sets.reduce(false) do |memo, set|
+        memo || set.all?{|rule| rule.match? scenario }
+      end
+    end
+
+    Filter = Struct.new(:tag) do
+      def name
+        @name ||= negated? ? tag[1..-1] : tag
+      end
+
+      def negated?
+        tag[0] == '~'
+      end
+
+      def match?(taggable)
+        negated? != taggable.tags.any?{|t| t.name == name }
+      end
+    end
+  end
+end

data/lib/gurke/capybara.rb

@@ -0,0 +1,28 @@
+require 'capybara'
+require 'gurke'
+require 'capybara/dsl'
+require 'capybara/rspec/matchers'
+
+Gurke.configure do |c|
+  c.include Capybara::DSL, type: :feature
+  c.include Capybara::RSpecMatchers, type: :feature
+
+  c.before do
+    next unless self.class.include?(Capybara::DSL)
+
+    # if context.metadata[:js]
+    #   Capybara.current_driver = Capybara.javascript_driver
+    # end
+    #
+    # if context.metadata[:driver]
+    #   Capybara.current_driver = context.metadata[:driver]
+    # end
+  end
+
+  c.after do
+    next unless self.class.include?(Capybara::DSL)
+
+    Capybara.reset_sessions!
+    Capybara.use_default_driver
+  end
+end

data/lib/gurke/cli.rb

@@ -0,0 +1,67 @@
+require 'trollop'
+
+module Gurke
+  #
+  class CLI
+    #
+    # Run CLI with given arguments.
+    #
+    # @param argv [Array<String>] Tokenized argument list.
+    #
+    def run(argv)
+      call parser.parse(argv), argv
+    rescue Trollop::VersionNeeded
+      print_version && exit
+    rescue Trollop::HelpNeeded
+      print_help && exit
+    rescue Trollop::CommandlineError => e
+      $stderr.puts "Error: #{e}"
+      $stderr.puts "Run with `-h' for more information on available arguments."
+      exit 255
+    end
+
+    def call(options, files)
+      if File.exist?(Gurke.root.join('gurke.rb'))
+        require File.expand_path(Gurke.root.join('gurke.rb'))
+      end
+
+      options[:require].each do |r|
+        Dir[r].each{|f| require File.expand_path(f) }
+      end if options[:require].any?
+
+      files  = Dir[options[:pattern].to_s] if files.empty? && options[:pattern]
+      status = Runner.new(files, options).run
+
+      Kernel.exit(status)
+    end
+
+    def print_version
+      $stdout.puts <<-EOF.gsub(/^ {8}/, '')
+        gurke v#{Gurke::VERSION}
+      EOF
+    end
+
+    def print_help
+      parser.educate($stdout)
+    end
+
+    def parser
+      @parser ||= Trollop::Parser.new do
+        opt :help, 'Print this help.'
+        opt :version, 'Show program version information.'
+        opt :backtrace, 'Show full error backtraces.'
+        opt :pattern, 'File pattern matching feature files to be run.',
+            default: 'features/**/*.feature'
+        opt :require, 'Files matching this pattern will be required after'\
+                      'loading environment but before running features.',
+            default: ['features/steps/**/*.rb',
+                      'features/support/steps/**/*.rb'],
+            multi: true
+        opt :tags, 'Only run features and scenarios matching given tag '\
+                   'filtering expression. TODO: Description.',
+            default: ['~wip'],
+            multi: true
+      end
+    end
+  end
+end

data/lib/gurke/configuration.rb

@@ -0,0 +1,118 @@
+module Gurke
+  #
+  class Configuration
+    #
+    # Define a before filter running before given action.
+    #
+    # @example
+    #   Gurke.before(:step) do
+    #     puts step.description
+    #   end
+    #
+    # @param action [Symbol] A defined action like `:feature`,
+    #   `:scenario` or `:step`.
+    #
+    # @yield Before any matching action is executed.
+    #
+    def before(action = :scenario, opts = nil, &block)
+      BEFORE_HOOKS.append action, Hook.new(opts, &block)
+    end
+
+    def around(action = :scenario, opts = nil, &block)
+      AROUND_HOOKS.append action, Hook.new(opts, &block)
+    end
+
+    # Define a after filter running after given action.
+    #
+    # @example
+    #   Gurke.after(:step) do
+    #     puts step.description
+    #   end
+    #
+    # @param action [Symbol] A defined action like `:feature`,
+    #   `:scenario` or `:step`.
+    #
+    # @yield After any matching action is executed.
+    #
+    def after(action = :scenario, opts = nil, &block)
+      AFTER_HOOKS.append action, Hook.new(opts, &block)
+    end
+
+    # Include given module into all or specific features or
+    # scenarios.
+    #
+    # @example
+    #   Gurke.include(MyTestMethods)
+    #
+    # @param mod [Module] Module to include.
+    # @param opts [Hash] Options.
+    #
+    def include(mod, opts = {})
+      inclusions << Inclusion.new(mod, opts)
+    end
+
+    # @api private
+    def inclusions
+      @inclusions ||= []
+    end
+
+    # @api private
+    def hooks
+      @hooks ||= Hooks.new
+    end
+
+    # @api private
+    class Inclusion
+      attr_reader :mod, :opts
+
+      def initialize(mod, opts)
+        @mod  = mod
+        @opts = opts
+      end
+    end
+
+    # @api private
+    class HookSet
+      attr_reader :hooks
+
+      def initialize
+        @hooks = {}
+      end
+
+      def for(action)
+        hooks[action] ||= []
+      end
+
+      def append(action, hook)
+        self.for(action) << hook
+      end
+    end
+
+    BEFORE_HOOKS = HookSet.new
+    AROUND_HOOKS = HookSet.new
+    AFTER_HOOKS  = HookSet.new
+
+    # @api private
+    class Hook
+      attr_reader :opts, :block
+
+      def initialize(opts, &block)
+        @opts  = opts
+        @block = block
+      end
+
+      def match?(context)
+        !opts.any?{|k, v| context.metadata[k] != v }
+      end
+
+      def run(context, *args)
+        block = @block
+        if context
+          context.instance_exec(*args, &block)
+        else
+          block.call(*args)
+        end
+      end
+    end
+  end
+end