hiptest-publisher 1.13.0 → 1.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf3135292196dceadbed7955498ce586d8f08b075a3bab0323efd92403876835
-  data.tar.gz: 6af5171a3e54d523bdcd79970e8847f1e94e89019a7c33a98e3436de27f44b47
+  metadata.gz: 93bcd3b1fd153cfef0772ddca03018f5286a9818c2027c051ab294db962593f3
+  data.tar.gz: e2e270ed0e0df6974697c41465fac47b46dd479db86971897b614e70fdc143dc
 SHA512:
-  metadata.gz: 1d7e65e2f1d31e605cb24a48cc1cb8c87137098571b76da485fc2513dd5795fabe81e561ea102f2e7fc17462b8389aa0ab1d0a05979436ccf3c62540cd3ca057
-  data.tar.gz: 3c5d13ec78ba4f3fa828ec053652a05f29cdb1f23c1a0e266efd3611c851c4b38c53b3d9eef8b41a0a3a58c0538420a3aa2c21220516d920a66175fe80734b74
+  metadata.gz: 5e07c6ab53bf5cb4d4884c3079a253ae654574a6ced1ef54528c8b1213e188f708d72811b928bdd7212368189ad376d4bb28890dc7e777a8efc97b07532d1934
+  data.tar.gz: c54b5414d1c7bd4a08286f1631e85850b1894b8fbee973fe63c6d967e8785acd2d1a8efda06c7222dbd07af3ce54a864025ddfc937e22cf25a46a58073468531

data/lib/config/cucumber-groovy.conf

@@ -20,6 +20,21 @@ filename = 'StepDefinitions.groovy'
 call_prefix = 'actionwords'
 renderer_addons = 'GherkinAddon'
 
+[step_definitions_library]
+node_name = libraries
+call_prefix = 'actionwords'
+template_dirs = cucumber/groovy/step-definitions, groovy, java, common
+named_filename = 'StepDefinitions%s.groovy'
+renderer_addons = 'GherkinAddon'
+
 [actionwords]
 template_dirs = cucumber/groovy/actionwords, groovy, java, common
 filename = 'Actionwords.groovy'
+
+[library]
+template_dirs = cucumber/groovy/actionwords-library, groovy, java, common
+filename = 'ActionwordLibrary.groovy'
+
+[libraries]
+template_dirs = cucumber/groovy/actionwords-library, groovy, java, common
+named_filename = '%sLibrary.groovy'

data/lib/config/java-junit.conf

@@ -13,3 +13,9 @@ call_prefix = 'actionwords'
 
 [actionwords]
 filename = 'Actionwords.java'
+
+[library]
+filename = 'ActionwordLibrary.java'
+
+[libraries]
+named_filename = '%sLibrary.java'

data/lib/hiptest-publisher.rb

@@ -2,19 +2,14 @@ require 'colorize'
 require 'json'
 require 'yaml'
 
-require 'hiptest-publisher/call_arguments_adder'
+require 'hiptest-publisher/node_modifiers/add_all'
 require 'hiptest-publisher/cli_options_checker'
 require 'hiptest-publisher/client'
-require 'hiptest-publisher/datatable_fixer'
-require 'hiptest-publisher/diff_displayer'
+require 'hiptest-publisher/formatters/diff_displayer'
 require 'hiptest-publisher/formatters/reporter'
 require 'hiptest-publisher/file_writer'
-require 'hiptest-publisher/gherkin_adder'
 require 'hiptest-publisher/handlebars_helper'
-require 'hiptest-publisher/items_orderer'
 require 'hiptest-publisher/options_parser'
-require 'hiptest-publisher/parameter_type_adder'
-require 'hiptest-publisher/parent_adder'
 require 'hiptest-publisher/renderer'
 require 'hiptest-publisher/signature_differ'
 require 'hiptest-publisher/signature_exporter'
@@ -143,7 +138,8 @@ module Hiptest
 
     def export_files
       @language_config.language_group_configs.each do |language_group_config|
-        ask_overwrite = language_group_config[:group_name] == 'actionwords'
+        next if ['library', 'libraries'].include?(language_group_config[:group_name]) && !@project.has_libraries?
+        ask_overwrite = ['actionwords', 'libraries'].include?(language_group_config[:group_name])
 
         language_group_config.each_node_rendering_context(@project) do |node_rendering_context|
           write_node_to_file(
@@ -176,7 +172,7 @@ module Hiptest
       analyze_project_data
 
       current = Hiptest::SignatureExporter.export_actionwords(@project, true)
-      diff =  Hiptest::SignatureDiffer.diff( old, current)
+      diff =  Hiptest::SignatureDiffer.diff(old, current, library_name: @cli_options.library_name)
     end
 
     def show_actionwords_diff
@@ -189,12 +185,7 @@ module Hiptest
       return if @project_data_analyzed
       reporter.with_status_message "Analyzing data" do
         @language_config = LanguageConfigParser.new(@cli_options)
-        Hiptest::Nodes::DatatableFixer.add(@project)
-        Hiptest::Nodes::ParentAdder.add(@project)
-        Hiptest::Nodes::ParameterTypeAdder.add(@project)
-        Hiptest::DefaultArgumentAdder.add(@project)
-        Hiptest::GherkinAdder.add(@project)
-        Hiptest::ItemsOrderer.add(@project, @cli_options.sort)
+        Hiptest::NodeModifiers.add_all(@project, @cli_options.sort)
       end
       @project_data_analyzed = true
     end

data/lib/hiptest-publisher/formatters/reporter.rb

@@ -1,5 +1,3 @@
-
-
 class Reporter
   def initialize(listeners = nil)
     @listeners = listeners || []

data/lib/hiptest-publisher/{actionword_indexer.rb → indexers/actionword_indexer.rb}

@@ -3,6 +3,7 @@ module Hiptest
     def initialize(project)
       @project = project
       @indexed = {}
+      @uid_indexed = {}
       index_actionwords
     end
 
@@ -16,16 +17,22 @@ module Hiptest
           indexed_parameters[param_name] = param.children[:default]
         end
 
-        @indexed[aw_name] = {
+        data = {
           actionword: aw,
           parameters: indexed_parameters
         }
 
+        @indexed[aw_name] = data
+        @uid_indexed[aw.children[:uid]] = data
       end
     end
 
     def get_index(name)
       @indexed[name]
     end
+
+    def get_uid_index(uid)
+      @uid_indexed[uid]
+    end
   end
 end

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

@@ -0,0 +1,34 @@
+module Hiptest
+  class ActionwordUidIndexer
+    def initialize(project)
+      @project = project
+      @indexed = {}
+      index_actionwords
+    end
+
+    def index_actionwords
+      @project.children[:actionwords].children[:actionwords].each do |actionword|
+        index_actionword(actionword)
+      end
+
+      @project.children[:libraries].children[:libraries].each do |library|
+        library.children[:actionwords].each do |actionword|
+          index_actionword(actionword, library: library)
+        end
+      end
+    end
+
+    def get_index(uid)
+      @indexed[uid]
+    end
+
+    private
+
+    def index_actionword(actionword, library: nil)
+      @indexed[actionword.children[:uid]] = {
+        actionword: actionword,
+        library: library
+      }
+    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[:actionwords].each do |actionword|
+            existing_names = library.children[:actionwords].reject{|aw| aw == actionword}.map(&:uniq_name)
+            new_name = find_uniq_name(actionword.children[:name], existing_names)
+            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,23 @@
+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'
+require 'hiptest-publisher/node_modifiers/uid_call_reference_adder'
+
+module Hiptest
+  module NodeModifiers
+    def self.add_all(project, sort_method = nil)
+      DatatableFixer.add(project)
+      ParentAdder.add(project)
+      UidCallReferencerAdder.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,52 @@
+require 'hiptest-publisher/indexers/actionword_indexer'
+require 'hiptest-publisher/nodes'
+
+module Hiptest
+  module NodeModifiers
+    class DefaultArgumentAdder
+      def self.add(project)
+        self.new(project).update_all_calls
+      end
+
+      def initialize(project)
+        @project = project
+        @indexer = ActionwordIndexer.new(project)
+      end
+
+      def update_all_calls
+        update_calls
+        update_uid_calls
+      end
+
+      def update_calls
+        @project.each_sub_nodes(Hiptest::Nodes::Call) do |call|
+          update_call(call, @indexer.get_index(call.children[:actionword]))
+        end
+      end
+
+      def update_uid_calls
+        @project.each_sub_nodes(Hiptest::Nodes::UIDCall) do |uid_call|
+          update_call(uid_call, @indexer.get_uid_index(uid_call.children[:uid]))
+        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/{datatable_fixer.rb → node_modifiers/datatable_fixer.rb}

@@ -1,10 +1,10 @@
 require 'hiptest-publisher/nodes_walker'
 
 module Hiptest
-  module Nodes
-    class DatatableFixer < Walker
+  module NodeModifiers
+    class DatatableFixer < Nodes::Walker
       def self.add(project)
-        Hiptest::Nodes::DatatableFixer.new.walk_node(project)
+        self.new.walk_node(project)
       end
 
       def walk_scenario(scenario)

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

@@ -0,0 +1,243 @@
+require 'hiptest-publisher/indexers/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)
+        @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, Hiptest::Nodes::UIDCall) do |call|
+            set_call_chunks(call)
+            call.children[:gherkin_text] ||= "#{text_annotation(call)} #{prettified(call)}"
+
+            if actionword = get_actionword(call)
+              @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 = []
+
+        call_chunks = call.is_a?(Hiptest::Nodes::Call) ? call.children[:actionword].split("\"", -1) : call.children[: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 = call.is_a?(Hiptest::Nodes::UIDCall) ? @indexer.get_uid_index(call.children[:uid]) : @indexer.get_index(call.children[:actionword])
+
+        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