cuke_modeler 0.4.1 → 1.0.0

data/lib/cuke_modeler/test_element.rb

@@ -1,79 +0,0 @@
-module CukeModeler
-
-  # A class modeling an element that contains steps.
-
-  class TestElement < FeatureElement
-
-    include Containing
-
-
-    # The steps contained by the TestElement
-    attr_accessor :steps
-
-
-    # Creates a new TestElement object and, if *parsed_test_element* is provided,
-    # populates the object.
-    def initialize(parsed_test_element = nil)
-      super
-
-      @steps = []
-
-      build_test_element(parsed_test_element) if parsed_test_element
-    end
-
-    # Returns true if the two elements have equivalent steps and false otherwise.
-    def ==(other_element)
-      return false unless other_element.respond_to?(:steps)
-
-      steps == other_element.steps
-    end
-
-    # Returns the immediate child elements of the element.
-    def contains
-      @steps
-    end
-
-
-    private
-
-
-    def process_source(source, file_name = nil)
-      case
-        when source.is_a?(String)
-          parse_test_element(source, file_name)
-        else
-          source
-      end
-    end
-
-    def parse_test_element(source_text, file_name = nil)
-      base_file_string = "Feature: Fake feature to parse\n"
-      source_text = base_file_string + source_text
-
-      parsed_file = Parsing::parse_text(source_text, file_name)
-
-      parsed_file.first['elements'].first
-    end
-
-    def build_test_element(parsed_test_element)
-      populate_test_element_steps(parsed_test_element)
-    end
-
-    def populate_test_element_steps(parsed_test_element)
-      if parsed_test_element['steps']
-        parsed_test_element['steps'].each do |step|
-          @steps << build_child_element(Step, step)
-        end
-      end
-    end
-
-    def steps_output_string
-      steps.collect { |step| indented_step_text(step) }.join("\n")
-    end
-
-    def indented_step_text(step)
-      step.to_s.split("\n").collect { |line| "  #{line}" }.join("\n")
-    end
-
-  end
-end

data/lib/cuke_modeler/world.rb

@@ -1,113 +0,0 @@
-module CukeModeler
-
-# A module providing suite level analysis functionality.
-
-  module World
-
-    # A placeholder string used to mark 'dirty' portions of input strings
-    SANITARY_STRING = '___SANITIZED_BY_CUCUMBER_ANALYTICS___'
-
-    # A pattern that matches a Cucumber step keyword
-    STEP_DEF_KEYWORD_PATTERN = '(?:Given|When|Then|And|But)'
-
-    # A pattern that matches a 'clean' regular expression
-    REGEX_PATTERN_STRING = '\/[^\/]*\/'
-
-    # A pattern that matches a step definition declaration line
-    STEP_DEF_LINE_PATTERN = /^\s*#{World::STEP_DEF_KEYWORD_PATTERN}\s*\(?\s*#{REGEX_PATTERN_STRING}\s*\)?/
-
-    # A pattern that captures the regular expression portion of a step definition declaration line
-    STEP_DEF_PATTERN_CAPTURE_PATTERN = /^\s*#{World::STEP_DEF_KEYWORD_PATTERN}\s*\(?\s*(#{REGEX_PATTERN_STRING})\s*\)?/
-
-
-    class << self
-
-      # Returns the left delimiter, which is used to mark the beginning of a step
-      # argument.
-      def left_delimiter
-        @left_delimiter
-      end
-
-      # Sets the left delimiter that will be used by default when determining
-      # step arguments.
-      def left_delimiter=(new_delimiter)
-        @left_delimiter = new_delimiter
-      end
-
-      # Returns the right delimiter, which is used to mark the end of a step
-      # argument.
-      def right_delimiter
-        @right_delimiter
-      end
-
-      # Sets the right delimiter that will be used by default when determining
-      # step arguments.
-      def right_delimiter=(new_delimiter)
-        @right_delimiter = new_delimiter
-      end
-
-      # Sets the delimiter that will be used by default when determining the
-      # boundaries of step arguments.
-      def delimiter=(new_delimiter)
-        self.left_delimiter = new_delimiter
-        self.right_delimiter = new_delimiter
-      end
-
-      # Loads the step patterns contained in the given file into the World.
-      def load_step_file(file_path)
-        File.open(file_path, 'r') do |file|
-          file.readlines.each do |line|
-            if step_def_line?(line)
-              the_reg_ex = extract_regular_expression(line)
-              loaded_step_patterns << the_reg_ex
-            end
-          end
-        end
-      end
-
-      # Loads the step pattern into the World.
-      def load_step_pattern(pattern)
-        loaded_step_patterns << pattern
-      end
-
-      # Returns the step patterns that have been loaded into the World.
-      def loaded_step_patterns
-        @defined_expressions ||= []
-      end
-
-      # Clears the step patterns that have been loaded into the World.
-      def clear_step_patterns
-        @defined_expressions = []
-      end
-
-
-      private
-
-
-      # Make life easier by ensuring that the only forward slashes in the
-      # regular expression are the important ones.
-      def sanitize_line(line)
-        line.gsub('\/', SANITARY_STRING)
-      end
-
-      # And be sure to restore the line to its original state.
-      def desanitize_line(line)
-        line.gsub(SANITARY_STRING, '\/')
-      end
-
-      # Returns whether or not the passed line is a step pattern.
-      def step_def_line?(line)
-        !!(sanitize_line(line) =~ STEP_DEF_LINE_PATTERN)
-      end
-
-      # Returns the regular expression portion of a step pattern line.
-      def extract_regular_expression(line)
-        line = desanitize_line(sanitize_line(line).match(STEP_DEF_PATTERN_CAPTURE_PATTERN)[1])
-        line = line.slice(1..(line.length - 2))
-
-        Regexp.new(line)
-      end
-
-    end
-  end
-end

data/spec/integration/table_row_integration_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-SimpleCov.command_name('TableRow') unless RUBY_VERSION.to_s < '1.9.0'
-
-describe 'TableRow, Integration' do
-
-  let(:clazz) { CukeModeler::TableRow }
-
-
-  describe 'unique behavior' do
-
-    describe 'getting ancestors' do
-
-      before(:each) do
-        source = ['Feature: Test feature',
-                  '',
-                  '  Scenario: Test test',
-                  '    * a step:',
-                  '      | a | table |']
-        source = source.join("\n")
-
-        file_path = "#{@default_file_directory}/table_row_test_file.feature"
-        File.open(file_path, 'w') { |file| file.write(source) }
-      end
-
-      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-      let(:table_row) { directory.feature_files.first.features.first.tests.first.steps.first.block.row_elements.first }
-
-
-      it 'can get its directory' do
-        ancestor = table_row.get_ancestor(:directory)
-
-        ancestor.should equal directory
-      end
-
-      it 'can get its feature file' do
-        ancestor = table_row.get_ancestor(:feature_file)
-
-        ancestor.should equal directory.feature_files.first
-      end
-
-      it 'can get its feature' do
-        ancestor = table_row.get_ancestor(:feature)
-
-        ancestor.should equal directory.feature_files.first.features.first
-      end
-
-      it 'can get its test' do
-        ancestor = table_row.get_ancestor(:test)
-
-        ancestor.should equal directory.feature_files.first.features.first.tests.first
-      end
-
-      it 'can get its step' do
-        ancestor = table_row.get_ancestor(:step)
-
-        ancestor.should equal directory.feature_files.first.features.first.tests.first.steps.first
-      end
-
-      it 'can get its table' do
-        ancestor = table_row.get_ancestor(:table)
-
-        ancestor.should equal directory.feature_files.first.features.first.tests.first.steps.first.block
-      end
-
-      it 'returns nil if it does not have the requested type of ancestor' do
-        ancestor = table_row.get_ancestor(:example)
-
-        ancestor.should be_nil
-      end
-
-    end
-
-  end
-
-end

data/spec/integration/world_integration_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-SimpleCov.command_name('World') unless RUBY_VERSION.to_s < '1.9.0'
-
-describe 'World, Integration' do
-
-  let(:world) { CukeModeler::World }
-
-  before(:each) do
-    @world.loaded_step_patterns.clear
-  end
-
-  # Nothing left to do here for now.
-end

data/spec/unit/containing_element_unit_specs.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for 'a containing element' do
-
-  # clazz must be defined by the calling file
-
-  let(:element) { clazz.new }
-
-
-  it 'has children' do
-    element.should respond_to(:contains)
-  end
-
-  it 'returns a collection of children' do
-    element.contains.is_a?(Array).should be_true
-  end
-
-end

data/spec/unit/feature_element_unit_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-SimpleCov.command_name('FeatureElement') unless RUBY_VERSION.to_s < '1.9.0'
-
-describe 'FeatureElement, Unit' do
-
-  let(:clazz) { CukeModeler::FeatureElement }
-  let(:element) { clazz.new }
-
-  describe 'common behavior' do
-
-    it_should_behave_like 'a feature element'
-    it_should_behave_like 'a nested element'
-    it_should_behave_like 'a prepopulated element'
-    it_should_behave_like 'a bare bones element'
-
-  end
-
-end

data/spec/unit/feature_element_unit_specs.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for 'a feature element' do
-
-  # clazz must be defined by the calling file
-
-  let(:element) { clazz.new }
-
-
-  it 'has a name' do
-    element.should respond_to(:name)
-  end
-
-  it 'can change its name' do
-    expect(element).to respond_to(:name=)
-
-    element.name = :some_name
-    element.name.should == :some_name
-    element.name = :some_other_name
-    element.name.should == :some_other_name
-  end
-
-  it 'has a description' do
-    element.should respond_to(:description)
-    element.should respond_to(:description_text)
-  end
-
-  it 'can get and set its description' do
-    expect(element).to respond_to(:description=)
-    expect(element).to respond_to(:description_text=)
-
-    element.description = :some_description
-    element.description.should == :some_description
-    element.description = :some_other_description
-    element.description.should == :some_other_description
-
-    element.description_text = :some_description
-    element.description_text.should == :some_description
-    element.description_text = :some_other_description
-    element.description_text.should == :some_other_description
-  end
-
-  it 'starts with no name' do
-    element.name.should == ''
-  end
-
-  it 'starts with no description' do
-    element.description.should == []
-    element.description_text.should == ''
-  end
-
-end

data/spec/unit/nested_element_unit_specs.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for 'a nested element' do
-
-  # clazz must be defined by the calling file
-
-  let(:nested_element) { clazz.new }
-
-
-  it 'has a parent element' do
-    nested_element.should respond_to(:parent_element)
-  end
-
-  it 'can change its parent element' do
-    expect(nested_element).to respond_to(:parent_element=)
-
-    nested_element.parent_element = :some_parent_element
-    nested_element.parent_element.should == :some_parent_element
-    nested_element.parent_element = :some_other_parent_element
-    nested_element.parent_element.should == :some_other_parent_element
-  end
-
-  it 'starts with no parent element' do
-    nested_element.parent_element.should == nil
-  end
-
-  it 'has access to its ancestors' do
-    nested_element.should respond_to(:get_ancestor)
-  end
-
-  it 'gets an ancestor based on type' do
-    (clazz.instance_method(:get_ancestor).arity == 1).should be_true
-  end
-
-  it 'raises and exception if an unknown ancestor type is requested' do
-    expect { nested_element.get_ancestor(:bad_ancestor_type) }.to raise_exception(ArgumentError)
-  end
-
-end

data/spec/unit/prepopulated_unit_specs.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for 'a prepopulated element' do
-
-  # clazz must be defined by the calling file
-
-  let(:element) { clazz.new }
-
-
-  it 'can take an argument' do
-    (clazz.instance_method(:initialize).arity != 0).should be_true
-  end
-
-end

data/spec/unit/raw_element_unit_specs.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for 'a raw element' do
-
-  # clazz must be defined by the calling file
-
-  let(:element) { clazz.new }
-
-
-  it 'has an underlying implementation representation' do
-    element.should respond_to(:raw_element)
-  end
-
-  it 'can change its underlying implementation representation' do
-    expect(element).to respond_to(:raw_element=)
-
-    element.raw_element = :some_raw_element
-    element.raw_element.should == :some_raw_element
-    element.raw_element = :some_other_raw_element
-    element.raw_element.should == :some_other_raw_element
-  end
-
-  it 'starts with no underlying implementation representation' do
-    element.raw_element.should == nil
-  end
-
-end