cuke_modeler 0.4.1 → 1.0.0

data/lib/cuke_modeler/models/table.rb

@@ -0,0 +1,67 @@
+module CukeModeler
+
+  # A class modeling a step's table.
+
+  class Table < Model
+
+    include Parsed
+    include Sourceable
+
+
+    # The row models that make up the table
+    attr_accessor :rows
+
+
+    # Creates a new Table object and, if *source_text* is provided, populates
+    # the object.
+    def initialize(source_text = nil)
+      @rows = []
+
+      super(source_text)
+
+      if source_text
+        parsed_table_data = parse_source(source_text)
+        populate_table(self, parsed_table_data)
+      end
+    end
+
+    # Returns the model objects that belong to this model.
+    def children
+      rows
+    end
+
+    # Returns a string representation of this model. For a table model,
+    # this will be Gherkin text that is equivalent to the table being modeled.
+    def to_s
+      rows.empty? ? '' : rows.collect { |row| row_output_string(row) }.join("\n")
+    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_table.feature')
+
+      parsed_file.first['elements'].first['steps'].first['table']
+    end
+
+    def row_output_string(row)
+      row_text = '|'
+
+      row.cells.count.times do |count|
+        row_text << " #{row.cells[count].to_s.ljust(determine_buffer_size(count))} |"
+      end
+
+      row_text
+    end
+
+    def determine_buffer_size(index)
+      rows.collect { |row| row.cells[index].to_s.length }.max || 0
+    end
+
+  end
+end

data/lib/cuke_modeler/models/tag.rb

@@ -0,0 +1,46 @@
+module CukeModeler
+
+  # A class modeling a tag.
+
+  class Tag < Model
+
+    include Parsed
+    include Sourceable
+
+
+    # The name of the tag
+    attr_accessor :name
+
+
+    # Creates a new Tag object and, if *source_text* is provided, populates the
+    # object.
+    def initialize(source_text = nil)
+      super(source_text)
+
+      if source_text
+        parsed_tag_data = parse_source(source_text)
+        populate_tag(self, parsed_tag_data)
+      end
+    end
+
+    # Returns a string representation of this model. For a tag model,
+    # this will be Gherkin text that is equivalent to the tag being modeled.
+    def to_s
+      name || ''
+    end
+
+
+    private
+
+
+    def parse_source(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
+
+  end
+end

data/lib/cuke_modeler/named.rb

@@ -0,0 +1,19 @@
+module CukeModeler
+
+  # A mix-in module containing methods used by models that represent an element that has a name.
+
+  module Named
+
+    # The name of the element
+    attr_accessor :name
+
+
+    private
+
+
+    def name_output_string
+      (name.nil? || name.empty?) ? '' : " #{name}"
+    end
+
+  end
+end

data/lib/cuke_modeler/nested.rb

@@ -1,32 +1,39 @@
 module CukeModeler
 
-  # A mix-in module containing methods used by elements that are nested inside
-  # of other elements.
+  # A mix-in module containing methods used by models that are nested inside
+  # of other models.
 
   module Nested
 
-    # The parent object that contains *self*
-    attr_accessor :parent_element
+    # The parent model that contains this model
+    attr_accessor :parent_model
 
 
-    # Returns the ancestor of *self* that matches the given type.
+    # Returns the ancestor model of this model that matches the given type.
     def get_ancestor(ancestor_type)
-      ancestor = self.parent_element
-      target_type = {:directory => Directory,
-                     :feature_file => FeatureFile,
-                     :feature => Feature,
-                     :test => TestElement,
-                     :step => Step,
-                     :table => Table,
-                     :example => Example
+      target_type = {:directory => [Directory],
+                     :feature_file => [FeatureFile],
+                     :feature => [Feature],
+                     :test => [Scenario, Outline, Background],
+                     :background => [Background],
+                     :scenario => [Scenario],
+                     :outline => [Outline],
+                     :step => [Step],
+                     :table => [Table],
+                     :example => [Example],
+                     :row => [Row]
       }[ancestor_type]
 
       raise(ArgumentError, "Unknown ancestor type '#{ancestor_type}'.") if target_type.nil?
 
-      until ancestor.is_a?(target_type) || ancestor.nil?
-        ancestor = ancestor.parent_element
+
+      ancestor = self.parent_model
+
+      until target_type.include?(ancestor.class) || ancestor.nil?
+        ancestor = ancestor.parent_model
       end
 
+
       ancestor
     end
 

data/lib/cuke_modeler/parsed.rb

@@ -0,0 +1,11 @@
+module CukeModeler
+
+  # A mix-in module containing methods used by models that are parsed from source text.
+
+  module Parsed
+
+    # The parsing data for this element that was generated by the parsing engine (i.e. the *gherkin* gem)
+    attr_accessor :parsing_data
+
+  end
+end

data/lib/cuke_modeler/parsing.rb

@@ -1,113 +1,96 @@
-# The 'gherkin' gem loads differently depending across versions. Try the old one first and then the new one
-begin
-  require 'gherkin'
-rescue LoadError => e
-  require 'gherkin/parser'
-end
-
-# Parsing will be with an 'adapter' appropriate to the version of the 'gherkin' gem that has been activated
-case
-  when Gem.loaded_specs['gherkin'].version.version[/^4/]
-
-    require 'gherkin/parser'
-    require 'cuke_modeler/adapters/gherkin_4_adapter'
-
-
-    module CukeModeler
-
-      module Parsing
-        class << self
+module CukeModeler
 
-          def parse_text(source_text, filename = 'cuke_modeler_fake_file.feature')
-            raise(ArgumentError, "Cannot parse #{source_text.class} objects. Strings only.") unless source_text.is_a?(String)
+  # A module providing source text parsing functionality.
 
-            begin
-              parsed_result = Gherkin::Parser.new.parse(source_text)
-            rescue => e
-              raise(ArgumentError, "Error encountered while parsing '#{filename}'\n#{e.class} - #{e.message}")
-            end
+  module Parsing
 
-            adapted_result = CukeModeler::Gherkin4Adapter.new.adapt(parsed_result)
 
-            adapted_result
-          end
-        end
-      end
+    # Have to at least load some version of the gem before which version of the gem has been loaded can
+    # be determined and the rest of the needed files can be loaded. Try the old one first and then the
+    # new one.
+    begin
+      require 'gherkin'
+    rescue LoadError
+      require 'gherkin/parser'
     end
 
-  when Gem.loaded_specs['gherkin'].version.version[/^3/]
-
-    require 'gherkin/parser'
-    require 'cuke_modeler/adapters/gherkin_3_adapter'
-
-
-    module CukeModeler
-
-      module Parsing
-        class << self
 
-          def parse_text(source_text, filename = 'cuke_modeler_fake_file.feature')
-            raise(ArgumentError, "Cannot parse #{source_text.class} objects. Strings only.") unless source_text.is_a?(String)
+    # The *gherkin* gem loads differently and has different grammar rules across major versions. Parsing
+    # will be done with an 'adapter' appropriate to the version of the *gherkin* gem that has been activated.
 
-            begin
-              parsed_result = Gherkin::Parser.new.parse(source_text)
-            rescue => e
-              raise(ArgumentError, "Error encountered while parsing '#{filename}'\n#{e.class} - #{e.message}")
-            end
+    case
+      when Gem.loaded_specs['gherkin'].version.version[/^4/]
+        require 'gherkin/parser'
+        require 'cuke_modeler/adapters/gherkin_4_adapter'
 
-            adapted_result = CukeModeler::Gherkin3Adapter.new.adapt(parsed_result)
 
-            adapted_result
-          end
+        # todo - make these methods private?
+        def self.parsing_method(source_text, _filename)
+          Gherkin::Parser.new.parse(source_text)
         end
-      end
-    end
 
-  else
+        def self.adapter_class
+          CukeModeler::Gherkin4Adapter
+        end
 
-    require 'stringio'
-    require 'gherkin/formatter/json_formatter'
-    require 'gherkin'
-    require 'json'
-    require 'multi_json'
-    require 'cuke_modeler/adapters/gherkin_2_adapter'
+      when Gem.loaded_specs['gherkin'].version.version[/^3/]
+        require 'gherkin/parser'
+        require 'cuke_modeler/adapters/gherkin_3_adapter'
 
 
-    module CukeModeler
+        def self.parsing_method(source_text, _filename)
+          Gherkin::Parser.new.parse(source_text)
+        end
 
-      # A module providing source text parsing functionality.
+        def self.adapter_class
+          CukeModeler::Gherkin3Adapter
+        end
 
-      module Parsing
+      else # Assume version 2.x
+        require 'stringio'
+        require 'gherkin/formatter/json_formatter'
+        require 'gherkin'
+        require 'json'
+        require 'multi_json'
+        require 'cuke_modeler/adapters/gherkin_2_adapter'
+
+
+        def self.parsing_method(source_text, filename)
+          io = StringIO.new
+          formatter = Gherkin::Formatter::JSONFormatter.new(io)
+          parser = Gherkin::Parser::Parser.new(formatter)
+          parser.parse(source_text, filename, 0)
+          formatter.done
+          MultiJson.load(io.string)
+        end
 
-        class << self
+        def self.adapter_class
+          CukeModeler::Gherkin2Adapter
+        end
 
-          # Parses the Cucumber feature given in *source_text* and returns an array
-          # containing the hash representation of its logical structure.
-          def parse_text(source_text, filename = 'cuke_modeler_fake_file.feature')
-            raise(ArgumentError, "Cannot parse #{source_text.class} objects. Strings only.") unless source_text.is_a?(String)
+    end
 
-            io = StringIO.new
-            formatter = Gherkin::Formatter::JSONFormatter.new(io)
-            parser = Gherkin::Parser::Parser.new(formatter)
 
-            begin
-              parser.parse(source_text, filename, 0)
-            rescue => e
-              raise(ArgumentError, "Error encountered while parsing '#{filename}'\n#{e.class} - #{e.message}")
-            end
+    class << self
 
-            formatter.done
+      # Parses the Cucumber feature given in *source_text* and returns an array
+      # containing the hash representation of its logical structure.
+      def parse_text(source_text, filename = 'cuke_modeler_fake_file.feature')
+        raise(ArgumentError, "Text to parse must be a String but got #{source_text.class}") unless source_text.is_a?(String)
 
 
-            parsed_result = MultiJson.load(io.string)
-            adapted_result = CukeModeler::Gherkin2Adapter.new.adapt(parsed_result)
+        begin
+          parsed_result = parsing_method(source_text, filename)
+        rescue => e
+          raise(ArgumentError, "Error encountered while parsing '#{filename}'\n#{e.class} - #{e.message}")
+        end
 
-            adapted_result
-          end
+        adapted_result = adapter_class.new.adapt(parsed_result)
 
-        end
 
+        adapted_result
       end
-    end
 
+    end
+  end
 end

data/lib/cuke_modeler/sourceable.rb

@@ -1,20 +1,12 @@
 module CukeModeler
 
-  # A mix-in module containing methods used by elements that know their
-  # source code line.
+  # A mix-in module containing methods used by models that know from which line of
+  # source code they originate.
 
   module Sourceable
 
     # The line number where the element began in the source code
-    attr_reader :source_line
-
-
-    private
-
-
-    def populate_element_source_line(parsed_element)
-      @source_line = parsed_element['line']
-    end
+    attr_accessor :source_line
 
   end
 end

data/lib/cuke_modeler/stepped.rb

@@ -0,0 +1,24 @@
+module CukeModeler
+
+  # A mix-in module containing methods used by models that represent an element that has steps.
+
+  module Stepped
+
+
+    # The step models contained by this model
+    attr_accessor :steps
+
+
+    private
+
+
+    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/taggable.rb

@@ -1,53 +1,30 @@
 module CukeModeler
 
-  # A mix-in module containing methods used by elements that can be tagged.
+  # A mix-in module containing methods used by models that represent an element that can be tagged.
 
   module Taggable
 
-    # The tags which are directly assigned to the element
+    # The models for 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
+    # Returns the models for 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 : []
+      parent_model.respond_to?(:all_tags) ? parent_model.all_tags : []
     end
 
-    # Returns all of the tags which are applicable to the element.
+    # Returns models for 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(' ')
+      tags.collect { |tag| tag.name }.join(' ')
     end
 
   end