cucumber-core 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea9227a0b067303f1aa77c9f4f05e75a73a74da6
+  data.tar.gz: 5ec7e76b3ec7fe9e093e5091a0e7e80156153aea
+SHA512:
+  metadata.gz: 9b8b2ce54523d97a6107b334342578af32f865281ceccb891f035cd55d0df119f267f510713e3e893ed6cb4a6be4af278648f22f3c77364ec0cc5d7e4ab15635
+  data.tar.gz: faae23fd3346d6957260ea77836ec6162e15d562017723d6328e5f386eecc3c4628fbe54513d579febcf97118303ece2d2ef9de505f5cab2752a897683c62b9a

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+cucumber

data/.travis.yml

@@ -0,0 +1,16 @@
+rvm:
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3
+  - jruby
+
+# whitelist
+branches:
+  only:
+    - master
+
+notifications:
+  email:
+    - cukes-devs@googlegroups.com
+  irc:
+    - "irc.freenode.org#cucumber"

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (C) 2013 The Cucumber Organisation
+
+MIT License (Expat)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,9 @@
+cucumber-ruby-core
+==================
+
+[![Build Status](https://secure.travis-ci.org/cucumber/cucumber-ruby-core.png)](http://travis-ci.org/cucumber/cucumber-ruby-core)
+[![Code
+Climate](https://codeclimate.com/github/cucumber/cucumber-ruby-core.png)](https://codeclimate.com/github/cucumber/cucumber-ruby-core)
+[![Coverage Status](https://coveralls.io/repos/cucumber/cucumber-ruby-core/badge.png?branch=master)](https://coveralls.io/r/cucumber/cucumber-ruby-core?branch=master)
+
+Core library for the Ruby flavour of Cucumber

data/Rakefile

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require 'rubygems'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.ruby_opts  = %w[-r./spec/coverage -w]
+  t.rspec_opts = %w[--color]
+end
+
+require_relative 'spec/capture_warnings'
+include CaptureWarnings
+namespace :spec do
+  task :warnings do
+    report_warnings do
+      Rake::Task['spec'].invoke
+    end
+  end
+end
+
+task default: ['spec:warnings']

data/cucumber-core.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "cucumber/core/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'cucumber-core'
+  s.version     = Cucumber::Core::Version
+  s.authors     = ["Aslak Hellesøy", "Matt Wynne", "Steve Tooke", "Oleg Sukhodolsky", "Tom Brand"]
+  s.description = 'Core library for the Cucumber BDD app'
+  s.summary     = "cucumber-core-#{s.version}"
+  s.email       = 'cukes@googlegroups.com'
+  s.homepage    = "http://cukes.info"
+  s.platform    = Gem::Platform::RUBY
+  s.license     = "MIT"
+  s.required_ruby_version = ">= 1.9.3"
+
+  s.add_dependency 'gherkin', '~> 2.12.0'
+
+  s.add_development_dependency 'bundler',   '>= 1.3.5'
+  s.add_development_dependency 'rake',      '>= 0.9.2'
+  s.add_development_dependency 'rspec',     '>= 2.13'
+  s.add_development_dependency 'unindent',  '>= 1.0'
+
+  # For coverage reports
+  s.add_development_dependency 'coveralls', '~> 0.7'
+
+  s.rubygems_version = ">= 1.6.1"
+  s.files            = `git ls-files`.split("\n").reject {|path| path =~ /\.gitignore$/ }
+  s.test_files       = `git ls-files -- spec/*`.split("\n")
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.require_path     = "lib"
+end

data/lib/cucumber/core.rb

@@ -0,0 +1,37 @@
+require 'cucumber/core/gherkin/parser'
+require 'cucumber/core/compiler'
+require 'cucumber/core/test/runner'
+require 'cucumber/core/test/mapper'
+require 'cucumber/core/test/hook_compiler'
+
+module Cucumber
+  module Core
+
+    def parse(gherkin_documents, compiler)
+      parser = Core::Gherkin::Parser.new(compiler)
+      gherkin_documents.each do |document|
+        parser.document document
+      end
+      parser.done
+      self
+    end
+
+    def compile(gherkin_documents, last_receiver, filters = [])
+      first_receiver = filters.reduce(last_receiver) do |receiver, (filter_type, args)|
+        filter_type.new(*args + [receiver])
+      end
+      compiler = Compiler.new(first_receiver)
+      parse gherkin_documents, compiler
+      self
+    end
+
+    def execute(gherkin_documents, mappings, report, filters = [], run_options = {})
+      receiver = Test::Runner.new(report, run_options)
+      filters << [Test::HookCompiler, [mappings]]
+      filters << [Test::Mapper, [mappings]]
+      compile gherkin_documents, receiver, filters
+      self
+    end
+
+  end
+end

data/lib/cucumber/core/ast.rb

@@ -0,0 +1,13 @@
+require 'cucumber/core/ast/comment'
+require 'cucumber/core/ast/tag'
+require 'cucumber/core/ast/feature'
+require 'cucumber/core/ast/empty_background'
+require 'cucumber/core/ast/background'
+require 'cucumber/core/ast/scenario'
+require 'cucumber/core/ast/step'
+require 'cucumber/core/ast/multiline_argument'
+require 'cucumber/core/ast/doc_string'
+require 'cucumber/core/ast/data_table'
+require 'cucumber/core/ast/scenario_outline'
+require 'cucumber/core/ast/outline_step'
+require 'cucumber/core/ast/examples_table'

data/lib/cucumber/core/ast/background.rb

@@ -0,0 +1,33 @@
+require 'cucumber/initializer'
+require 'cucumber/core/ast/names'
+require 'cucumber/core/ast/location'
+require 'cucumber/core/ast/describes_itself'
+
+module Cucumber
+  module Core
+    module Ast
+      class Background
+        include Names
+        include HasLocation
+        include DescribesItself
+
+        include Cucumber.initializer(:gherkin_statement, :language, :location, :comments, :keyword, :title, :description, :raw_steps)
+
+        attr_accessor :feature
+        attr_accessor :comments, :keyword, :location
+        attr_reader   :gherkin_statement
+
+        def children
+          raw_steps
+        end
+
+        private
+
+        def description_for_visitors
+          :background
+        end
+
+      end
+    end
+  end
+end

data/lib/cucumber/core/ast/comment.rb

@@ -0,0 +1,17 @@
+require 'cucumber/initializer'
+require 'cucumber/core/ast/location'
+
+module Cucumber
+  module Core
+    module Ast
+      class Comment
+        include HasLocation
+        include Cucumber.initializer :location, :value
+
+        def to_s
+          value
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/ast/data_table.rb

@@ -0,0 +1,326 @@
+require 'gherkin/rubify'
+require 'gherkin/lexer/i18n_lexer'
+require 'gherkin/formatter/escaping'
+require 'cucumber/core/ast/describes_itself'
+require 'cucumber/core/ast/location'
+
+module Cucumber
+  module Core
+    module Ast
+      # Step Definitions that match a plain text Step with a multiline argument table
+      # will receive it as an instance of DataTable. A DataTable object holds the data of a
+      # table parsed from a feature file and lets you access and manipulate the data
+      # in different ways.
+      #
+      # For example:
+      #
+      #   Given I have:
+      #     | a | b |
+      #     | c | d |
+      #
+      # And a matching StepDefinition:
+      #
+      #   Given /I have:/ do |table|
+      #     data = table.raw
+      #   end
+      #
+      # This will store <tt>[['a', 'b'], ['c', 'd']]</tt> in the <tt>data</tt> variable.
+      #
+      class DataTable
+        include DescribesItself
+        include HasLocation
+
+        class Builder
+          attr_reader :rows
+
+          def initialize
+            @rows = []
+          end
+
+          def row(row, line_number)
+            @rows << row
+          end
+
+          def eof
+          end
+        end
+
+        include ::Gherkin::Rubify
+
+        NULL_CONVERSIONS = Hash.new({ :strict => false, :proc => lambda{ |cell_value| cell_value } }).freeze
+
+        attr_accessor :file
+
+        def self.default_arg_name #:nodoc:
+          "table"
+        end
+
+        def self.parse(text, uri, location)
+          builder = Builder.new
+          lexer = ::Gherkin::Lexer::I18nLexer.new(builder)
+          lexer.scan(text)
+          new(builder.rows, location)
+        end
+
+        # Creates a new instance. +raw+ should be an Array of Array of String
+        # or an Array of Hash
+        # You don't typically create your own DataTable objects - Cucumber will do
+        # it internally and pass them to your Step Definitions.
+        #
+        def initialize(raw, location)
+          @cells_class = Cells
+          @cell_class = Cell
+          raw = ensure_array_of_array(rubify(raw))
+          # Verify that it's square
+          raw.transpose
+          create_cell_matrix(raw)
+          @location = location
+        end
+
+        def to_step_definition_arg
+          dup
+        end
+
+        # Creates a copy of this table
+        #
+        def dup
+          self.class.new(raw.dup, location)
+        end
+
+        # Returns a new, transposed table. Example:
+        #
+        #   | a | 7 | 4 |
+        #   | b | 9 | 2 |
+        #
+        # Gets converted into the following:
+        #
+        #   | a | b |
+        #   | 7 | 9 |
+        #   | 4 | 2 |
+        #
+        def transpose
+          self.class.new(raw.transpose, location)
+        end
+
+        def map(&block)
+          new_raw = raw.map do |row|
+            row.map(&block)
+          end
+
+          self.class.new(new_raw, location)
+        end
+
+        # Converts this table into an Array of Hash where the keys of each
+        # Hash are the headers in the table. For example, a DataTable built from
+        # the following plain text:
+        #
+        #   | a | b | sum |
+        #   | 2 | 3 | 5   |
+        #   | 7 | 9 | 16  |
+        #
+        # Gets converted into the following:
+        #
+        #   [{'a' => '2', 'b' => '3', 'sum' => '5'}, {'a' => '7', 'b' => '9', 'sum' => '16'}]
+        #
+        def hashes
+          build_hashes
+        end
+
+        # Converts this table into a Hash where the first column is
+        # used as keys and the second column is used as values
+        #
+        #   | a | 2 |
+        #   | b | 3 |
+        #
+        # Gets converted into the following:
+        #
+        #   {'a' => '2', 'b' => '3'}
+        #
+        # The table must be exactly two columns wide
+        #
+        def rows_hash
+          verify_table_width(2)
+          self.transpose.hashes[0]
+        end
+
+        # Gets the raw data of this table. For example, a DataTable built from
+        # the following plain text:
+        #
+        #   | a | b |
+        #   | c | d |
+        #
+        # gets converted into the following:
+        #
+        #   [['a', 'b'], ['c', 'd']]
+        #
+        def raw
+          cell_matrix.map do |row|
+            row.map do |cell|
+              cell.value
+            end
+          end
+        end
+
+        def column_names #:nodoc:
+          cell_matrix[0].map { |cell| cell.value }
+        end
+
+        def rows
+          hashes.map do |hash|
+            hash.values_at(*headers)
+          end
+        end
+
+        # For testing only
+        def to_sexp #:nodoc:
+          [:table, *cells_rows.map{|row| row.to_sexp}]
+        end
+
+        def to_hash(cells) #:nodoc:
+          hash = Hash.new do |the_hash, key|
+            the_hash[key.to_s] if key.is_a?(Symbol)
+          end
+          column_names.each_with_index do |column_name, column_index|
+            hash[column_name] = cells.value(column_index)
+          end
+          hash
+        end
+
+        def verify_table_width(width) #:nodoc:
+          raise %{The table must have exactly #{width} columns} unless raw[0].size == width
+        end
+
+        def cells_rows #:nodoc:
+          cell_matrix.map do |cell_row|
+            @cells_class.new(self, cell_row)
+          end
+        end
+
+        def headers #:nodoc:
+          raw.first
+        end
+
+        def cell_matrix #:nodoc:
+          @cell_matrix
+        end
+
+        def col_width(col) #:nodoc:
+          columns[col].__send__(:width)
+        end
+
+        def ==(other)
+          other.class == self.class && raw == other.raw
+        end
+
+        def inspect
+          raw.inspect
+        end
+
+        private
+
+        TO_S_PREFIXES = Hash.new('    ')
+        TO_S_PREFIXES[:comment]   = '(+) '
+        TO_S_PREFIXES[:undefined] = '(-) '
+
+        def build_hashes
+          cells_rows[1..-1].map do |row|
+            row.to_hash
+          end
+        end
+
+        def create_cell_matrix(raw) #:nodoc:
+          @cell_matrix = raw.map do |raw_row|
+            line = raw_row.line rescue -1
+            raw_row.map do |raw_cell|
+              new_cell(raw_cell, line)
+            end
+          end
+        end
+
+        def columns #:nodoc:
+          cell_matrix.transpose.map do |cell_row|
+            @cells_class.new(self, cell_row)
+          end
+        end
+
+        def new_cell(raw_cell, line) #:nodoc:
+          @cell_class.new(raw_cell, self, line)
+        end
+
+        def ensure_array_of_array(array)
+          Hash === array[0] ? hashes_to_array(array) : array
+        end
+
+        def hashes_to_array(hashes) #:nodoc:
+          header = hashes[0].keys.sort
+          [header] + hashes.map{|hash| header.map{|key| hash[key]}}
+        end
+
+        def description_for_visitors
+          :table
+        end
+
+        # Represents a row of cells or columns of cells
+        class Cells #:nodoc:
+          include Enumerable
+          include Gherkin::Formatter::Escaping
+
+          attr_reader :exception
+
+          def initialize(table, cells)
+            @table, @cells = table, cells
+          end
+
+          # For testing only
+          def to_sexp #:nodoc:
+            [:row, line, *@cells.map{|cell| cell.to_sexp}]
+          end
+
+          def to_hash #:nodoc:
+            @to_hash ||= @table.to_hash(self)
+          end
+
+          def value(n) #:nodoc:
+            self[n].value
+          end
+
+          def [](n)
+            @cells[n]
+          end
+
+          def line
+            @cells[0].line
+          end
+
+          private
+
+          def width
+            map{|cell| cell.value ? escape_cell(cell.value.to_s).unpack('U*').length : 0}.max
+          end
+
+          def each(&proc)
+            @cells.each(&proc)
+          end
+        end
+
+        class Cell #:nodoc:
+          attr_reader :line, :table
+          attr_accessor :status, :value
+
+          def initialize(value, table, line)
+            @value, @table, @line = value, table, line
+          end
+
+          def inspect!
+            @value = "(i) #{value.inspect}"
+          end
+
+          # For testing only
+          def to_sexp #:nodoc:
+            [:cell, @value]
+          end
+        end
+      end
+    end
+  end
+end