cuke_modeler 0.4.1 → 1.0.0

data/lib/cuke_modeler/described.rb

@@ -0,0 +1,28 @@
+module CukeModeler
+
+  # A mix-in module containing methods used by models that represent an element that has a description.
+
+  module Described
+
+    # The description of the element
+    attr_accessor :description
+
+
+    private
+
+
+    def description_output_string
+      text = ''
+
+      unless description.empty?
+        description_lines = description.split("\n")
+
+        text << "\n" if description_lines.first =~ /\S/
+        text << description_lines.collect { |line| "#{line}" }.join("\n")
+      end
+
+      text
+    end
+
+  end
+end

data/lib/cuke_modeler/models/background.rb

@@ -0,0 +1,66 @@
+module CukeModeler
+
+  # A class modeling a feature's background.
+
+  class Background < Model
+
+    include Parsed
+    include Named
+    include Described
+    include Stepped
+    include Sourceable
+
+
+    # Creates a new Background object and, if *source_text* is provided, populates
+    # the object.
+    def initialize(source_text = nil)
+      @steps = []
+
+      super(source_text)
+
+      if source_text
+        parsed_background_data = parse_source(source_text)
+        populate_background(self, parsed_background_data)
+      end
+    end
+
+    # Returns *true* if the two models have equivalent steps and *false* otherwise.
+    def ==(other_model)
+      return false unless other_model.respond_to?(:steps)
+
+      steps == other_model.steps
+    end
+
+    # Returns the model objects that belong to this model.
+    def children
+      steps
+    end
+
+    # Returns a string representation of this model. For a background model,
+    # this will be Gherkin text that is equivalent to the background being modeled.
+    def to_s
+      text = ''
+
+      text << "Background:#{name_output_string}"
+      text << "\n" + description_output_string unless (description.nil? || description.empty?)
+      text << "\n" unless (steps.empty? || description.nil? || description.empty?)
+      text << "\n" + steps_output_string unless steps.empty?
+
+      text
+    end
+
+
+    private
+
+
+    def parse_source(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, 'cuke_modeler_stand_alone_background.feature')
+
+      parsed_file.first['elements'].first
+    end
+
+  end
+end

data/lib/cuke_modeler/models/cell.rb

@@ -0,0 +1,48 @@
+module CukeModeler
+
+  # A class modeling a single cell of a row.
+
+  class Cell < Model
+
+    include Sourceable
+    include Parsed
+
+
+    # The value of the cell
+    attr_accessor :value
+
+
+    # Creates a new Cell object and, if *source_text* is provided, populates
+    # the object.
+    def initialize(source_text = nil)
+      super(source_text)
+
+      if source_text
+        parsed_cell_data = parse_source(source_text)
+        populate_cell(self, parsed_cell_data)
+      end
+    end
+
+    # Returns a string representation of this model. For a cell model,
+    # this will be Gherkin text that is equivalent to the cell being modeled.
+    def to_s
+      # Vertical bars and backslashes are special characters that need to be escaped
+      @value ? @value.gsub('\\', '\\\\\\').gsub('|', '\|') : ''
+    end
+
+
+    private
+
+
+    def parse_source(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_cell.feature')
+
+      parsed_file.first['elements'].first['steps'].first['table']['rows'].first['cells'].first
+    end
+
+  end
+
+end

data/lib/cuke_modeler/models/directory.rb

@@ -0,0 +1,95 @@
+module CukeModeler
+
+  # A class modeling a directory in a Cucumber suite.
+
+  class Directory < Model
+
+
+    # The feature file models contained by the modeled directory
+    attr_accessor :feature_files
+
+    # The directory models contained by the modeled directory
+    attr_accessor :directories
+
+    # The file path of the modeled directory
+    attr_accessor :path
+
+
+    # Creates a new Directory object and, if *directory_path* is provided,
+    # populates the object.
+    def initialize(directory_path = nil)
+      @path = directory_path
+      @feature_files = []
+      @directories = []
+
+      super(directory_path)
+
+      if directory_path
+        raise(ArgumentError, "Unknown directory: #{directory_path.inspect}") unless File.exists?(directory_path)
+
+        processed_directory_data = process_directory(directory_path)
+        populate_directory(self, processed_directory_data)
+      end
+    end
+
+    # Returns the name of the modeled directory.
+    def name
+      File.basename(@path.gsub('\\', '/')) if @path
+    end
+
+    # Returns the model objects that belong to this model.
+    def children
+      @feature_files + @directories
+    end
+
+    # Returns a string representation of this model. For a directory
+    # model, this will be the path of the modeled directory.
+    def to_s
+      path.to_s
+    end
+
+
+    private
+
+
+    def process_directory(directory_path)
+      directory_data = {'path' => directory_path,
+                        'directories' => [],
+                        'feature_files' => []
+      }
+
+      entries = Dir.entries(directory_path)
+      entries.delete '.'
+      entries.delete '..'
+
+      entries.each do |entry|
+        entry = "#{directory_path}/#{entry}"
+
+        case
+          when File.directory?(entry)
+            directory_data['directories'] << process_directory(entry)
+          when entry =~ /\.feature$/
+            directory_data['feature_files'] << process_feature_file(entry)
+          else
+            # Ignore anything that isn't a directory or a feature file
+        end
+      end
+
+
+      directory_data
+    end
+
+    def process_feature_file(file_path)
+      feature_file_data = {'path' => file_path}
+
+      source_text = IO.read(file_path)
+      feature = Parsing::parse_text(source_text, file_path).first
+
+      feature_file_data['feature'] = feature
+
+
+      feature_file_data
+    end
+
+  end
+end

data/lib/cuke_modeler/models/doc_string.rb

@@ -0,0 +1,59 @@
+module CukeModeler
+
+  # A class modeling a step's doc string.
+
+  class DocString < Model
+
+    include Parsed
+    include Sourceable
+
+
+    # The content type associated with the doc string
+    attr_accessor :content_type
+
+    # The content of the doc string
+    attr_accessor :content
+
+
+    # Creates a new DocString object and, if *source_text* is provided, populates
+    # the object.
+    def initialize(source_text = nil)
+      super(source_text)
+
+      if source_text
+        parsed_doc_string_data = parse_source(source_text)
+        populate_docstring(self, parsed_doc_string_data)
+      end
+    end
+
+    # Returns a string representation of this model. For a doc string model,
+    # this will be Gherkin text that is equivalent to the doc string being modeled.
+    def to_s
+      text = "\"\"\"#{content_type_output_string}\n"
+      text << content_output_string
+      text << '"""'
+    end
+
+
+    private
+
+
+    def parse_source(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 content_type_output_string
+      content_type ? " #{content_type}" : ''
+    end
+
+    def content_output_string
+      (content.nil? || content.empty?) ? '' : content.gsub('"""', '\"\"\"') + "\n"
+    end
+
+  end
+end

data/lib/cuke_modeler/models/example.rb

@@ -0,0 +1,167 @@
+module CukeModeler
+
+  # A class modeling an example table of an outline.
+
+  class Example < Model
+
+    include Parsed
+    include Named
+    include Described
+    include Sourceable
+    include Taggable
+
+
+    # The row models in the example table
+    attr_accessor :rows
+
+
+    # Creates a new Example object and, if *source_text* is provided,
+    # populates the object.
+    def initialize(source_text = nil)
+      @tags = []
+      @rows = []
+
+      super(source_text)
+
+      if source_text
+        parsed_example_data = parse_source(source_text)
+        populate_example(self, parsed_example_data)
+      end
+    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 rows.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 << 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.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_removed)
+      return unless argument_rows
+
+      case
+        when row_removed.is_a?(Array)
+          location = argument_rows.index { |row| row.cells.collect { |cell| cell.value } == row_removed.collect { |value| value.strip } }
+        when row_removed.is_a?(Hash)
+          # Note: the hash value order has to be manually calculated because Ruby 1.8.7 does not have ordered 
+          # hash keys. Alternatively, the hash may have simply been built up 'willy nilly' by the user instead 
+          # of being built up in order according to the parameter order.
+          location = argument_rows.index { |row| row.cells.collect { |cell| cell.value } == ordered_row_values(row_removed.each_value { |value| value.strip! }) }
+        else
+          raise(ArgumentError, "Can only remove row from a Hash or an Array but received #{row_removed.class}")
+      end
+
+      @rows.delete_at(location + 1) if location
+    end
+
+    # The argument rows in the example table
+    def argument_rows
+      rows[1..rows.count] || []
+    end
+
+    # The parameter row for the example table
+    def parameter_row
+      rows.first
+    end
+
+    # Returns the parameters of the example table
+    def parameters
+      parameter_row ? parameter_row.cells.collect { |cell| cell.value } : []
+    end
+
+    # Returns the model objects that belong to this model.
+    def children
+      rows + tags
+    end
+
+    # Returns a string representation of this model. For an example model,
+    # this will be Gherkin text that is equivalent to the example being modeled.
+    def to_s
+      text = ''
+
+      text << tag_output_string + "\n" unless tags.empty?
+      text << "Examples:#{name_output_string}"
+      text << "\n" + description_output_string unless (description.nil? || description.empty?)
+      text << "\n" unless (description.nil? || description.empty?)
+      text << "\n" + parameters_output_string
+      text << "\n" + rows_output_string unless argument_rows.empty?
+
+      text
+    end
+
+
+    private
+
+
+    def parse_source(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 determine_buffer_size(index)
+      rows.collect { |row| row.cells[index].to_s.length }.max || 0
+    end
+
+    def parameters_output_string
+      text = ''
+
+      unless parameter_row.nil?
+        text << "  |"
+        parameter_row.cells.count.times { |index| text << " #{string_for(parameter_row.cells, index)} |" }
+      end
+
+      text
+    end
+
+    def rows_output_string
+      text = ''
+
+      unless argument_rows.empty?
+
+        argument_rows.each do |row|
+          text << "  |"
+          row.cells.count.times { |index| text << " #{string_for(row.cells, index)} |" }
+          text << "\n"
+        end
+
+        text.chomp!
+      end
+
+      text
+    end
+
+    def string_for(cells, index)
+      cells[index] ? cells[index].to_s.ljust(determine_buffer_size(index)) : ''
+    end
+
+    def ordered_row_values(row_hash)
+      parameter_row.cells.collect { |cell| cell.value }.collect { |parameter| row_hash[parameter] }
+    end
+
+  end
+end