cuke_modeler 3.27.0 → 3.28.0

data/lib/cuke_modeler/adapters/gherkin_base_adapter.rb

@@ -1,17 +1,17 @@
-module CukeModeler
-
-  # @api private
-  #
-  # A class providing some basic and common adapter functionality. Internal helper class.
-  class GherkinBaseAdapter
-
-    private
-
-    def save_original_data(adapted_ast, raw_ast)
-      adapted_ast['cuke_modeler_parsing_data'] = Marshal.load(Marshal.dump(raw_ast))
-    end
-
-  end
-
-  private_constant :GherkinBaseAdapter
-end
+module CukeModeler
+
+  # @api private
+  #
+  # A class providing some basic and common adapter functionality. Internal helper class.
+  class GherkinBaseAdapter
+
+    private
+
+    def save_original_data(adapted_ast, raw_ast)
+      adapted_ast['cuke_modeler_parsing_data'] = Marshal.load(Marshal.dump(raw_ast))
+    end
+
+  end
+
+  private_constant :GherkinBaseAdapter
+end

data/lib/cuke_modeler/containing.rb

@@ -1,105 +1,105 @@
-module CukeModeler
-
-  # @api private
-  #
-  # A mix-in module containing methods used by models that contain other models. Internal helper class.
-  module Containing
-
-    include Enumerable
-
-    # TODO: Have this method return `self` so that method chaining can be done?
-
-    # @api
-    #
-    # Executes the given code block with this model and every model that is a child of this model. Exact
-    # order of model tree traversal is not guaranteed beyond the first model traversed, which will be the
-    # model that called this method. If no block is provided, an `Enumerator` is returned instead.
-    #
-    # @example
-    #   model.each
-    #   model.each { |model| puts model.inspect }
-    #
-    # @yieldparam [Model] The current model being visited
-    # @return [Enumerable] if no block is given
-    def each(&block)
-      if block
-        block.call(self)
-        children.each { |child| child.each(&block) }
-      else
-        to_enum(:each)
-      end
-    end
-
-    # @api
-    # @deprecated Use `Enumerable` module methods instead
-    #
-    # Executes the given code block with every model that is a child of this model.
-    #
-    # @example
-    #   model.each_descendant { |model| puts model.inspect }
-    #
-    # @yieldparam [Model] The current model being visited
-    def each_descendant(&block)
-      children.each do |child_model|
-        block.call(child_model)
-        child_model.each_descendant(&block) if child_model.respond_to?(:each_descendant)
-      end
-    end
-
-    # @api
-    # @deprecated Use `Enumerable` module methods instead
-    #
-    # Executes the given code block with this model and every model that is a child of this model.
-    #
-    # @example
-    #   model.each_model { |model| puts model.inspect }
-    #
-    # @yieldparam [Model] The current model being visited
-    def each_model(&block)
-      block.call(self)
-
-      each_descendant(&block)
-    end
-
-
-    private
-
-
-    def build_child_model(clazz, model_data)
-      model = clazz.new
-      # Send-ing to get around private scoping. Don't want the make the method public
-      # and there is no way to get the already processed data to the child model that
-      # wouldn't require something public.
-      model.send('populate_model', model_data)
-      model.parent_model = self
-
-      model
-    end
-
-    # TODO: move to mix-in module
-    def populate_keyword(parsed_model_data)
-      @keyword = parsed_model_data['keyword'].strip
-    end
-
-    # TODO: move elsewhere?
-    def populate_children(parsed_feature_data)
-      return unless parsed_feature_data['elements']
-
-      parsed_feature_data['elements'].each do |element|
-        case element['type']
-          when 'Scenario', 'scenario'
-            @tests << build_child_model(Scenario, element)
-          when 'ScenarioOutline', 'scenario_outline'
-            @tests << build_child_model(Outline, element)
-          when 'Background', 'background'
-            @background = build_child_model(Background, element)
-          when 'Rule'
-            @rules << build_child_model(Rule, element)
-          else
-            raise(ArgumentError, "Unknown element type: #{element['type']}")
-        end
-      end
-    end
-
-  end
-end
+module CukeModeler
+
+  # @api private
+  #
+  # A mix-in module containing methods used by models that contain other models. Internal helper class.
+  module Containing
+
+    include Enumerable
+
+    # TODO: Have this method return `self` so that method chaining can be done?
+
+    # @api
+    #
+    # Executes the given code block with this model and every model that is a child of this model. Exact
+    # order of model tree traversal is not guaranteed beyond the first model traversed, which will be the
+    # model that called this method. If no block is provided, an `Enumerator` is returned instead.
+    #
+    # @example
+    #   model.each
+    #   model.each { |model| puts model.inspect }
+    #
+    # @yieldparam [Model] The current model being visited
+    # @return [Enumerable] if no block is given
+    def each(&block)
+      if block
+        block.call(self)
+        children.each { |child| child.each(&block) }
+      else
+        to_enum(:each)
+      end
+    end
+
+    # @api
+    # @deprecated Use `Enumerable` module methods instead
+    #
+    # Executes the given code block with every model that is a child of this model.
+    #
+    # @example
+    #   model.each_descendant { |model| puts model.inspect }
+    #
+    # @yieldparam [Model] The current model being visited
+    def each_descendant(&block)
+      children.each do |child_model|
+        block.call(child_model)
+        child_model.each_descendant(&block) if child_model.respond_to?(:each_descendant)
+      end
+    end
+
+    # @api
+    # @deprecated Use `Enumerable` module methods instead
+    #
+    # Executes the given code block with this model and every model that is a child of this model.
+    #
+    # @example
+    #   model.each_model { |model| puts model.inspect }
+    #
+    # @yieldparam [Model] The current model being visited
+    def each_model(&block)
+      block.call(self)
+
+      each_descendant(&block)
+    end
+
+
+    private
+
+
+    def build_child_model(clazz, model_data)
+      model = clazz.new
+      # Send-ing to get around private scoping. Don't want the make the method public
+      # and there is no way to get the already processed data to the child model that
+      # wouldn't require something public.
+      model.send('populate_model', model_data)
+      model.parent_model = self
+
+      model
+    end
+
+    # TODO: move to mix-in module
+    def populate_keyword(parsed_model_data)
+      @keyword = parsed_model_data['keyword'].strip
+    end
+
+    # TODO: move elsewhere?
+    def populate_children(parsed_feature_data)
+      return unless parsed_feature_data['elements']
+
+      parsed_feature_data['elements'].each do |element|
+        case element['type']
+          when 'Scenario', 'scenario'
+            @tests << build_child_model(Scenario, element)
+          when 'ScenarioOutline', 'scenario_outline'
+            @tests << build_child_model(Outline, element)
+          when 'Background', 'background'
+            @background = build_child_model(Background, element)
+          when 'Rule'
+            @rules << build_child_model(Rule, element)
+          else
+            raise(ArgumentError, "Unknown element type: #{element['type']}")
+        end
+      end
+    end
+
+  end
+end

data/lib/cuke_modeler/described.rb

@@ -1,71 +1,71 @@
-module CukeModeler
-
-  # @api private
-  #
-  # A mix-in module containing methods used by models that represent an element that has a
-  # description. Internal helper class.
-  module Described
-
-    # @api
-    #
-    # 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.join("\n")
-      end
-
-      text
-    end
-
-    def no_description_to_output?
-      description.nil? || description.empty?
-    end
-
-    def populate_description(parsed_model_data)
-      @description = trimmed_description(parsed_model_data['description'])
-    end
-
-    def trimmed_description(description)
-      description = description.split("\n")
-
-      trim_leading_blank_lines(description)
-      trim_trailing_blank_lines(description)
-      trim_leading_spaces(description)
-      trim_trailing_spaces(description)
-
-      description.join("\n")
-    end
-
-    def trim_leading_blank_lines(description)
-      description.replace(description.drop_while { |line| line !~ /\S/ })
-    end
-
-    def trim_trailing_blank_lines(_description)
-      # Nothing to do. Already done by the parser but leaving this here in case that changes in future versions.
-    end
-
-    def trim_leading_spaces(description)
-      non_blank_lines = description.grep(/\S/)
-
-      fewest_spaces = non_blank_lines.collect { |line| line[/^\s*/].length }.min || 0
-
-      description.each { |line| line.slice!(0..(fewest_spaces - 1)) } if fewest_spaces.positive?
-    end
-
-    def trim_trailing_spaces(description)
-      description.map!(&:rstrip)
-    end
-
-  end
-end
+module CukeModeler
+
+  # @api private
+  #
+  # A mix-in module containing methods used by models that represent an element that has a
+  # description. Internal helper class.
+  module Described
+
+    # @api
+    #
+    # 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.join("\n")
+      end
+
+      text
+    end
+
+    def no_description_to_output?
+      description.nil? || description.empty?
+    end
+
+    def populate_description(parsed_model_data)
+      @description = trimmed_description(parsed_model_data['description'])
+    end
+
+    def trimmed_description(description)
+      description = description.split("\n")
+
+      trim_leading_blank_lines(description)
+      trim_trailing_blank_lines(description)
+      trim_leading_spaces(description)
+      trim_trailing_spaces(description)
+
+      description.join("\n")
+    end
+
+    def trim_leading_blank_lines(description)
+      description.replace(description.drop_while { |line| line !~ /\S/ })
+    end
+
+    def trim_trailing_blank_lines(_description)
+      # Nothing to do. Already done by the parser but leaving this here in case that changes in future versions.
+    end
+
+    def trim_leading_spaces(description)
+      non_blank_lines = description.grep(/\S/)
+
+      fewest_spaces = non_blank_lines.collect { |line| line[/^\s*/].length }.min || 0
+
+      description.each { |line| line.slice!(0..(fewest_spaces - 1)) } if fewest_spaces.positive?
+    end
+
+    def trim_trailing_spaces(description)
+      description.map!(&:rstrip)
+    end
+
+  end
+end

data/lib/cuke_modeler/models/background.rb

@@ -1,122 +1,122 @@
-module CukeModeler
-
-  # A class modeling a feature's background.
-  class Background < Model
-
-    include Parsing
-    include Parsed
-    include Named
-    include Described
-    include Stepped
-    include Sourceable
-
-
-    # The background's keyword
-    attr_accessor :keyword
-
-
-    # Creates a new Background object and, if *source_text* is provided, populates
-    # the object.
-    #
-    # @example
-    #   Background.new
-    #   Background.new("Background:\n  * a step")
-    #
-    # @param source_text [String] The Gherkin text that will be used to populate the model
-    # @raise [ArgumentError] If *source_text* is not a String
-    # @return [Background] A new Background instance
-    def initialize(source_text = nil)
-      @steps = []
-
-      super
-    end
-
-    # TODO: Have (all) models be equivalent if they have the same #to_s output. Would
-    # likely require major version change.
-
-    # Compares this model with another object. Returns *true* if the two objects
-    # have equivalent steps and *false* otherwise.
-    #
-    # @example
-    #   background_1 == background_2
-    #
-    # @param other [Object] The object to compare this model with
-    # @return [Boolean] Whether the two objects are equivalent
-    def ==(other)
-      return false unless other.respond_to?(:steps)
-
-      steps == other.steps
-    end
-
-    # Returns the model objects that are children of this model. For a
-    # Background model, these would be any associated Step models.
-    #
-    # @example
-    #   background.children
-    #
-    # @return [Array<Step>] A collection of child models
-    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.
-    #
-    # @example
-    #   background.to_s
-    #
-    # @return [String] A string representation of this model
-    def to_s
-      text = ''
-
-      text << "#{@keyword}:#{name_output_string}"
-      text << "\n#{description_output_string}" unless no_description_to_output?
-      text << "\n" unless steps.empty? || no_description_to_output?
-      text << "\n#{steps_output_string}" unless steps.empty?
-
-      text
-    end
-
-    # See `Object#inspect`. Returns some basic information about the
-    # object, including its class, object ID, and its most meaningful
-    # attribute. For a Background model, this will be the name of the
-    # background. If *verbose* is true, provides default Ruby inspection
-    # behavior instead.
-    #
-    # @example
-    #   background.inspect
-    #   background.inspect(verbose: true)
-    #
-    # @param verbose [Boolean] Whether or not to return the full details of
-    #   the object. Defaults to false.
-    # @return [String] A string representation of this model
-    def inspect(verbose: false)
-      return super if verbose
-
-      "#{super.chop} @name: #{name.inspect}>"
-    end
-
-
-    private
-
-
-    def process_source(source_text)
-      base_file_string = "# language: #{Parsing.dialect}\n#{dialect_feature_keyword}: 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['feature']['elements'].first
-    end
-
-    def populate_model(parsed_background_data)
-      populate_parsing_data(parsed_background_data)
-      populate_keyword(parsed_background_data)
-      populate_name(parsed_background_data)
-      populate_description(parsed_background_data)
-      populate_source_location(parsed_background_data)
-      populate_steps(parsed_background_data)
-    end
-
-  end
-end
+module CukeModeler
+
+  # A class modeling a feature's background.
+  class Background < Model
+
+    include Parsing
+    include Parsed
+    include Named
+    include Described
+    include Stepped
+    include Sourceable
+
+
+    # The background's keyword
+    attr_accessor :keyword
+
+
+    # Creates a new Background object and, if *source_text* is provided, populates
+    # the object.
+    #
+    # @example
+    #   Background.new
+    #   Background.new("Background:\n  * a step")
+    #
+    # @param source_text [String] The Gherkin text that will be used to populate the model
+    # @raise [ArgumentError] If *source_text* is not a String
+    # @return [Background] A new Background instance
+    def initialize(source_text = nil)
+      @steps = []
+
+      super
+    end
+
+    # TODO: Have (all) models be equivalent if they have the same #to_s output. Would
+    # likely require major version change.
+
+    # Compares this model with another object. Returns *true* if the two objects
+    # have equivalent steps and *false* otherwise.
+    #
+    # @example
+    #   background_1 == background_2
+    #
+    # @param other [Object] The object to compare this model with
+    # @return [Boolean] Whether the two objects are equivalent
+    def ==(other)
+      return false unless other.respond_to?(:steps)
+
+      steps == other.steps
+    end
+
+    # Returns the model objects that are children of this model. For a
+    # Background model, these would be any associated Step models.
+    #
+    # @example
+    #   background.children
+    #
+    # @return [Array<Step>] A collection of child models
+    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.
+    #
+    # @example
+    #   background.to_s
+    #
+    # @return [String] A string representation of this model
+    def to_s
+      text = ''
+
+      text << "#{@keyword}:#{name_output_string}"
+      text << "\n#{description_output_string}" unless no_description_to_output?
+      text << "\n" unless steps.empty? || no_description_to_output?
+      text << "\n#{steps_output_string}" unless steps.empty?
+
+      text
+    end
+
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a Background model, this will be the name of the
+    # background. If *verbose* is true, provides default Ruby inspection
+    # behavior instead.
+    #
+    # @example
+    #   background.inspect
+    #   background.inspect(verbose: true)
+    #
+    # @param verbose [Boolean] Whether or not to return the full details of
+    #   the object. Defaults to false.
+    # @return [String] A string representation of this model
+    def inspect(verbose: false)
+      return super if verbose
+
+      "#{super.chop} @name: #{name.inspect}>"
+    end
+
+
+    private
+
+
+    def process_source(source_text)
+      base_file_string = "# language: #{Parsing.dialect}\n#{dialect_feature_keyword}: 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['feature']['elements'].first
+    end
+
+    def populate_model(parsed_background_data)
+      populate_parsing_data(parsed_background_data)
+      populate_keyword(parsed_background_data)
+      populate_name(parsed_background_data)
+      populate_description(parsed_background_data)
+      populate_source_location(parsed_background_data)
+      populate_steps(parsed_background_data)
+    end
+
+  end
+end