cuke_modeler 0.4.1 → 1.0.0

data/lib/cuke_modeler/models/feature.rb

@@ -0,0 +1,106 @@
+module CukeModeler
+
+  # A class modeling a feature in a Cucumber suite.
+
+  class Feature < Model
+
+    include Parsed
+    include Named
+    include Described
+    include Taggable
+    include Sourceable
+
+
+    # The Background object contained by the Feature
+    attr_accessor :background
+
+    # The Scenario and Outline objects contained by the Feature
+    attr_accessor :tests
+
+
+    # Creates a new Feature object and, if *source_text* is provided, populates the
+    # object.
+    def initialize(source_text = nil)
+      @tags = []
+      @tests = []
+
+      super(source_text)
+
+      if source_text
+        parsed_feature_data = parse_source(source_text)
+        populate_feature(self, parsed_feature_data)
+      end
+    end
+
+    # Returns *true* if the feature contains a background, *false* otherwise.
+    def has_background?
+      !@background.nil?
+    end
+
+    # Returns the scenario models contained in the feature.
+    def scenarios
+      @tests.select { |test| test.is_a? Scenario }
+    end
+
+    # Returns the outline models contained in the feature.
+    def outlines
+      @tests.select { |test| test.is_a? Outline }
+    end
+
+    # Returns the number of test cases contained in the feature. A test case is a
+    # single set of test values, such as an individual scenario or one example row
+    # of an outline.
+    def test_case_count
+      scenarios.count + outlines.reduce(0) { |outline_sum, outline|
+        outline_sum += outline.examples.reduce(0) { |example_sum, example|
+          example_sum += example.argument_rows.count
+        }
+      }
+    end
+
+    # Returns the model objects that belong to this model.
+    def children
+      models = tests + tags
+      models << background if background
+
+      models
+    end
+
+    # Returns a string representation of this model. For a feature model,
+    # this will be Gherkin text that is equivalent to the feature being modeled.
+    def to_s
+      text = ''
+
+      text << tag_output_string + "\n" unless tags.empty?
+      text << "Feature:#{name_output_string}"
+      text << "\n" + description_output_string unless (description.nil? || description.empty?)
+      text << "\n\n" + background_output_string if background
+      text << "\n\n" + tests_output_string unless tests.empty?
+
+      text
+    end
+
+
+    private
+
+
+    def parse_source(source_text)
+      parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_feature.feature')
+
+      parsed_file.first
+    end
+
+    def background_output_string
+      test_output_string(background)
+    end
+
+    def tests_output_string
+      tests.collect { |test| test_output_string(test) }.join("\n\n")
+    end
+
+    def test_output_string(model)
+      model.to_s.split("\n").collect { |line| line.empty? ? '' : "  #{line}" }.join("\n")
+    end
+
+  end
+end

data/lib/cuke_modeler/models/feature_file.rb

@@ -0,0 +1,64 @@
+module CukeModeler
+
+  # A class modeling a feature file in a Cucumber suite.
+
+  class FeatureFile < Model
+
+
+    # The feature model contained by the modeled feature file
+    attr_accessor :feature
+
+    # The file path of the modeled feature file
+    attr_accessor :path
+
+
+    # Creates a new FeatureFile object and, if *file_path* is provided,
+    # populates the object.
+    def initialize(file_path = nil)
+      @path = file_path
+
+      super(file_path)
+
+      if file_path
+        raise(ArgumentError, "Unknown file: #{file_path.inspect}") unless File.exists?(file_path)
+
+        processed_feature_file_data = process_feature_file(file_path)
+        populate_featurefile(self, processed_feature_file_data)
+      end
+
+    end
+
+    # Returns the name of the modeled feature file.
+    def name
+      File.basename(@path.gsub('\\', '/')) if @path
+    end
+
+    # Returns the model objects that belong to this model.
+    def children
+      [@feature]
+    end
+
+    # Returns a string representation of this model. For a feature file
+    # model, this will be the path of the modeled feature file.
+    def to_s
+      path.to_s
+    end
+
+
+    private
+
+
+    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/model.rb

@@ -0,0 +1,32 @@
+module CukeModeler
+
+  # A class modeling an element of a Cucumber suite.
+
+  class Model
+
+    include Nested
+    include Containing
+
+
+    # Creates a new Model object and, if *source_text* is provided,
+    # populates the object.
+    def initialize(source_text = nil)
+      raise(ArgumentError, "Can only create models from Strings but was given a #{source_text.class}.") if source_text && !source_text.is_a?(String)
+
+      # This should be overridden by a child class
+    end
+
+    # Returns a string representation of this model.
+    def to_s
+      # This should be overridden by a child class
+      super
+    end
+
+    # Returns the model objects that belong to this model.
+    def children
+      # This should be overridden by a child class
+      []
+    end
+
+  end
+end

data/lib/cuke_modeler/models/outline.rb

@@ -0,0 +1,79 @@
+module CukeModeler
+
+  # A class modeling an individual outline in a Cucumber suite.
+
+  class Outline < Model
+
+    include Parsed
+    include Named
+    include Described
+    include Stepped
+    include Sourceable
+    include Taggable
+
+
+    # The Example objects contained by the Outline
+    attr_accessor :examples
+
+
+    # Creates a new Outline object and, if *source_text* is provided, populates the
+    # object.
+    def initialize(source_text = nil)
+      @steps = []
+      @tags = []
+      @examples = []
+
+      super(source_text)
+
+      if source_text
+        parsed_outline_data = parse_source(source_text)
+        populate_outline(self, parsed_outline_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
+      examples + steps + tags
+    end
+
+    # Returns a string representation of this model. For an outline model,
+    # this will be Gherkin text that is equivalent to the outline being modeled.
+    def to_s
+      text = ''
+
+      text << tag_output_string + "\n" unless tags.empty?
+      text << "Scenario Outline:#{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 << "\n\n" + examples_output_string unless examples.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_outline.feature')
+
+      parsed_file.first['elements'].first
+    end
+
+    def examples_output_string
+      examples.empty? ? '' : examples.collect { |example| example.to_s }.join("\n\n")
+    end
+
+  end
+end

data/lib/cuke_modeler/models/row.rb

@@ -0,0 +1,49 @@
+module CukeModeler
+
+  # A class modeling a single row of a step table or example table.
+
+  class Row < Model
+
+    include Sourceable
+    include Parsed
+
+    # The cell models that make up the row
+    attr_accessor :cells
+
+
+    # Creates a new Row object and, if *source_text* is provided, populates
+    # the object.
+    def initialize(source_text = nil)
+      @cells = []
+
+      super(source_text)
+
+      if source_text
+        parsed_row_data = parse_source(source_text)
+        populate_row(self, parsed_row_data)
+      end
+    end
+
+    # Returns a string representation of this model. For a row model,
+    # this will be Gherkin text that is equivalent to the row being modeled.
+    def to_s
+      text_cells = cells.collect { |cell| cell.to_s }
+
+      "| #{text_cells.join(' | ')} |"
+    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_row.feature')
+
+      parsed_file.first['elements'].first['steps'].first['table']['rows'].first
+    end
+
+  end
+end

data/lib/cuke_modeler/models/scenario.rb

@@ -0,0 +1,69 @@
+module CukeModeler
+
+  # A class modeling an individual scenario of a Cucumber suite.
+
+  class Scenario < Model
+
+    include Parsed
+    include Named
+    include Described
+    include Stepped
+    include Sourceable
+    include Taggable
+
+
+    # Creates a new Scenario object and, if *source_text* is provided, populates the
+    # object.
+    def initialize(source_text = nil)
+      @steps = []
+      @tags = []
+
+      super(source_text)
+
+      if source_text
+        parsed_scenario_data = parse_source(source_text)
+        populate_scenario(self, parsed_scenario_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 + tags
+    end
+
+    # Returns a string representation of this model. For a scenario model,
+    # this will be Gherkin text that is equivalent to the scenario being modeled.
+    def to_s
+      text = ''
+
+      text << tag_output_string + "\n" unless tags.empty?
+      text << "Scenario:#{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_scenario.feature')
+
+      parsed_file.first['elements'].first
+    end
+
+  end
+end

data/lib/cuke_modeler/models/step.rb

@@ -0,0 +1,68 @@
+module CukeModeler
+
+  # A class modeling a single step of a background, scenario, or outline.
+
+  class Step < Model
+
+    include Sourceable
+    include Parsed
+
+
+    # The step's keyword
+    attr_accessor :keyword
+
+    # The base text of the step
+    attr_accessor :text
+
+    # The step's passed block
+    attr_accessor :block
+
+
+    # Creates a new Step object and, if *source_text* is provided, populates the
+    # object.
+    def initialize(source_text = nil)
+      super(source_text)
+
+      if source_text
+        parsed_step_data = parse_source(source_text)
+        populate_step(self, parsed_step_data)
+      end
+    end
+
+    # Returns *true* if the two steps have the same base text (i.e. minus any keyword,
+    # table, or doc string and *false* otherwise.
+    def ==(other_step)
+      return false unless other_step.respond_to?(:text)
+
+      text == other_step.text
+    end
+
+    # Returns the model objects that belong to this model.
+    def children
+      [block]
+    end
+
+    # Returns a string representation of this model. For a step model,
+    # this will be Gherkin text that is equivalent to the step being modeled.
+    def to_s
+      text = "#{keyword} #{self.text}"
+      text << "\n" + block.to_s.split("\n").collect { |line| "  #{line}" }.join("\n") if block
+
+      text
+    end
+
+
+    private
+
+
+    def parse_source(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
+
+  end
+end