cuke_modeler 0.0.1

data/features/step_definitions/table_steps.rb

@@ -0,0 +1,54 @@
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?table has the following contents:$/ do |file, test, step, contents|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = contents.raw
+
+  @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.row_elements.collect { |row| row.cells }.should == expected
+  # todo - remove once #contents is no longer supported
+  @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents.should == expected
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?table correctly stores its underlying implementation$/ do |file, test, step|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  raw_element = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.raw_element
+
+  raw_element.is_a?(Array).should be_true
+  raw_element.each { |row| row.has_key?('cells').should be_true }
+end
+
+Given(/^a table row element$/) do
+  @element = CukeModeler::TableRow.new
+end
+
+When(/^the table row element has no cells$/) do
+  @element.cells = []
+end
+
+Given(/^a table row element based on the following gherkin:$/) do |row_text|
+  @element = CukeModeler::TableRow.new(row_text)
+end
+
+Then(/^the table row has convenient output$/) do
+  @parsed_files.first.feature.tests.first.steps.first.block.row_elements.first.method(:to_s).owner.should == CukeModeler::TableRow
+end
+
+Given(/^a table element$/) do
+  @element = CukeModeler::Table.new
+end
+
+When(/^the table element has no rows$/) do
+  @element.row_elements = []
+end
+
+Then(/^the table has convenient output$/) do
+  @parsed_files.first.feature.tests.first.steps.first.block.method(:to_s).owner.should == CukeModeler::Table
+end
+
+Given(/^a table element based on the following gherkin:$/) do |table_text|
+  @element = CukeModeler::Table.new(table_text)
+end

data/features/step_definitions/tag_steps.rb

@@ -0,0 +1,61 @@
+Then /^the feature tag correctly stores its underlying implementation$/ do
+  raw_element = @parsed_files.first.feature.tag_elements.first.raw_element
+
+  raw_element.has_key?('name').should be_true
+end
+
+When(/^the test tag correctly stores its underlying implementation$/) do
+  raw_element = @parsed_files.first.feature.tests.first.tag_elements.first.raw_element
+
+  raw_element.has_key?('name').should be_true
+end
+
+When(/^the example tag correctly stores its underlying implementation$/) do
+  raw_element = @parsed_files.first.feature.tests.first.examples.first.tag_elements.first.raw_element
+
+  raw_element.has_key?('name').should be_true
+end
+
+Then(/^the feature tag name is "([^"]*)"$/) do |tag_name|
+  tag = @parsed_files.first.feature.tag_elements.first
+
+  tag.name.should == tag_name
+end
+
+When(/^the test tag name is "([^"]*)"$/) do |tag_name|
+  tag = @parsed_files.first.feature.tests.first.tag_elements.first
+
+  tag.name.should == tag_name
+end
+
+When(/^the example tag name is "([^"]*)"$/) do |tag_name|
+  tag = @parsed_files.first.feature.tests.first.examples.first.tag_elements.first
+
+  tag.name.should == tag_name
+end
+
+Then(/^the feature tag source line "([^"]*)"$/) do |line|
+  tag = @parsed_files.first.feature.tag_elements.first
+
+  tag.source_line.should == line
+end
+
+When(/^the test tag source line "([^"]*)"$/) do |line|
+  tag = @parsed_files.first.feature.tests.first.tag_elements.first
+
+  tag.source_line.should == line
+end
+
+When(/^the example tag source line "([^"]*)"$/) do |line|
+  tag = @parsed_files.first.feature.tests.first.examples.first.tag_elements.first
+
+  tag.source_line.should == line
+end
+
+Then(/^the tag has convenient output$/) do
+  @parsed_files.first.feature.tag_elements.first.method(:to_s).owner.should == CukeModeler::Tag
+end
+
+Given(/^a tag element based on the following gherkin:$/) do |tag_text|
+  @element = CukeModeler::Tag.new(tag_text)
+end

data/features/step_definitions/test_steps.rb

@@ -0,0 +1,114 @@
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? is found to have the following properties:$/ do |file, test, properties|
+  file ||= 1
+  test ||= 1
+
+  properties = properties.rows_hash
+
+  properties.each do |property, value|
+    assert value == @parsed_files[file - 1].feature.tests[test - 1].send(property.to_sym).to_s
+  end
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? has the following description:$/ do |file, test, text|
+  file ||= 1
+  test ||= 1
+
+  new_description = @parsed_files[file - 1].feature.tests[test - 1].description_text
+  old_description = @parsed_files[file - 1].feature.tests[test - 1].description
+
+  new_description.should == text
+  old_description.should == remove_whitespace(text)
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? steps are as follows:$/ do |file, test, steps|
+  file ||= 1
+  test ||= 1
+
+  steps = steps.raw.flatten.collect do |step|
+    if step.start_with? "'"
+      step.slice(1..step.length - 2)
+    else
+      step
+    end
+  end
+
+  actual_steps = Array.new.tap do |steps|
+    @parsed_files[file - 1].feature.tests[test - 1].steps.each do |step|
+      steps << step.base
+    end
+  end
+
+  assert actual_steps.flatten == steps
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? is found to have the following tags:$/ do |file, test, expected_tags|
+  file ||= 1
+  test ||= 1
+
+  expected_tags = expected_tags.raw.flatten
+
+  @parsed_files[file - 1].feature.tests[test - 1].tags.should == expected_tags
+  @parsed_files[file - 1].feature.tests[test - 1].tag_elements.collect { |tag| tag.name }.should == expected_tags
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? is found to have the following applied tags:$/ do |file, test, expected_tags|
+  file ||= 1
+  test ||= 1
+
+  expected_tags = expected_tags.raw.flatten
+
+  @parsed_files[file - 1].feature.tests[test - 1].applied_tags.should == expected_tags
+  @parsed_files[file - 1].feature.tests[test - 1].applied_tag_elements.collect { |tag| tag.name }.should == expected_tags
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? step "([^"]*)" has the following block:$/ do |file, test, step, block|
+  file ||= 1
+  test ||= 1
+
+  block = block.raw.flatten.collect do |line|
+    if line.start_with? "'"
+      line.slice(1..line.length - 2)
+    else
+      line
+    end
+  end
+
+  assert @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block == block
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? is equal to test "([^"]*)"$/ do |file, first_test, second_test|
+  file ||= 1
+  first_test ||= 1
+
+  expected = true
+  actual = @parsed_files[file - 1].feature.tests[first_test - 1] == @parsed_files[file - 1].feature.tests[second_test - 1]
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? is not equal to test "([^"]*)"$/ do |file, first_test, second_test|
+  file ||= 1
+  first_test ||= 1
+
+  assert @parsed_files[file - 1].feature.tests[first_test - 1] != @parsed_files[file - 1].feature.tests[second_test - 1]
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? correctly stores its underlying implementation$/ do |file, test|
+  file ||= 1
+  test ||= 1
+
+  raw_element = @parsed_files[file - 1].feature.tests[test - 1].raw_element
+
+  expected = ['Scenario', 'Scenario Outline']
+  actual = raw_element['keyword']
+
+  expected.include?(actual).should be_true
+end
+
+Then(/^the scenario has convenient output$/) do
+  @parsed_files.first.feature.tests.first.method(:to_s).owner.should == CukeModeler::Scenario
+end
+
+Given(/^a scenario element based on the following gherkin:$/) do |scenario_text|
+  @element = CukeModeler::Scenario.new(scenario_text)
+end

data/features/step_definitions/verification_steps.rb

@@ -0,0 +1,9 @@
+Then(/^the following text is provided:$/) do |expected_text|
+  expected_text.sub!('path_to', @default_file_directory)
+
+  @output.should == expected_text
+end
+
+Then(/^the text provided is "(.*)"$/) do |text_string|
+  @output.should == text_string.gsub('\n', "\n")
+end

data/features/support/env.rb

@@ -0,0 +1,27 @@
+unless RUBY_VERSION.to_s < '1.9.0'
+  require 'simplecov'
+  SimpleCov.command_name('cucumber_tests')
+end
+
+require 'test/unit/assertions'
+include Test::Unit::Assertions
+
+require File.dirname(__FILE__) + '/../../lib/cuke_modeler'
+
+
+Before do
+  @default_file_directory = "#{File.dirname(__FILE__)}/../temp_files"
+  @default_feature_file_name = 'test_feature.feature'
+  @default_step_file_name = 'test_steps.rb'
+  @test_file_directory = "#{File.dirname(__FILE__)}/../test_files"
+  @test_step_file_location = "#{@default_file_directory}/#{@default_step_file_name}"
+  @spec_directory = "#{File.dirname(__FILE__)}/../../spec"
+
+  FileUtils.mkdir(@default_file_directory)
+end
+
+After do
+  FileUtils.remove_dir(@default_file_directory, true)
+end
+
+

data/features/support/transforms.rb

@@ -0,0 +1,3 @@
+Transform /^(-?\d+)$/ do |number|
+  number.to_i
+end

data/lib/cuke_modeler.rb

@@ -0,0 +1,29 @@
+require "cuke_modeler/version"
+
+require 'cuke_modeler/parsing'
+require 'cuke_modeler/containing'
+require 'cuke_modeler/taggable'
+require 'cuke_modeler/raw'
+require 'cuke_modeler/sourceable'
+require 'cuke_modeler/nested'
+require 'cuke_modeler/feature_file'
+require 'cuke_modeler/directory'
+require 'cuke_modeler/feature_element.rb'
+require 'cuke_modeler/feature'
+require 'cuke_modeler/test_element.rb'
+require 'cuke_modeler/background'
+require 'cuke_modeler/scenario'
+require 'cuke_modeler/outline'
+require 'cuke_modeler/example'
+require 'cuke_modeler/step'
+require 'cuke_modeler/doc_string'
+require 'cuke_modeler/table'
+require 'cuke_modeler/world'
+require 'cuke_modeler/row'
+require 'cuke_modeler/table_row'
+require 'cuke_modeler/tag'
+
+
+module CukeModeler
+  # Your code goes here...
+end

data/lib/cuke_modeler/background.rb

@@ -0,0 +1,38 @@
+module CukeModeler
+
+  # A class modeling a Cucumber feature's Background.
+
+  class Background < TestElement
+
+    # Creates a new Background object and, if *source* is provided, populates
+    # the object.
+    def initialize(source = nil)
+      parsed_background = process_source(source)
+
+      super(parsed_background)
+
+      build_background(parsed_background) if parsed_background
+    end
+
+    # Returns gherkin representation of the background.
+    def to_s
+      text = ''
+
+      text << "Background:#{name_output_string}"
+      text << "\n" + description_output_string unless description_text.empty?
+      text << "\n" unless steps.empty? || description_text.empty?
+      text << "\n" + steps_output_string unless steps.empty?
+
+      text
+    end
+
+
+    private
+
+
+    def build_background(parsed_background)
+      # Just a stub in case something specific needs to be done
+    end
+
+  end
+end

data/lib/cuke_modeler/containing.rb

@@ -0,0 +1,18 @@
+module CukeModeler
+
+
+  module Containing
+
+
+    private
+
+
+    def build_child_element(clazz, element_data)
+      element = clazz.new(element_data)
+      element.parent_element = self
+
+      element
+    end
+
+  end
+end

data/lib/cuke_modeler/directory.rb

@@ -0,0 +1,86 @@
+module CukeModeler
+
+  # A class modeling a directory containing .feature files.
+
+  class Directory
+
+    include Containing
+    include Nested
+
+
+    # The FeatureFile objects contained by the Directory
+    attr_accessor :feature_files
+
+    # The Directory objects contained by the Directory
+    attr_accessor :directories
+
+
+    # Creates a new Directory object and, if *directory_parsed* is provided,
+    # populates the object.
+    def initialize(directory_parsed = nil)
+      @directory = directory_parsed
+
+      @feature_files = []
+      @directories = []
+
+      if directory_parsed
+        raise(ArgumentError, "Unknown directory: #{directory_parsed.inspect}") unless File.exists?(directory_parsed)
+        build_directory
+      end
+    end
+
+    # Returns the name of the directory.
+    def name
+      File.basename(@directory.gsub('\\', '/'))
+    end
+
+    # Returns the path of the directory.
+    def path
+      @directory
+    end
+
+    # Returns the number of sub-directories contained in the directory.
+    def directory_count
+      @directories.count
+    end
+
+    # Returns the number of features files contained in the directory.
+    def feature_file_count
+      @feature_files.count
+    end
+
+    # Returns the immediate child elements of the directory (i.e. its Directory
+    # and FeatureFile objects).
+    def contains
+      @feature_files + @directories
+    end
+
+    # Returns the path of the directory.
+    def to_s
+      path.to_s
+    end
+
+
+    private
+
+
+    def build_directory
+      entries = Dir.entries(@directory)
+      entries.delete '.'
+      entries.delete '..'
+
+      entries.each do |entry|
+        entry = "#{@directory}/#{entry}"
+
+        case
+          when File.directory?(entry)
+            @directories << build_child_element(Directory, entry)
+          when entry =~ /\.feature$/
+            @feature_files << build_child_element(FeatureFile, entry)
+        end
+      end
+
+    end
+
+  end
+end