cuke_modeler 0.4.1 → 1.0.0

data/lib/cuke_modeler/scenario.rb

@@ -1,45 +0,0 @@
-module CukeModeler
-
-  # A class modeling a Cucumber Scenario.
-
-  class Scenario < TestElement
-
-    include Taggable
-
-
-    # Creates a new Scenario object and, if *source* is provided, populates the
-    # object.
-    def initialize(source = nil)
-      parsed_scenario = process_source(source, 'cuke_modeler_stand_alone_scenario.feature')
-
-      super(parsed_scenario)
-
-      @tags = []
-      @tag_elements = []
-
-      build_scenario(parsed_scenario) if parsed_scenario
-    end
-
-    # Returns gherkin representation of the scenario.
-    def to_s
-      text = ''
-
-      text << tag_output_string + "\n" unless tags.empty?
-      text << "Scenario:#{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_scenario(scenario)
-      populate_element_tags(scenario)
-    end
-
-  end
-end

data/lib/cuke_modeler/step.rb

@@ -1,216 +0,0 @@
-module CukeModeler
-
-  # A class modeling a Cucumber Feature.
-
-  class Step
-
-    include Containing
-    include Sourceable
-    include Raw
-    include Nested
-
-
-    # The step's keyword
-    attr_accessor :keyword
-
-    # The base text of the step
-    attr_accessor :base
-
-    # The step's passed block
-    attr_accessor :block
-
-    # The step's arguments
-    attr_accessor :arguments
-
-
-    # Creates a new Step object and, if *source* is provided, populates the
-    # object.
-    def initialize(source = nil)
-      @arguments = []
-
-      parsed_step = process_source(source)
-
-      build_step(parsed_step) if parsed_step
-    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
-
-    # Returns the delimiter that is used to mark the beginning of a step
-    # argument.
-    def left_delimiter
-      @left_delimiter || World.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 delimiter that is used to mark the end of a step
-    # argument.
-    def right_delimiter
-      @right_delimiter || World.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
-
-    # Returns true if the two steps have the same text, minus any keywords
-    # and arguments, and false otherwise.
-    def ==(other_step)
-      return false unless other_step.respond_to?(:step_text)
-
-      left_step = step_text(:with_keywords => false, :with_arguments => false)
-      right_step = other_step.step_text(:with_keywords => false, :with_arguments => false)
-
-      left_step == right_step
-    end
-
-    # Deprecated
-    #
-    # Returns the entire text of the step. Options can be set to selectively
-    # exclude certain portions of the text. *left_delimiter* and *right_delimiter*
-    # are used to determine which parts of the step are arguments.
-    #
-    #  a_step = CukeModeler::Step.new("Given *some* step with a block:\n|block line 1|\n|block line 2|")
-    #
-    #  a_step.step_text
-    #  #=> ['Given *some* step with a block:', '|block line 1|', '|block line 2|']
-    #  a_step.step_text(:with_keywords => false)
-    #  #=> ['*some* step with a block:', '|block line 1|', '|block line 2|']
-    #  a_step.step_text(:with_arguments => false, :left_delimiter => '*', :right_delimiter => '*')
-    #  #=> ['Given ** step with a block:']
-    #  a_step.step_text(:with_keywords => false, :with_arguments => false, :left_delimiter => '-', :right_delimiter => '-'))
-    #  #=> ['*some* step with a block:']
-    #
-    def step_text(options = {})
-      options = {:with_keywords => true,
-                 :with_arguments => true,
-                 :left_delimiter => self.left_delimiter,
-                 :right_delimiter => self.right_delimiter}.merge(options)
-
-      final_step = []
-      step_text = ''
-
-      step_text += "#{@keyword} " if options[:with_keywords]
-
-      if options[:with_arguments]
-        step_text += @base
-        final_step << step_text
-        final_step.concat(rebuild_block_text(@block)) if @block
-      else
-        step_text += stripped_step(@base, options[:left_delimiter], options[:right_delimiter])
-        final_step << step_text
-      end
-
-      final_step
-    end
-
-    # Populates the step's arguments based on the step's text and some method of
-    # determining which parts of the text are arguments. Methods include using
-    # a regular expression and using the step's delimiters.
-    def scan_arguments(*how)
-      if how.count == 1
-        pattern = how.first
-      else
-        left_delimiter = how[0] || self.left_delimiter
-        right_delimiter = how[1] || self.right_delimiter
-
-        return [] unless left_delimiter && right_delimiter
-
-        pattern = Regexp.new(Regexp.escape(left_delimiter) + '(.*?)' + Regexp.escape(right_delimiter))
-      end
-
-      @arguments = @base.scan(pattern).flatten
-    end
-
-    # Returns a gherkin representation of the step.
-    def to_s
-      text = "#{keyword} #{base}"
-      text << "\n" + block.to_s.split("\n").collect { |line| "  #{line}" }.join("\n") if block
-
-      text
-    end
-
-
-    private
-
-
-    def process_source(source)
-      case
-        when source.is_a?(String)
-          parse_step(source)
-        else
-          source
-      end
-    end
-
-    def parse_step(source_text)
-      base_file_string = "Feature: Fake feature to parse\nScenario:\n"
-      source_text = base_file_string + source_text
-
-      parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_step.feature')
-
-      parsed_file.first['elements'].first['steps'].first
-    end
-
-    def build_step(step)
-      populate_base(step)
-      populate_block(step)
-      populate_keyword(step)
-      populate_element_source_line(step)
-      populate_raw_element(step)
-
-      scan_arguments
-    end
-
-    def populate_base(step)
-      @base = step['name']
-    end
-
-    def populate_block(step)
-      @block = build_block(step)
-    end
-
-    def populate_keyword(step)
-      @keyword = step['keyword'].strip
-    end
-
-    # Returns the step string minus any arguments based on the given delimiters.
-    def stripped_step(step, left_delimiter, right_delimiter)
-      unless left_delimiter.nil? || right_delimiter.nil?
-        pattern = Regexp.new(Regexp.escape(left_delimiter) + '.*?' + Regexp.escape(right_delimiter))
-        step = step.gsub(pattern, left_delimiter + right_delimiter)
-      end
-
-      step
-    end
-
-    def build_block(step)
-      case
-        when step['rows']
-          @block = build_child_element(Table, step['rows'])
-        when step['doc_string']
-          @block = build_child_element(DocString, step['doc_string'])
-        else
-          @block = nil
-      end
-
-      @block
-    end
-
-    def rebuild_block_text(blok)
-      blok.contents.collect { |row| "|#{row.join('|')}|" }
-    end
-
-  end
-end

data/lib/cuke_modeler/table.rb

@@ -1,90 +0,0 @@
-module CukeModeler
-
-  # A class modeling the table of a Step.
-
-  class Table
-
-    include Containing
-    include Raw
-    include Nested
-
-
-    # The contents of the table
-    #
-    # Deprecated
-    attr_accessor :contents
-
-    # The row elements that make up the table
-    attr_accessor :row_elements
-
-
-    # Creates a new Table object and, if *source* is provided, populates
-    # the object.
-    def initialize(source = nil)
-      @contents = []
-      @row_elements = []
-
-      parsed_table = process_source(source)
-
-      build_table(parsed_table) if parsed_table
-    end
-
-    # Returns a gherkin representation of the table.
-    def to_s
-      row_elements.empty? ? '' : row_elements.collect { |row| row_output_string(row) }.join("\n")
-    end
-
-
-    private
-
-
-    def process_source(source)
-      case
-        when source.is_a?(String)
-          parse_table(source)
-        else
-          source
-      end
-    end
-
-    def parse_table(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_table.feature')
-
-      parsed_file.first['elements'].first['steps'].first['rows']
-    end
-
-    def build_table(table)
-      populate_contents(table)
-      populate_row_elements(table)
-      populate_raw_element(table)
-    end
-
-    def populate_contents(table)
-      @contents = table['rows'].collect { |row| row['cells'] }
-    end
-
-    def populate_row_elements(table)
-      table['rows'].each do |row|
-        @row_elements << build_child_element(TableRow, row)
-      end
-    end
-
-    def row_output_string(row)
-      row_text = '|'
-
-      row.cells.count.times do |count|
-        row_text << " #{row.cells[count].ljust(determine_buffer_size(count))} |"
-      end
-
-      row_text
-    end
-
-    def determine_buffer_size(index)
-      row_elements.collect { |row| row.cells[index].length }.max || 0
-    end
-
-  end
-end

data/lib/cuke_modeler/table_row.rb

@@ -1,64 +0,0 @@
-module CukeModeler
-
-  # A class modeling a step table row.
-
-  class TableRow
-
-    include Sourceable
-    include Raw
-    include Nested
-
-
-    # The cells that make up the row
-    attr_accessor :cells
-
-
-    # Creates a new TableRow object and, if *source* is provided, populates
-    # the object.
-    def initialize(source = nil)
-      parsed_row = process_source(source)
-
-      @cells = []
-
-      build_row(parsed_row) if parsed_row
-    end
-
-    # Returns a gherkin representation of the table row.
-    def to_s
-      "| #{cells.join(' | ')} |"
-    end
-
-
-    private
-
-
-    def process_source(source)
-      case
-        when source.is_a?(String)
-          parse_row(source)
-        else
-          source
-      end
-    end
-
-    def parse_row(source_text)
-      base_file_string = "Feature: Fake feature to parse\nScenario:\n* fake step\n"
-      source_text = base_file_string + source_text
-
-      parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_table_row.feature')
-
-      parsed_file.first['elements'].first['steps'].first['rows']['rows'].first
-    end
-
-    def build_row(parsed_row)
-      populate_element_source_line(parsed_row)
-      populate_row_cells(parsed_row)
-      populate_raw_element(parsed_row)
-    end
-
-    def populate_row_cells(parsed_row)
-      @cells = parsed_row['cells']
-    end
-
-  end
-end

data/lib/cuke_modeler/tag.rb

@@ -1,62 +0,0 @@
-module CukeModeler
-
-  # A class modeling a Tag.
-
-  class Tag
-
-    include Raw
-    include Sourceable
-    include Nested
-
-
-    # The name of the Tag
-    attr_accessor :name
-
-
-    # Creates a new Tag object and, if *source* is provided, populates the
-    # object.
-    def initialize(source = nil)
-      parsed_tag = process_source(source)
-
-      build_tag(parsed_tag) if parsed_tag
-    end
-
-    # Returns gherkin representation of the tag.
-    def to_s
-      name || ''
-    end
-
-
-    private
-
-
-    def process_source(source)
-      case
-        when source.is_a?(String)
-          parse_tag(source)
-        else
-          source
-      end
-    end
-
-    def parse_tag(source_text)
-      base_file_string = "\nFeature: Fake feature to parse"
-      source_text = source_text + base_file_string
-
-      parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_tag.feature')
-
-      parsed_file.first['tags'].first
-    end
-
-    def build_tag(parsed_tag)
-      populate_name(parsed_tag)
-      populate_raw_element(parsed_tag)
-      populate_element_source_line(parsed_tag)
-    end
-
-    def populate_name(parsed_tag)
-      @name = parsed_tag['name']
-    end
-
-  end
-end