cuke_modeler 0.4.1 → 1.0.0

data/features/step_definitions/test_steps.rb

@@ -1,123 +0,0 @@
-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|
-
-    actual = @parsed_files[file - 1].feature.tests[test - 1].send(property.to_sym).to_s
-    expected = value
-
-    assert(actual == expected, "Expected #{property} to be: #{expected}\n but was: #{actual}")
-  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
-
-  expect(actual_steps.flatten).to eq(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
-
-  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
-    expected = ['Scenario', 'Scenario Outline']
-    actual = raw_element[:keyword]
-  else
-    expected = ['Scenario', 'Scenario Outline']
-    actual = raw_element['keyword']
-  end
-
-  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/lib/cuke_modeler/background.rb

@@ -1,38 +0,0 @@
-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, 'cuke_modeler_stand_alone_background.feature')
-
-      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/directory.rb

@@ -1,83 +0,0 @@
-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
-
-    # The file path of the Directory
-    attr_accessor :path
-
-
-    # Creates a new Directory object and, if *directory_parsed* is provided,
-    # populates the object.
-    def initialize(directory_parsed = nil)
-      @path = 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(@path.gsub('\\', '/')) if @path
-    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(@path)
-      entries.delete '.'
-      entries.delete '..'
-
-      entries.each do |entry|
-        entry = "#{@path}/#{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

data/lib/cuke_modeler/doc_string.rb

@@ -1,87 +0,0 @@
-module CukeModeler
-
-  # A class modeling the Doc String of a Step.
-
-  class DocString
-
-    include Raw
-    include Nested
-
-
-    # The content type associated with the doc string
-    attr_accessor :content_type
-
-    # Deprecated
-    #
-    # The contents of the doc string
-    attr_accessor :contents
-
-    # The contents of the doc string
-    attr_accessor :contents_text
-
-
-    # Creates a new DocString object and, if *source* is provided, populates
-    # the object.
-    def initialize(source = nil)
-      @contents = []
-      @contents_text = ''
-
-      parsed_doc_string = process_source(source)
-
-      build_doc_string(parsed_doc_string) if parsed_doc_string
-    end
-
-    # Returns a gherkin representation of the doc string.
-    def to_s
-      text = "\"\"\"#{content_type_output_string}\n"
-      text << contents_output_string
-      text << '"""'
-    end
-
-
-    private
-
-
-    def process_source(source)
-      case
-        when source.is_a?(String)
-          parse_doc_string(source)
-        else
-          source
-      end
-    end
-
-    def parse_doc_string(source_text)
-      base_file_string = "Feature:\nScenario:\n* step\n"
-      source_text = base_file_string + source_text
-
-      parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_doc_string.feature')
-
-      parsed_file.first['elements'].first['steps'].first['doc_string']
-    end
-
-    def build_doc_string(doc_string)
-      populate_content_type(doc_string)
-      populate_contents(doc_string)
-      populate_raw_element(doc_string)
-    end
-
-    def populate_content_type(doc_string)
-      @content_type = doc_string['content_type'] == "" ? nil : doc_string['content_type']
-    end
-
-    def populate_contents(doc_string)
-      @contents = doc_string['value'].split($/, -1)
-      @contents_text = doc_string['value']
-    end
-
-    def content_type_output_string
-      content_type ? " #{content_type}" : ''
-    end
-
-    def contents_output_string
-      contents_text.empty? ? '' : contents_text.gsub('"""', '\"\"\"') + "\n"
-    end
-
-  end
-end

data/lib/cuke_modeler/example.rb

@@ -1,195 +0,0 @@
-module CukeModeler
-
-  # A class modeling a Cucumber Examples table.
-
-  class Example < FeatureElement
-
-    include Taggable
-    include Containing
-
-
-    # The argument rows in the example table
-    #
-    # todo - Make this a read only method that derives the rows from
-    # the row elements
-    attr_accessor :rows
-
-    # The parameters for the example table
-    #
-    # todo - Make this a read only method that derives the parameters from
-    # the row elements
-    attr_accessor :parameters
-
-    # The row elements in the example table
-    attr_accessor :row_elements
-
-
-    # Creates a new Example object and, if *source* is provided,
-    # populates the object.
-    def initialize(source = nil)
-      parsed_example = process_source(source)
-
-      super(parsed_example)
-
-      @tags = []
-      @tag_elements = []
-      @rows = []
-      @parameters = []
-      @row_elements = []
-
-      build_example(parsed_example) if parsed_example
-    end
-
-    # Adds a row to the example table. The row can be given as a Hash of
-    # parameters and their corresponding values or as an Array of values which
-    # will be assigned in order.
-    def add_row(row)
-      raise('Cannot add a row. No parameters have been set.') if @parameters.empty?
-
-      # A quick 'deep clone' so that the input isn't modified
-      row = Marshal::load(Marshal.dump(row))
-
-      case
-        when row.is_a?(Array)
-          # 'stringify' input
-          row.collect! { |value| value.to_s }
-
-          @rows << Hash[@parameters.zip(row.collect { |value| value.strip })]
-          @row_elements << Row.new("|#{row.join('|')}|")
-        when row.is_a?(Hash)
-          # 'stringify' input
-          row = row.inject({}) { |hash, (key, value)| hash[key.to_s] = value.to_s; hash }
-
-          @rows << row.each_value { |value| value.strip! }
-          @row_elements << Row.new("|#{ordered_row_values(row).join('|')}|")
-        else
-          raise(ArgumentError, "Can only add row from a Hash or an Array but received #{row.class}")
-      end
-    end
-
-    # Removes a row from the example table. The row can be given as a Hash of
-    # parameters and their corresponding values or as an Array of values
-    # which will be assigned in order.
-    def remove_row(row)
-      case
-        when row.is_a?(Array)
-          location = @rows.index { |row_hash| row_hash.values_at(*@parameters) == row.collect { |value| value.strip } }
-        when row.is_a?(Hash)
-          location = @rows.index { |row_hash| row_hash == row.each_value { |value| value.strip! } }
-        else
-          raise(ArgumentError, "Can only remove row from a Hash or an Array but received #{row.class}")
-      end
-
-      #todo - remove once Hash rows are no longer supported
-      @rows.delete_at(location) if location
-      @row_elements.delete_at(location + 1) if location
-    end
-
-    # Returns the immediate child elements of the element.
-    def contains
-      @row_elements
-    end
-
-    # Returns a gherkin representation of the example.
-    def to_s
-      text = ''
-
-      text << tag_output_string + "\n" unless tags.empty?
-      text << "Examples:#{name_output_string}"
-      text << "\n" + description_output_string unless description_text.empty?
-      text << "\n" unless description_text.empty?
-      text << "\n" + parameters_output_string
-      text << "\n" + rows_output_string unless rows.empty?
-
-      text
-    end
-
-
-    private
-
-
-    def process_source(source)
-      case
-        when source.is_a?(String)
-          parse_example(source)
-        else
-          source
-      end
-    end
-
-    def parse_example(source_text)
-      base_file_string = "Feature: Fake feature to parse\nScenario Outline:\n* fake step\n"
-      source_text = base_file_string + source_text
-
-      parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_example.feature')
-
-      parsed_file.first['elements'].first['examples'].first
-    end
-
-    def build_example(parsed_example)
-      populate_element_tags(parsed_example)
-      populate_example_row_elements(parsed_example)
-      populate_example_parameters
-      populate_example_rows
-    end
-
-    def populate_example_parameters
-      @parameters = @row_elements.first.cells unless @row_elements.empty?
-    end
-
-    def populate_example_rows
-      @row_elements.each do |row|
-        @rows << Hash[@parameters.zip(row.cells)]
-      end
-
-      @rows.shift
-    end
-
-    def populate_example_row_elements(parsed_example)
-      parsed_example['rows'].each do |row|
-        @row_elements << build_child_element(Row, row)
-      end
-    end
-
-    def determine_buffer_size(index)
-      row_elements.collect { |row| row.cells[index].length }.max || 0
-    end
-
-    def parameters_output_string
-      text = ''
-
-      unless parameters.empty?
-        text << "  |"
-        parameters.count.times { |index| text << " #{string_for(parameters, index)} |" }
-      end
-
-      text
-    end
-
-    def rows_output_string
-      text = ''
-
-      unless rows.empty?
-
-        rows.each do |row|
-          text << "  |"
-          row.values.count.times { |index| text << " #{string_for(ordered_row_values(row), index)} |" }
-          text << "\n"
-        end
-
-        text.chomp!
-      end
-
-      text
-    end
-
-    def string_for(cells, index)
-      cells[index] ? cells[index].ljust(determine_buffer_size(index)) : ''
-    end
-
-    def ordered_row_values(row_hash)
-      @parameters.collect { |parameter| row_hash[parameter] }
-    end
-
-  end
-end