hiptest-publisher 1.13.0 → 1.14.0

data/lib/hiptest-publisher/node_modifiers/items_orderer.rb

@@ -0,0 +1,33 @@
+require 'hiptest-publisher/nodes'
+
+module Hiptest
+  module NodeModifiers
+    class ItemsOrderer
+      def self.add(project, order)
+        self.new(project).order_items(order)
+      end
+
+      def initialize(project)
+        @project = project
+      end
+
+      def order_items(order)
+        if (order == 'order')
+          @project.each_sub_nodes(Hiptest::Nodes::Folder) do |folder|
+            folder.children[:scenarios].sort_by! {|sc| sc.order_in_parent}
+            folder.children[:subfolders].sort_by! {|f| f.order_in_parent}
+          end
+        end
+
+        if (order == 'alpha')
+          @project.each_sub_nodes(Hiptest::Nodes::Folder) do |folder|
+            folder.children[:scenarios].sort_by! {|sc| sc.children[:name] }
+            folder.children[:subfolders].sort_by! {|f| f.children[:name] }
+          end
+
+          @project.children[:scenarios].children[:scenarios].sort_by! {|sc| sc.children[:name] }
+        end
+      end
+    end
+  end
+end

data/lib/hiptest-publisher/{parameter_type_adder.rb → node_modifiers/parameter_type_adder.rb}

@@ -1,14 +1,13 @@
 require 'hiptest-publisher/nodes_walker'
 require 'hiptest-publisher/project_grapher'
 
-
 module Hiptest
-  module Nodes
+  module NodeModifiers
     class ParameterTypeAdder
       attr_reader :call_types
 
       def self.add(project)
-        Hiptest::Nodes::ParameterTypeAdder.new.process(project)
+        self.new.process(project)
       end
 
       def initialize
@@ -33,15 +32,15 @@ module Hiptest
 
       def gather_scenarios_argument_types(project)
         project.children[:scenarios].children[:scenarios].each do |scenario|
-          @call_types.add_callable_item(scenario.children[:name], Scenario)
+          @call_types.add_callable_item(scenario.children[:name], Hiptest::Nodes::Scenario)
           add_arguments_from(scenario.children[:datatable])
         end
       end
 
       def gather_actionwords_default_parameters_types(project)
         project.children[:actionwords].children[:actionwords].each do |actionword|
-          @call_types.add_callable_item(actionword.children[:name], Actionword)
-          actionword.each_sub_nodes(Parameter) do |parameter|
+          @call_types.add_callable_item(actionword.children[:name], Hiptest::Nodes::Actionword)
+          actionword.each_sub_nodes(Hiptest::Nodes::Parameter) do |parameter|
             default = parameter.children[:default]
             next if default.nil?
             @call_types.add_argument_type(parameter.children[:name], get_type(default))
@@ -50,20 +49,22 @@ module Hiptest
       end
 
       def gather_call_argument_types(node)
-        node.each_sub_nodes(Call) do |call|
-          @call_types.add_callable_item(call.children[:actionword], Actionword)
+        node.each_sub_nodes(Hiptest::Nodes::Call, Hiptest::Nodes::UIDCall) do |call|
+          actionword_name = call.is_a?(Hiptest::Nodes::Call) ? call.children[:actionword] : call.children[:actionword_name]
+
+          @call_types.add_callable_item(actionword_name, Hiptest::Nodes::Actionword)
           add_arguments_from(call, node)
         end
       end
 
       def write_parameter_types_to_item(callable_item)
-        callable_item.each_sub_nodes(Parameter) do |parameter|
+        callable_item.each_sub_nodes(Hiptest::Nodes::Parameter) do |parameter|
           parameter.children[:type] = @call_types.type_of(callable_item.children[:name], parameter.children[:name], callable_item.class)
         end
       end
 
       def add_arguments_from(node, context = nil)
-        node.each_sub_nodes(Argument) do |argument|
+        node.each_sub_nodes(Hiptest::Nodes::Argument) do |argument|
           @call_types.add_argument_type(argument.children[:name], get_type(argument.children[:value], context))
         end
       end
@@ -72,10 +73,10 @@ module Hiptest
 
       def get_type(value, context = nil)
         case value
-          when StringLiteral, Template then :String
-          when NumericLiteral then value.children[:value].include?(".") ? :float : :int
-          when BooleanLiteral then :bool
-          when Variable then get_var_value(value.children[:name], context)
+          when Hiptest::Nodes::StringLiteral, Hiptest::Nodes::Template then :String
+          when Hiptest::Nodes::NumericLiteral then value.children[:value].to_s.include?(".") ? :float : :int
+          when Hiptest::Nodes::BooleanLiteral then :bool
+          when Hiptest::Nodes::Variable then get_var_value(value.children[:name], context)
           else :null
         end
       end

data/lib/hiptest-publisher/{parent_adder.rb → node_modifiers/parent_adder.rb}

@@ -1,17 +1,17 @@
 require 'hiptest-publisher/nodes_walker'
 
 module Hiptest
-  module Nodes
+  module NodeModifiers
     class ParentAdder
       def self.add(project)
-        Hiptest::Nodes::ParentAdder.new.process(project)
+        self.new.process(project)
       end
 
       def process(node)
-        node.each_direct_children {|child|
+        node.each_direct_children do |child|
           child.parent ||= node
           process(child)
-        }
+        end
       end
     end
   end

data/lib/hiptest-publisher/node_modifiers/uid_call_reference_adder.rb

@@ -0,0 +1,27 @@
+require 'hiptest-publisher/indexers/actionword_uid_indexer'
+require 'hiptest-publisher/nodes'
+
+module Hiptest
+  module NodeModifiers
+    class UidCallReferencerAdder
+      def self.add(project)
+        self.new(project).update_uid_calls
+      end
+
+      def initialize(project)
+        @project = project
+        @indexer = ActionwordUidIndexer.new(project)
+      end
+
+      def update_uid_calls
+        @project.each_sub_nodes(Hiptest::Nodes::UIDCall) do |uid_call|
+          index = @indexer.get_index(uid_call.children[:uid])
+          next if index.nil?
+
+          uid_call.children[:actionword_name] = index[:actionword].children[:name]
+          uid_call.children[:library_name] = index[:library].children[:name] unless index[:library].nil?
+        end
+      end
+    end
+  end
+end

data/lib/hiptest-publisher/nodes.rb

@@ -235,6 +235,26 @@ module Hiptest
       end
     end
 
+    class UIDCall < Node
+      attr_reader :chunks, :extra_inlined_arguments
+      attr_writer :chunks, :extra_inlined_arguments
+
+      def initialize(uid, arguments = [], annotation = nil)
+        super()
+        annotation = nil if annotation == ""
+
+        @children = {
+          uid: uid,
+          arguments: arguments,
+          all_arguments: arguments,
+          annotation: annotation
+        }
+
+        @chunks = []
+        @extra_inlined_arguments = []
+      end
+    end
+
     class IfThen < Node
       def initialize(condition, then_, else_ = [])
         super()
@@ -325,8 +345,8 @@ module Hiptest
     end
 
     class Actionword < Item
-      attr_reader :chunks, :extra_inlined_parameters
-      attr_writer :chunks, :extra_inlined_parameters
+      attr_reader :chunks, :extra_inlined_parameters, :uniq_name
+      attr_writer :chunks, :extra_inlined_parameters, :uniq_name
 
       def initialize(name, tags = [], parameters = [], body = [], uid = nil, description = '')
         super(name, tags, description, parameters, body)
@@ -334,6 +354,7 @@ module Hiptest
 
         @chunks = []
         @extra_inlined_parameters = []
+        @uniq_name = name
       end
 
       def must_be_implemented?
@@ -529,8 +550,27 @@ module Hiptest
       end
     end
 
+    class Libraries < Node
+      def initialize(libraries = [])
+        super()
+        @children = {
+          libraries: libraries
+        }
+      end
+    end
+
+    class Library < Node
+      def initialize(name = 'default_library', actionwords = [])
+        super()
+        @children = {
+          name: name,
+          actionwords: actionwords
+        }
+      end
+    end
+
     class Project < Node
-      def initialize(name, description = '', test_plan = TestPlan.new, scenarios = Scenarios.new, actionwords = Actionwords.new, tests = Tests.new)
+      def initialize(name, description = '', test_plan = TestPlan.new, scenarios = Scenarios.new, actionwords = Actionwords.new, tests = Tests.new, libraries = Libraries.new)
         super()
         test_plan.parent = self if test_plan.respond_to?(:parent=)
         scenarios.parent = self
@@ -542,10 +582,15 @@ module Hiptest
           test_plan: test_plan,
           scenarios: scenarios,
           actionwords: actionwords,
-          tests: tests
+          tests: tests,
+          libraries: libraries
         }
       end
 
+      def has_libraries?
+        !children[:libraries].children[:libraries].empty?
+      end
+
       def assign_scenarios_to_folders
         @children[:scenarios].children[:scenarios].each do |scenario|
           folder = @children[:test_plan].find_folder_by_uid(scenario.folder_uid)

data/lib/hiptest-publisher/options_parser.rb

@@ -228,6 +228,7 @@ class OptionsParser
       Option.new(nil, 'show-actionwords-renamed', false, nil, "Output signatures of renamed action words", :aw_renamed),
       Option.new(nil, 'show-actionwords-signature-changed', false, nil, "Output signatures of action words for which signature changed", :aw_signature_changed),
       Option.new(nil, 'show-actionwords-definition-changed', false, nil, "Output action words for which definition changed", :aw_definition_changed),
+      Option.new(nil, 'library-name=LIBRARY_NAME', nil, String, "Use in conjunction with show-actionwords-*: show the diff for the specified library", :library_name),
       Option.new(nil, 'with-folders', false, nil, "Use folders hierarchy to export files in respective directories", :with_folders),
       Option.new(nil, 'empty-folders', false, nil, "Export empty folders", :empty_folders),
       Option.new(nil, 'split-scenarios', false, nil, "Export each scenario in a single file (except for Gherkin based languages)", :split_scenarios),
@@ -485,7 +486,7 @@ class LanguageGroupConfig
 
   def nodes(project)
     case node_name
-    when :tests, :scenarios, :actionwords
+    when :tests, :scenarios, :actionwords, :libraries
       if splitted_files?
         project.children[node_name].children[node_name]
       elsif with_folders?
@@ -493,6 +494,8 @@ class LanguageGroupConfig
       else
         [project.children[node_name]]
       end
+    when :library
+      [project.children[:libraries]]
     when :folders
       get_folder_nodes(project)
     end
@@ -608,6 +611,10 @@ class LanguageGroupConfig
       @leafless_export ? :tests : :scenarios
     elsif self[:node_name] == "actionwords" || self[:group_name] == "actionwords"
       :actionwords
+    elsif self[:node_name] == "libraries" || self[:group_name] == "libraries"
+      :libraries
+    elsif self[:node_name] == "library" || self[:group_name] == "library"
+      :library
     elsif self[:node_name] == "folders"
       :folders
     else

data/lib/hiptest-publisher/render_context_maker.rb

@@ -9,7 +9,7 @@ module Hiptest
         is_empty?: item.children[:body].empty?,
         declared_variables: item.declared_variables_names,
         raw_parameter_names: item.children[:parameters].map {|p| p.children[:name] },
-        self_name: item.children[:name],
+        self_name: item.children[:name]
       }
     end
 
@@ -27,10 +27,20 @@ module Hiptest
         chunks: aw.chunks || [],
         extra_inlined_parameters: aw.extra_inlined_parameters || [],
         has_free_text_parameter?: aw.children[:parameters].select(&:free_text?).count > 0,
-        has_datatable_parameter?: aw.children[:parameters].select(&:datatable?).count > 0
+        has_datatable_parameter?: aw.children[:parameters].select(&:datatable?).count > 0,
+        uniq_name: aw.uniq_name,
+        has_library?: (aw.parent.is_a? Hiptest::Nodes::Library) ? true : false,
+        library_name: aw.parent.nil? ? '' : aw.parent.children[:name]
       )
     end
 
+    def walk_actionwords(aws)
+      project = aws.parent
+      {
+        uses_library?: project.nil? ? false : project.has_libraries?
+      }
+    end
+
     def walk_folder(folder)
       walk_relative_item(folder).merge(
         self_name: folder.children[:name],
@@ -45,7 +55,8 @@ module Hiptest
       walk_item(scenario).merge(walk_relative_item(scenario)).merge(
         project_name: scenario.parent.parent.children[:name],
         has_datasets?: has_datasets?(scenario),
-        has_annotations?: has_annotations?(scenario)
+        has_annotations?: has_annotations?(scenario),
+        uniq_name: scenario.children[:name]
       )
     end
 
@@ -65,10 +76,6 @@ module Hiptest
       }
     end
 
-    def walk_actionwords(aws)
-      {}
-    end
-
     def walk_test(test)
       {
         has_description?: !test.children[:description].nil? && !test.children[:description].empty?,
@@ -78,7 +85,7 @@ module Hiptest
         is_empty?: test.children[:body].empty?,
         has_datasets?: false,
         project_name: test.parent.parent.children[:name],
-        self_name: test.children[:name],
+        self_name: test.children[:name]
       }
     end
 
@@ -101,6 +108,13 @@ module Hiptest
       }
     end
 
+    def walk_uidcall(uidcall)
+      {
+        has_library?: !uidcall.children[:library_name].nil?,
+        chunks: uidcall.chunks || []
+      }
+    end
+
     def walk_ifthen(it)
       {
         has_else?: !it.children[:else].empty?
@@ -137,6 +151,12 @@ module Hiptest
       }
     end
 
+    def walk_libraries(libraries)
+      {
+        library_names: libraries.children[:libraries].map {|lib| lib.children[:name]}
+      }
+    end
+
     private
 
     def has_step?(item)

data/lib/hiptest-publisher/signature_differ.rb

@@ -1,7 +1,7 @@
 module Hiptest
   class SignatureDiffer
-    def self.diff(old, current)
-      SignatureDiffer.new(old, current).compute_diff
+    def self.diff(old, current, library_name: nil)
+      SignatureDiffer.new(old, current).compute_diff(library_name)
     end
 
     def initialize(old, current)
@@ -9,9 +9,14 @@ module Hiptest
       @current = current
     end
 
-    def compute_diff
-      @old_uid = map_by_uid(@old)
-      @current_uid = map_by_uid(@current)
+    def compute_diff(library_name = nil)
+      if library_name.nil?
+        @old_uid = map_by_uid(@old)
+        @current_uid = map_by_uid(@current)
+      else
+        @old_uid = map_by_uid(get_library_actionwords(@old, library_name))
+        @current_uid = map_by_uid(get_library_actionwords(@current, library_name))
+      end
 
       compute_created
       compute_deleted
@@ -88,8 +93,13 @@ module Hiptest
       end.compact
     end
 
-    def map_by_uid(actionwords)
-      Hash[actionwords.collect { |aw| [aw['uid'], aw] }]
+    def get_library_actionwords(data, library_name)
+      library = data.select {|item| item['type'] == 'library' && item['name'] == library_name}.first
+      library.nil? ? [] : library['actionwords']
+    end
+
+    def map_by_uid(items)
+      Hash[items.reject {|item| item['type'] == 'library'}.collect { |aw| [aw['uid'], aw] }]
     end
   end
 end

data/lib/hiptest-publisher/signature_exporter.rb

@@ -5,14 +5,30 @@ module Hiptest
   class SignatureExporter
     def self.export_actionwords(project, export_nodes = false)
       exporter = SignatureExporter.new
-      exporter.export_actionwords(project.children[:actionwords], export_nodes)
+
+      [
+        exporter.export_actionwords(project.children[:actionwords], export_nodes),
+        exporter.export_libraries(project.children[:libraries], export_nodes)
+      ].flatten
     end
 
     def export_actionwords(aws, export_nodes = false)
       aws.children[:actionwords].map {|aw| export_actionword(aw, export_nodes)}
     end
 
-    def export_item(item, export_node = false)
+    def export_libraries(libraries, export_nodes = false)
+      libraries.children[:libraries].map {|lib| export_library(lib, export_nodes)}
+    end
+
+    def export_library(library, export_nodes = false)
+      {
+        'name' => library.children[:name],
+        'type' => 'library',
+        'actionwords' => library.children[:actionwords].map {|aw| export_actionword(aw, export_nodes) }
+      }
+    end
+
+    def export_actionword(item, export_node = false)
       hash = {
         'name' => item.children[:name],
         'uid' => item.children[:uid],
@@ -22,8 +38,6 @@ module Hiptest
       hash['node'] = item if export_node
       hash
     end
-    alias :export_actionword :export_item
-    alias :export_scenario :export_item
 
     def export_parameters(item)
       item.children[:parameters].map {|p| export_parameter(p)}