cuke_modeler 0.0.1

data/lib/cuke_modeler/table.rb

@@ -0,0 +1,90 @@
+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)
+
+      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.collect { |row| row['cells'] }
+    end
+
+    def populate_row_elements(table)
+      table.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

@@ -0,0 +1,64 @@
+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)
+
+      parsed_file.first['elements'].first['steps'].first['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

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

data/lib/cuke_modeler/taggable.rb

@@ -0,0 +1,54 @@
+module CukeModeler
+
+  # A mix-in module containing methods used by elements that can be tagged.
+
+  module Taggable
+
+    # The tags which are directly assigned to the element
+    attr_accessor :tags
+
+    # The tag elements belonging to the element
+    attr_accessor :tag_elements
+
+
+    # Returns the tags which are indirectly assigned to the element (i.e. they
+    # have been inherited from a parent element).
+    def applied_tags
+      @parent_element.respond_to?(:all_tags) ? @parent_element.all_tags : []
+    end
+
+    # Returns the tags elements which are indirectly assigned to the element
+    # (i.e. they have been inherited from a parent element).
+    def applied_tag_elements
+      @parent_element.respond_to?(:all_tag_elements) ? @parent_element.all_tag_elements : []
+    end
+
+    # Returns all of the tags which are applicable to the element.
+    def all_tags
+      applied_tags + @tags
+    end
+
+    # Returns all of the tag elements which are applicable to the element.
+    def all_tag_elements
+      applied_tag_elements + @tag_elements
+    end
+
+
+    private
+
+
+    def populate_element_tags(parsed_element)
+      if parsed_element['tags']
+        parsed_element['tags'].each do |tag|
+          @tags << tag['name']
+          @tag_elements << build_child_element(Tag, tag)
+        end
+      end
+    end
+
+    def tag_output_string
+      tag_elements.collect { |tag| tag.name }.join(' ')
+    end
+
+  end
+end

data/lib/cuke_modeler/test_element.rb

@@ -0,0 +1,77 @@
+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)
+      steps == other_element.steps
+    end
+
+    # Returns the immediate child elements of the element.
+    def contains
+      @steps
+    end
+
+
+    private
+
+
+    def process_source(source)
+      case
+        when source.is_a?(String)
+          parse_test_element(source)
+        else
+          source
+      end
+    end
+
+    def parse_test_element(source_text)
+      base_file_string = "Feature: Fake feature to parse\n"
+      source_text = base_file_string + source_text
+
+      parsed_file = Parsing::parse_text(source_text)
+
+      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/version.rb

@@ -0,0 +1,3 @@
+module CukeModeler
+  VERSION = "0.0.1"
+end

data/lib/cuke_modeler/world.rb

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