cucumber_analytics 0.0.9 → 1.0.0

data/features/step_definitions/background_steps.rb

@@ -3,25 +3,23 @@ Then /^the(?: feature "([^"]*)")? background is found to have the following prop
   properties = properties.rows_hash
 
   properties.each do |property, expected_value|
-    assert expected_value == @parsed_files[file - 1].feature.background.send(property.to_sym).to_s
+    expected = expected_value
+    actual = @parsed_files[file - 1].feature.background.send(property.to_sym).to_s
+
+    actual.should == expected
   end
 end
 
 Then /^the(?: feature "([^"]*)")? background's descriptive lines are as follows:$/ do |file, lines|
   file ||= 1
   expected_description = lines.raw.flatten
+  actual_description = @parsed_files[file - 1].feature.background.description
 
-  assert @parsed_files[file - 1].feature.background.description == expected_description
+  actual_description.should == expected_description
 end
 
-Then /^the(?: feature "([^"]*)")? background's steps(?: "([^"]*)" arguments)?(?: "([^"]*)" keywords)? are as follows:$/ do |file, arguments, keywords, steps|
+Then /^the(?: feature "([^"]*)")? background's steps are as follows:$/ do |file, steps|
   file ||= 1
-  arguments ||= 'with'
-  keywords ||= 'with'
-  translate = {'with' => true,
-               'without' => false}
-
-  options = {:with_keywords => translate[keywords], :with_arguments => translate[arguments]}
 
   steps = steps.raw.flatten.collect do |step|
     if step.start_with? "'"
@@ -33,11 +31,14 @@ Then /^the(?: feature "([^"]*)")? background's steps(?: "([^"]*)" arguments)?(?:
 
   actual_steps = Array.new.tap do |steps|
     @parsed_files[file - 1].feature.background.steps.each do |step|
-      steps << step.step_text(options)
+      steps << step.base
     end
   end
 
-  assert actual_steps.flatten == steps
+  expected = steps
+  actual = actual_steps.flatten
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
 
 When /^step "([^"]*)" of the background (?:of feature "([^"]*)" )?has the following block:$/ do |step, file, block|

data/features/step_definitions/directory_steps.rb

@@ -7,7 +7,10 @@ Then /^(?:the )?directory(?: "([^"]*)")? is found to have the following properti
       expected_value.sub!('path_to', @default_file_directory)
     end
 
-    assert expected_value == @parsed_directories[directory - 1].send(property.to_sym).to_s
+    expected = expected_value
+    actual = @parsed_directories[directory - 1].send(property.to_sym).to_s
+
+    assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
   end
 end
 
@@ -23,7 +26,7 @@ When /^(?:the )?directory(?: "([^"]*)")? directories are as follows:$/ do |direc
   directory ||= 1
 
   expected = directories.raw.flatten.sort
-  actual = @parsed_directories[directory - 1].feature_directories.collect { |sub_directory| sub_directory.name }
+  actual = @parsed_directories[directory - 1].directories.collect { |sub_directory| sub_directory.name }
 
   assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
@@ -32,7 +35,7 @@ When /^(?:the )?directory(?: "([^"]*)")? has no directories$/ do |directory|
   directory ||= 1
 
   expected = []
-  actual = @parsed_directories[directory - 1].feature_directories
+  actual = @parsed_directories[directory - 1].directories
 
   assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end

data/features/step_definitions/doc_string_steps.rb

@@ -0,0 +1,50 @@
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string content type is "([^"]*)"$/ do |file, test, step, type|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = type
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.content_type
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string has no content type$/ do |file, test, step|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = nil
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.content_type
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string has the following contents:$/ do |file, test, step, contents|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = contents.raw.flatten.collect do |cell_value|
+    if cell_value.start_with? "'"
+      cell_value.slice(1..cell_value.length - 2)
+    else
+      cell_value
+    end
+  end
+
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string contents are empty$/ do |file, test, step|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = []
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end

data/features/step_definitions/{file_steps.rb → feature_file_steps.rb}

@@ -7,14 +7,20 @@ Then /^(?:the )?file(?: "([^"]*)")? is found to have the following properties:$/
       expected_value.sub!('path_to', @test_directory)
     end
 
-    assert expected_value == @parsed_files[file - 1].send(property.to_sym).to_s
+    expected = expected_value
+    actual = @parsed_files[file - 1].send(property.to_sym).to_s
+
+    assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
   end
 end
 
 When /^(?:the )?file(?: "([^"]*)")? features are as follows:$/ do |file, feature|
   file ||= 1
 
-  assert @parsed_files[file - 1].feature.name == feature.raw.flatten.first
+  expected = feature.raw.flatten.first
+  actual = @parsed_files[file - 1].feature.name
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
 
 When /^(?:the )?file(?: "([^"]*)")? has no features$/ do |file|

data/features/step_definitions/feature_steps.rb

@@ -18,9 +18,10 @@ Then /^the descriptive lines of feature "([^"]*)" are as follows:$/ do |file, li
 end
 
 Then /^feature "([^"]*)" is found to have the following tags:$/ do |file, tags|
-  expected_tags = tags.raw.flatten
+  expected = tags.raw.flatten
+  actual = @parsed_files[file - 1].feature.tags
 
-  assert @parsed_files[file - 1].feature.tags == expected_tags
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
 
 Then /^feature "([^"]*)" has no descriptive lines$/ do |file|
@@ -44,13 +45,16 @@ When /^(?:the )?feature(?: "([^"]*)")? outlines are as follows:$/ do |file, outl
 
   actual_outlines = @parsed_files[file - 1].feature.outlines.collect { |outline| outline.name }
 
-  assert actual_outlines.flatten.sort == outlines.raw.flatten.sort
+  expected = outlines.raw.flatten.sort
+  actual = actual_outlines.flatten.sort
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
 
 When /^(?:the )?feature(?: "([^"]*)")? background is as follows:$/ do |file, background|
   file ||= 1
 
-  assert @parsed_files[file - 1].feature.background.name == background.raw.flatten.first
+  @parsed_files[file - 1].feature.background.name.should  == background.raw.flatten.first
 end
 
 When /^feature "([^"]*)" has no scenarios$/ do |file|

data/features/step_definitions/outline_steps.rb

@@ -2,9 +2,10 @@ When /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example blocks are as
   file ||= 1
   test ||= 1
 
-  names = names.raw.flatten
+  expected = names.raw.flatten
+  actual = @parsed_files[file - 1].feature.tests[test - 1].examples.collect { |example| example.name }
 
-  assert @parsed_files[file - 1].feature.tests[test - 1].examples.collect { |example| example.name } == names
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
 
 Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^"]*)")? is found to have the following properties:$/ do |file, test, example, properties|
@@ -34,9 +35,11 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^
   test ||= 1
   example ||= 1
 
-  tags = tags.raw.flatten
 
-  assert @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].tags == tags
+  expected = tags.raw.flatten
+  actual = @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].tags
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
 
 Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^"]*)")? is found to have the following applied tags:$/ do |file, test, example, tags|
@@ -57,7 +60,10 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^
   test ||= 1
   example ||= 1
 
-  assert @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].tags == []
+  expected = []
+  actual = @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].tags
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
 
 Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^"]*)")? rows are as follows:$/ do |file, test, example, rows|
@@ -108,7 +114,7 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^
   parameters = parameters.raw.flatten
 
   expected = parameters
-  actual =@parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].parameters
+  actual = @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].parameters
 
   assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end

data/features/step_definitions/setup_steps.rb

@@ -12,7 +12,7 @@ When /^the file(?: "([^"]*)")? is read$/ do |file_name|
   @test_directory ||= @default_file_directory
   file_name ||= @default_feature_file_name
 
-  @parsed_files << CucumberAnalytics::ParsedFile.new("#{@test_directory}/#{file_name}")
+  @parsed_files << CucumberAnalytics::FeatureFile.new("#{@test_directory}/#{file_name}")
 end
 
 When /^the step definition file "([^"]*)" is read$/ do |file_name|
@@ -37,7 +37,7 @@ When /^the directory(?: "([^"]*)")? is read$/ do |directory_name|
   @parsed_directories ||= []
   @test_directory = "#{@default_file_directory}/#{directory_name}" if directory_name
 
-  @parsed_directories << CucumberAnalytics::ParsedDirectory.new(@test_directory)
+  @parsed_directories << CucumberAnalytics::Directory.new(@test_directory)
 end
 
 When /^the following step definition file(?: "([^"]*)")?:$/ do |file_name, file_text|

data/features/step_definitions/spec_steps.rb

@@ -1,15 +1,18 @@
 Given /^that there are "([^"]*)" detailing models$/ do |spec_file|
-  fail "The spec file does not exist: #{spec_file}" unless File.exists?(File.join(SPEC_DIRECTORY, spec_file))
+  sub_directory = spec_file =~ /integration/ ? 'integration' : 'unit'
+  spec_file = "#{SPEC_DIRECTORY}/#{sub_directory}/#{spec_file}"
+
+  fail "The spec file does not exist: #{spec_file}" unless File.exists?(spec_file)
 
   @spec_file = spec_file
 end
 
 When /^the corresponding unit tests are run$/ do
-  command = "rspec spec/#{@spec_file}"
+  command = "rspec #{@spec_file}"
 
   @specs_passed = system(command)
 end
 
 Then /^all of those specifications are met$/ do
-  fail "There were unmet specifications." unless @specs_passed
+  fail "There were unmet specifications in '#{@spec_file}'." unless @specs_passed
 end

data/features/step_definitions/step_steps.rb

@@ -0,0 +1,91 @@
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? step(?: "([^"]*)")? keyword is "([^"]*)"$/ do |file, test, step, keyword|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = keyword
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].keyword
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?step(?: "([^"]*)")? has the following block:$/ do |file, test, step, block|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = block.raw.flatten.collect do |cell_value|
+    if cell_value.start_with? "'"
+      cell_value.slice(1..cell_value.length - 2)
+    else
+      cell_value
+    end
+  end
+
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.flatten
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?step(?: "([^"]*)")? has no block$/ do |file, test, step|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = nil
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block
+
+  actual.should == expected
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? step(?: "([^"]*)")? text is "([^"]*)"$/ do |file, test, step, text|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = text
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].base
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? step(?: "([^"]*)")? arguments are:$/ do |file, test, step, arguments|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = arguments.raw.flatten
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].arguments
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? step(?: "([^"]*)")? has no arguments$/ do |file, test, step|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = []
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].arguments
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?step(?: "([^"]*)")? has a "([^"]*)"$/ do |file, test, step, type|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  case type
+    when 'doc string'
+      expected = CucumberAnalytics::DocString
+    when 'table'
+      expected = CucumberAnalytics::Table
+    else
+      raise(ArgumentError, "Unknown block type: #{type}")
+  end
+
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.class
+
+  actual.should == expected
+end

data/features/step_definitions/table_steps.rb

@@ -0,0 +1,10 @@
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?table has the following contents:$/ do |file, test, step, contents|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = contents.raw
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end

data/features/step_definitions/test_steps.rb

@@ -17,16 +17,9 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? descriptive lines are
   assert @parsed_files[file - 1].feature.tests[test - 1].description == lines
 end
 
-Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? steps(?: "([^"]*)" arguments)?(?: "([^"]*)" keywords)? are as follows:$/ do |file, test, arguments, keywords, steps|
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? steps are as follows:$/ do |file, test, steps|
   file ||= 1
   test ||= 1
-  arguments ||= 'with'
-  keywords ||= 'with'
-  translate = {'with' => true,
-               'without' => false}
-
-  options = {:with_keywords => translate[keywords], :with_arguments => translate[arguments]}
-
 
   steps = steps.raw.flatten.collect do |step|
     if step.start_with? "'"
@@ -38,7 +31,7 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? steps(?: "([^"]*)" ar
 
   actual_steps = Array.new.tap do |steps|
     @parsed_files[file - 1].feature.tests[test - 1].steps.each do |step|
-      steps << step.step_text(options)
+      steps << step.base
     end
   end
 
@@ -84,7 +77,10 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? is equal to 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]
+  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|

data/features/step_definitions/world_steps.rb

@@ -39,7 +39,7 @@ Then /^the(?: "([^"]*)")? steps collected from feature "([^"]*)" background are
       expected_steps = CucumberAnalytics::World.steps_in(container)
   end
 
-  assert expected_steps.collect { |step| step.step_text }.flatten.sort == steps.sort
+  assert expected_steps.collect { |step| step.base }.flatten.sort == steps.sort
 end
 
 Then /^the(?: "([^"]*)")? steps collected from feature "([^"]*)" test "([^"]*)" are as follows:$/ do |defined, file, test, steps|
@@ -56,57 +56,63 @@ Then /^the(?: "([^"]*)")? steps collected from feature "([^"]*)" test "([^"]*)"
       expected_steps = CucumberAnalytics::World.steps_in(container)
   end
 
-  assert expected_steps.collect { |step| step.step_text }.flatten.sort == steps.sort
+  assert expected_steps.collect { |step| step.base }.flatten.sort == steps.sort
 end
 
 When /^the(?: "([^"]*)")? steps collected from (?:the )?feature(?: "([^"]*)")? are as follows:$/ do |defined, file, steps|
   file ||= 1
-  steps = steps.raw.flatten
   container = @parsed_files[file - 1].feature
 
   case defined
     when 'defined'
-      expected_steps = CucumberAnalytics::World.defined_steps_in(container)
+      actual_steps = CucumberAnalytics::World.defined_steps_in(container)
     when 'undefined'
-      expected_steps = CucumberAnalytics::World.undefined_steps_in(container)
+      actual_steps = CucumberAnalytics::World.undefined_steps_in(container)
     else
-      expected_steps = CucumberAnalytics::World.steps_in(container)
+      actual_steps = CucumberAnalytics::World.steps_in(container)
   end
 
-  assert expected_steps.collect { |step| step.step_text }.flatten.sort == steps.sort
+  expected = steps.raw.flatten.sort
+  actual = actual_steps.collect { |step| step.base }.flatten.sort
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
 
 When /^the(?: "([^"]*)")? steps collected from (?:the )?file(?: "([^"]*)")? are as follows:$/ do |defined, file, steps|
   file ||= 1
-  steps = steps.raw.flatten
   container = @parsed_files[file - 1]
 
   case defined
     when 'defined'
-      expected_steps = CucumberAnalytics::World.defined_steps_in(container)
+      actual_steps = CucumberAnalytics::World.defined_steps_in(container)
     when 'undefined'
-      expected_steps = CucumberAnalytics::World.undefined_steps_in(container)
+      actual_steps = CucumberAnalytics::World.undefined_steps_in(container)
     else
-      expected_steps = CucumberAnalytics::World.steps_in(container)
+      actual_steps = CucumberAnalytics::World.steps_in(container)
   end
 
-  assert expected_steps.collect { |step| step.step_text }.flatten.sort == steps.sort
+  expected = steps.raw.flatten.sort
+  actual = actual_steps.collect { |step| step.base }.flatten.sort
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
 
 When /^the(?: "([^"]*)")? steps collected from the directory are as follows:$/ do |defined, steps|
-  steps = steps.raw.flatten
   container = @parsed_directories.last
 
   case defined
     when 'defined'
-      expected_steps = CucumberAnalytics::World.defined_steps_in(container)
+      actual_steps = CucumberAnalytics::World.defined_steps_in(container)
     when 'undefined'
-      expected_steps = CucumberAnalytics::World.undefined_steps_in(container)
+      actual_steps = CucumberAnalytics::World.undefined_steps_in(container)
     else
-      expected_steps = CucumberAnalytics::World.steps_in(container)
+      actual_steps = CucumberAnalytics::World.steps_in(container)
   end
 
-  assert expected_steps.collect { |step| step.step_text }.flatten.sort == steps.sort
+  expected = steps.raw.flatten.sort
+  actual = actual_steps.collect { |step| step.base }.flatten.sort
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
 
 Then /^the tests collected from feature "([^"]*)" are as follows:$/ do |file, tests|
@@ -153,9 +159,12 @@ end
 Then /^the files collected from directory "([^"]*)" are as follows:$/ do |directory, files|
   directory ||= 1
 
-  actual_files = CucumberAnalytics::World.files_in(@parsed_directories[directory - 1]).collect { |file| file.name }
+  actual_files = CucumberAnalytics::World.feature_files_in(@parsed_directories[directory - 1]).collect { |file| file.name }
 
-  assert actual_files.flatten.sort == files.raw.flatten.sort
+  expected = files.raw.flatten.sort
+  actual = actual_files.flatten.sort
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
 
 Then /^the directories collected from directory "([^"]*)" are as follows:$/ do |directory, directories|

data/features/support/env.rb

@@ -7,8 +7,6 @@ include Test::Unit::Assertions
 
 require File.dirname(__FILE__) + '/../../lib/cucumber_analytics'
 
-CucumberAnalytics::Logging.set_log_level(Logger::FATAL)
-
 
 DEFAULT_FEATURE_FILE_NAME = 'test_feature.feature'
 DEFAULT_STEP_FILE_NAME = 'test_steps.rb'

data/lib/cucumber_analytics/background.rb

@@ -0,0 +1,16 @@
+module CucumberAnalytics
+
+  # 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)
+    end
+
+  end
+end

data/lib/cucumber_analytics/containing.rb

@@ -0,0 +1,18 @@
+module CucumberAnalytics
+
+
+  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/cucumber_analytics/directory.rb

@@ -0,0 +1,83 @@
+module CucumberAnalytics
+
+  # A class modeling a directory containing .feature files.
+
+  class Directory
+
+    include Containing
+
+
+    # The FeatureFile objects contained by the Directory
+    attr_accessor :feature_files
+
+    # The Directory objects contained by the Directory
+    attr_accessor :directories
+
+    # The parent object that contains *self*
+    attr_accessor :parent_element
+
+
+    # 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
+
+
+    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