cuke_modeler 0.0.1

data/lib/cuke_modeler/doc_string.rb

@@ -0,0 +1,87 @@
+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)
+
+      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

@@ -0,0 +1,184 @@
+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)
+      case
+        when row.is_a?(Array)
+          @rows << Hash[@parameters.zip(row.collect { |value| value.strip })]
+          @row_elements << Row.new("|#{row.join('|')}|")
+        when row.is_a?(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)
+
+      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
+    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

data/lib/cuke_modeler/feature.rb

@@ -0,0 +1,147 @@
+module CukeModeler
+
+  # A class modeling a Cucumber Feature.
+
+  class Feature < FeatureElement
+
+    include Taggable
+    include Containing
+
+
+    # The Background object contained by the Feature
+    attr_accessor :background
+
+    # The TestElement objects contained by the Feature
+    attr_accessor :tests
+
+
+    # Creates a new Feature object and, if *source* is provided, populates the
+    # object.
+    def initialize(source = nil)
+      parsed_feature = process_source(source)
+
+      super(parsed_feature)
+
+      @tags = []
+      @tag_elements = []
+      @tests = []
+
+      build_feature(parsed_feature) if parsed_feature
+    end
+
+    # Returns true if the feature contains a background, false otherwise.
+    def has_background?
+      !@background.nil?
+    end
+
+    # Returns the scenarios contained in the feature.
+    def scenarios
+      @tests.select { |test| test.is_a? Scenario }
+    end
+
+    # Returns the outlines contained in the feature.
+    def outlines
+      @tests.select { |test| test.is_a? Outline }
+    end
+
+    # Returns the number of scenarios contained in the feature.
+    def scenario_count
+      scenarios.count
+    end
+
+    # Returns the number of outlines contained in the feature.
+    def outline_count
+      outlines.count
+    end
+
+    # Returns the number of tests contained in the feature.
+    def test_count
+      @tests.count
+    end
+
+    # Returns the number of test cases contained in the feature.
+    def test_case_count
+      scenario_count + outlines.reduce(0) { |outline_sum, outline|
+        outline_sum += outline.examples.reduce(0) { |example_sum, example|
+          example_sum += example.rows.count
+        }
+      }
+    end
+
+    # Returns the immediate child elements of the feature (i.e. its Background,
+    # Scenario, and Outline objects.
+    def contains
+      @background ? [@background] + @tests : @tests
+    end
+
+
+    # Returns gherkin representation of the feature.
+    def to_s
+      text = ''
+
+      text << tag_output_string + "\n" unless tags.empty?
+      text << "Feature:#{name_output_string}"
+      text << "\n" + description_output_string unless description_text.empty?
+      text << "\n\n" + background_output_string if background
+      text << "\n\n" + tests_output_string unless tests.empty?
+
+      text
+    end
+
+
+    private
+
+
+    def process_source(source)
+      case
+        when source.is_a?(String)
+          parse_feature(source)
+        else
+          source
+      end
+    end
+
+    def parse_feature(source_text)
+      parsed_file = Parsing::parse_text(source_text)
+
+      parsed_file.first
+    end
+
+    def build_feature(parsed_feature)
+      populate_element_tags(parsed_feature)
+      populate_feature_elements(parsed_feature)
+    end
+
+    def populate_feature_elements(parsed_feature)
+      elements = parsed_feature['elements']
+
+      if elements
+        elements.each do |element|
+          case element['keyword']
+            when 'Scenario'
+              @tests << build_child_element(Scenario, element)
+            when 'Scenario Outline'
+              @tests << build_child_element(Outline, element)
+            when 'Background'
+              @background = build_child_element(Background, element)
+            else
+              raise(ArgumentError, "Unknown keyword: #{element['keyword']}")
+          end
+        end
+      end
+    end
+
+    def background_output_string
+      test_element_output_string(background)
+    end
+
+    def tests_output_string
+      tests.collect { |test| test_element_output_string(test) }.join("\n\n")
+    end
+
+    def test_element_output_string(test_element)
+      test_element.to_s.split("\n").collect { |line| line.empty? ? '' : "  #{line}" }.join("\n")
+    end
+
+  end
+end

data/lib/cuke_modeler/feature_element.rb

@@ -0,0 +1,73 @@
+module CukeModeler
+
+  # A class modeling an basic element of a feature.
+
+  class FeatureElement
+
+    include Sourceable
+    include Raw
+    include Nested
+
+
+    # The name of the FeatureElement
+    attr_accessor :name
+
+    # Deprecated
+    #
+    # The description of the FeatureElement
+    attr_accessor :description
+
+    # The description of the FeatureElement
+    attr_accessor :description_text
+
+
+    # Creates a new FeatureElement object and, if *parsed_element* is provided,
+    # populates the object.
+    def initialize(parsed_element = nil)
+      @name = ''
+      @description = []
+      @description_text = ''
+
+      build_feature_element(parsed_element) if parsed_element
+    end
+
+
+    private
+
+
+    def build_feature_element(parsed_element)
+      populate_feature_element_name(parsed_element)
+      populate_feature_element_description(parsed_element)
+      populate_element_source_line(parsed_element)
+      populate_raw_element(parsed_element)
+    end
+
+    def populate_feature_element_name(parsed_element)
+      @name = parsed_element['name']
+    end
+
+    def populate_feature_element_description(parsed_element)
+      @description_text = parsed_element['description']
+      @description = parsed_element['description'].split("\n").collect { |line| line.strip }
+      @description.delete('')
+    end
+
+    def name_output_string
+      name.empty? ? '' : " #{name}"
+    end
+
+    def description_output_string
+      text = ''
+
+      unless description_text.empty?
+        description_lines = description_text.split("\n")
+
+        text << "  \n" if description_lines.first =~ /\S/
+        text << description_lines.collect { |line| "  #{line}" }.join("\n")
+      end
+
+      text
+    end
+
+  end
+end