hiptest-publisher-fork 3.2.0

data/lib/hiptest-publisher/indexers/library_actionword_indexer.rb

@@ -0,0 +1,32 @@
+module Hiptest
+  class LibraryActionwordIndexer
+    def initialize(project)
+      @project = project
+      @indexed = {}
+      index_library_actionwords
+    end
+
+    def index_library_actionwords
+      @project.each_sub_nodes(Hiptest::Nodes::LibraryActionword) do |aw|
+        aw_name = aw.children[:name]
+        indexed_parameters = {}
+
+        aw.children[:parameters].map do |param|
+          param_name = param.children[:name]
+          indexed_parameters[param_name] = param.children[:default]
+        end
+
+        data = {
+          actionword: aw,
+          parameters: indexed_parameters
+        }
+
+        @indexed[aw_name] = data
+      end
+    end
+
+    def get_index(name)
+      @indexed[name]
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Hiptest
+  module NodeModifiers
+    class ActionwordUniqRenamer
+      def self.add(project)
+        self.new(project).make_uniq_names
+      end
+
+      def initialize(project)
+        @project = project
+      end
+
+      def make_uniq_names
+        @project.children[:libraries].children[:libraries].each do |library|
+          library.children[:library_actionwords].each do |library_actionword|
+            existing_names = library.children[:library_actionwords].reject{|aw| aw == library_actionword}.map(&:uniq_name)
+            new_name = find_uniq_name(library_actionword.children[:name], existing_names)
+            library_actionword.uniq_name = new_name
+          end
+        end
+      end
+
+      def find_uniq_name(name, existing)
+        return name unless existing.include?(name)
+
+        index = 1
+        new_name = ""
+
+        loop do
+          new_name = "#{name} #{index}"
+
+          break unless existing.include?(new_name)
+          index += 1
+        end
+
+        new_name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'hiptest-publisher/node_modifiers/actionword_uniq_renamer'
+require 'hiptest-publisher/node_modifiers/call_arguments_adder'
+require 'hiptest-publisher/node_modifiers/datatable_fixer'
+require 'hiptest-publisher/node_modifiers/gherkin_adder'
+require 'hiptest-publisher/node_modifiers/items_orderer'
+require 'hiptest-publisher/node_modifiers/parameter_type_adder'
+require 'hiptest-publisher/node_modifiers/parent_adder'
+
+module Hiptest
+  module NodeModifiers
+    def self.add_all(project, sort_method = nil)
+      DatatableFixer.add(project)
+      ParentAdder.add(project)
+      ParameterTypeAdder.add(project)
+      DefaultArgumentAdder.add(project)
+      ActionwordUniqRenamer.add(project)
+      GherkinAdder.add(project)
+      ItemsOrderer.add(project, sort_method) unless sort_method.nil?
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'hiptest-publisher/indexers/actionword_indexer'
+require 'hiptest-publisher/indexers/library_actionword_indexer'
+require 'hiptest-publisher/nodes'
+
+module Hiptest
+  module NodeModifiers
+    class DefaultArgumentAdder
+      def self.add(project)
+        self.new(project).update_calls
+      end
+
+      def initialize(project)
+        @project = project
+        @library_indexer = LibraryActionwordIndexer.new(project)
+        @indexer = ActionwordIndexer.new(project)
+      end
+
+      def update_calls
+        @project.each_sub_nodes(Hiptest::Nodes::Call) do |call|
+          actionword = @library_indexer.get_index(call.children[:actionword])
+          actionword = @indexer.get_index(call.children[:actionword]) if actionword.nil?
+
+          update_call(call, actionword)
+        end
+      end
+
+      private
+
+      def update_call(call, aw_data)
+        return if aw_data.nil?
+
+        arguments = {}
+        call.children[:arguments].each do |arg|
+          arguments[arg.children[:name]] = arg.children[:value]
+        end
+
+        call.children[:all_arguments] = aw_data[:parameters].map do |p_name, default_value|
+          Hiptest::Nodes::Argument.new(
+            p_name,
+            arguments.has_key?(p_name) ? arguments[p_name] : default_value
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'hiptest-publisher/nodes_walker'
+
+module Hiptest
+  module NodeModifiers
+    class DatatableFixer < Nodes::Walker
+      def self.add(project)
+        self.new.walk_node(project)
+      end
+
+      def walk_scenario(scenario)
+        return if scenario.children[:datatable].nil?
+
+        @argument_names = scenario.children[:parameters].map{|param| param.children[:name]}
+
+        scenario.children[:datatable].children[:datasets].map do |dataset|
+          arguments_mapping = {}
+          dataset.children[:arguments].map do |arg|
+            arguments_mapping[arg.children[:name]] = arg
+          end
+
+          dataset.children[:arguments] = @argument_names.map do |arg_name|
+            if arguments_mapping.has_key?(arg_name)
+              arguments_mapping[arg_name]
+            else
+              Hiptest::Nodes::Argument.new(arg_name, Hiptest::Nodes::StringLiteral.new(''))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,252 @@
+require 'hiptest-publisher/indexers/actionword_indexer'
+require 'hiptest-publisher/indexers/library_actionword_indexer'
+require 'hiptest-publisher/nodes'
+
+module Hiptest
+  module NodeModifiers
+    class GherkinAdder
+      def self.add(project)
+        self.new(project).update_calls
+      end
+
+      def initialize(project)
+        @project = project
+        @indexer = ActionwordIndexer.new(project)
+        @library_indexer = LibraryActionwordIndexer.new(project)
+        @annotations_counter = AnnotationsCounter.new
+
+        @special_params = ['__free_text', '__datatable']
+      end
+
+      def update_calls
+        @project.each_sub_nodes(Hiptest::Nodes::Scenario, Hiptest::Nodes::Actionword, Hiptest::Nodes::Test, Hiptest::Nodes::Folder) do |item|
+          @last_annotation = nil
+          item.each_sub_nodes(Hiptest::Nodes::Call) do |call|
+            set_call_chunks(call)
+            call.children[:gherkin_text] ||= "#{text_annotation(call)} #{prettified(call)}"
+
+            if actionword = get_actionword(call)
+              if actionword.is_a?(Hiptest::Nodes::LibraryActionword)
+                call.children[:library_name] = actionword.parent.children[:name]
+              end
+              @annotations_counter.increment(actionword, code_annotation(call))
+              set_actionwords_chunks(actionword)
+
+              actionword.children[:gherkin_pattern] ||= pattern(actionword)
+              actionword.children[:parameters_ordered_by_pattern] ||= order_parameters_by_pattern(actionword)
+            end
+          end
+        end
+
+        @annotations_counter.actionwords.each do |actionword|
+          actionword.children[:gherkin_annotation] = @annotations_counter.most_used_annotation(actionword) || "Given"
+          actionword.children[:gherkin_used_annotations] = @annotations_counter.all_used_annotations(actionword) || ['Given']
+        end
+      end
+
+      def annotation(call)
+        call.children[:annotation].capitalize if call.children[:annotation]
+      end
+
+      def text_annotation(call)
+        annotation(call) || "*"
+      end
+
+      def code_annotation(call)
+        call_annotation = annotation(call)
+        if call_annotation
+          if ["And", "But"].include?(call_annotation)
+            call_annotation = @last_annotation || "Given"
+          end
+          @last_annotation = call_annotation
+        end
+      end
+
+      def prettified(call)
+        base = call.chunks.map {|chunk| chunk[:value]}.join("\"").strip
+        call.extra_inlined_arguments.each do |chunk|
+          base += " \"#{chunk[:value]}\""
+        end
+
+        base
+      end
+
+      def set_call_chunks(call)
+        all_arguments = all_valued_arguments_for(call)
+        inline_parameter_names = []
+        extra_inlined_arguments = []
+
+        call.chunks = []
+        call.extra_inlined_arguments = []
+
+        actionword_name = call.is_a?(Hiptest::Nodes::Call) ? call.children[:actionword] : call.children[:actionword_name]
+        call_chunks = actionword_name.split("\"", -1)
+
+        call_chunks.each_slice(2) do |text, inline_parameter_name|
+          call.chunks << {
+            value: text,
+            is_argument: false
+          }
+
+          if all_arguments.has_key?(inline_parameter_name)
+            inline_parameter_names << inline_parameter_name.clone
+            value = all_arguments[inline_parameter_name]
+            inline_parameter_name.replace(value)
+
+            call.chunks << {
+              value: inline_parameter_name,
+              is_argument: true
+            }
+          else
+           call.chunks << {
+              value: inline_parameter_name,
+              is_argument: false
+            } unless inline_parameter_name.nil?
+          end
+        end
+
+        missing_parameter_names = all_arguments.keys - inline_parameter_names - @special_params
+        call.extra_inlined_arguments = missing_parameter_names.map do |missing_parameter_name|
+          {
+            value: all_arguments[missing_parameter_name],
+            is_argument: true
+          }
+        end
+      end
+
+      def pattern(actionword)
+        patterned = actionword.chunks.map {|chunk| chunk[:value]}.join("\"")
+        actionword.extra_inlined_parameters.each do |param|
+          patterned += " \"#{param[:value]}\""
+        end
+
+        "^#{patterned.strip}$"
+      end
+
+      def set_actionwords_chunks(actionword)
+        name = actionword.uniq_name
+        actionword_parameters = evaluated_map(actionword.children[:parameters])
+        name_chunks = name.split("\"", -1)
+        inline_parameter_names = []
+
+        actionword.chunks = []
+        actionword.extra_inlined_parameters = []
+
+        name_chunks.each_slice(2) do |text, inline_parameter_name|
+          actionword.chunks << {
+            value: text.gsub(/[.|()\\.+*?\[\]{}^$]/) { |c| "\\#{c}" },
+            is_parameter: false
+          }
+
+          inline_parameter_names << inline_parameter_name if inline_parameter_name
+          if actionword_parameters.has_key?(inline_parameter_name)
+            actionword.chunks << {
+              value: "(.*)",
+              name: inline_parameter_name,
+              is_parameter: true
+            }
+          else
+            actionword.chunks << {
+              value: inline_parameter_name,
+              is_parameter: false
+            } if inline_parameter_name
+          end
+        end
+        missing_parameter_names = actionword_parameters.keys - inline_parameter_names - @special_params
+
+        missing_parameter_names.each do |missing_parameter_name|
+          actionword.extra_inlined_parameters << {
+            value: "(.*)",
+            name: missing_parameter_name,
+            is_parameter: true
+          }
+        end
+      end
+
+      def order_parameters_by_pattern(actionword)
+        inline_parameter_names = actionword.children[:name].scan(/\"(.*?)\"/).flatten
+        actionword_parameters = {}
+        actionword.children[:parameters].map {|p| actionword_parameters[p.children[:name]] = p}
+
+        missing_parameter_names = actionword_parameters.keys - inline_parameter_names - @special_params
+        [inline_parameter_names, missing_parameter_names, @special_params].flatten.map do |name|
+          actionword_parameters[name]
+        end.compact
+      end
+
+      def all_valued_arguments_for(call)
+        evaluated_call_arguments = evaluated_map(call.children[:arguments])
+        evaluated_actionword_parameters = evaluated_map(get_actionword_parameters(call))
+        names = evaluated_actionword_parameters.keys
+
+        hash_array = names.map { |name|
+          value = evaluated_call_arguments[name] || evaluated_actionword_parameters[name] || ""
+          [name, value]
+        }
+        Hash[hash_array]
+      end
+
+      def get_actionword_parameters(call)
+        actionword = get_actionword(call)
+        actionword && actionword.children[:parameters] || []
+      end
+
+      def get_actionword(call)
+        actionword = @library_indexer.get_index(call.children[:actionword])
+
+        if actionword.nil?
+          actionword = @indexer.get_index(call.children[:actionword])
+        end
+
+        actionword && actionword[:actionword] || nil
+      end
+
+      def evaluated_map(named_values)
+        hash_array = named_values.map do |named_value|
+          name = named_value.children[:name]
+          value = evaluate(named_value.children[:value] || named_value.children[:default])
+          [name, value]
+        end
+        Hash[hash_array]
+      end
+
+      def evaluate(value)
+        if value.nil?
+          nil
+        elsif Hiptest::Nodes::Variable === value
+          "<#{value.children[:name]}>"
+        elsif value.children[:chunks]
+          value.children[:chunks].map {|chunk| evaluate(chunk) }.join('')
+        elsif value.children[:value]
+          value.children[:value]
+        else
+          nil
+        end
+      end
+    end
+
+    class AnnotationsCounter
+      def initialize
+        @counts_by_actionword = Hash.new {|counts, actionword| counts[actionword] = Hash.new(0) }
+      end
+
+      def actionwords
+        @counts_by_actionword.keys
+      end
+
+      def increment(actionword, annotation)
+        counts = @counts_by_actionword[actionword]
+        counts[annotation] += 1 if annotation
+      end
+
+      def most_used_annotation(actionword)
+        max = @counts_by_actionword[actionword].values.max
+        @counts_by_actionword[actionword].key(max)
+      end
+
+      def all_used_annotations(actionword)
+        @counts_by_actionword[actionword].keys
+      end
+    end
+  end
+end

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/node_modifiers/parameter_type_adder.rb

@@ -0,0 +1,141 @@
+require 'hiptest-publisher/nodes_walker'
+require 'hiptest-publisher/project_grapher'
+
+module Hiptest
+  module NodeModifiers
+    class ParameterTypeAdder
+      attr_reader :call_types
+
+      def self.add(project)
+        self.new.process(project)
+      end
+
+      def initialize
+        @call_types = CallTypes.new
+      end
+
+      def process(project)
+        gather_scenarios_argument_types(project)
+        gather_actionwords_default_parameters_types(project)
+
+        # To have the most accurate type, the closest calls must be computed
+        # first, and deepest calls must be computed last (because they  depend
+        # on previous calls types).
+        distances_index = Hiptest::ProjectGrapher.distances_index(project)
+        distances_index.each_value do |items|  # distances_index items are sorted by distance, from closest to deepest
+          items.each do |item|
+            write_parameter_types_to_item(item)
+            gather_call_argument_types(item)
+          end
+        end
+      end
+
+      def gather_scenarios_argument_types(project)
+        project.children[:scenarios].children[:scenarios].each do |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], 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))
+          end
+        end
+      end
+
+      def gather_call_argument_types(node)
+        node.each_sub_nodes(Hiptest::Nodes::Call) do |call|
+          actionword_name = call.children[:actionword]
+
+          @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(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(Hiptest::Nodes::Argument) do |argument|
+          @call_types.add_argument_type(argument.children[:name], get_type(argument.children[:value], context))
+        end
+      end
+
+      private
+
+      def get_type(value, context = nil)
+        case value
+          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
+
+      def get_var_value(name, context)
+        return :null if context.nil? || context.children[:parameters].nil?
+
+        context.children[:parameters].each do |param|
+          if param.children[:name] == name
+            return param.children[:type] || :null
+          end
+        end
+
+        return :null
+      end
+    end
+
+    class CallTypes
+      def initialize
+        @callable_items = {}
+        @current_callable_item = nil
+      end
+
+      def add_callable_item(item_name, item_type)
+        name = "#{item_type}-#{item_name}"
+        @callable_items[name] ||= {}
+        @current_callable_item = @callable_items[name]
+      end
+
+      def add_argument_type(name, type)
+        @current_callable_item[name] ||= {types: Set.new}
+        @current_callable_item[name][:types] << type
+      end
+
+      def type_of(item_name, parameter_name, item_type)
+        name = "#{item_type}-#{item_name}"
+        callable_item =  @callable_items[name]
+        return :String if callable_item.nil?
+
+        parameter = callable_item[parameter_name]
+
+        return :String if parameter.nil?
+        return type_from_types(parameter[:types])
+      end
+
+      private
+
+      def type_from_types(types)
+        types = types - [:null]
+        if types.empty?
+          :null
+        elsif types.length == 1
+          types.first
+        elsif types == Set[:float, :int]
+          :float
+        else
+          :String
+        end
+      end
+    end
+  end
+end

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

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