hiptest-publisher-fork 3.2.0

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

@@ -0,0 +1,101 @@
+require 'i18n'
+
+require 'hiptest-publisher/utils'
+
+class ConsoleFormatter
+  attr_reader :verbose
+
+  def initialize(verbose, color: nil)
+    @verbose = verbose
+    @color = color.nil? ? tty? : color
+    @immediate_verbose = true
+    @verbose_messages = []
+  end
+
+  def dump_error(error, message = nil)
+    return unless verbose
+    puts colorize(message, :blue) if message
+    line = "-" * 80
+    puts colorize(line, :yellow)
+    puts colorize("#{error.class.name}: #{error.message}", :red)
+    puts colorize("#{error.backtrace.map {|l| "  #{l}\n"}.join}", :yellow)
+    puts colorize(line, :yellow)
+  end
+
+  def show_error(message)
+    STDOUT.print colorize(message, :yellow)
+  end
+
+  def show_failure(message)
+    STDOUT.print(colorize(message, :red))
+  end
+
+  def show_options(options, message = nil)
+    return unless verbose
+    message ||= I18n.t(:verbose_header, version: hiptest_publisher_version)
+    puts colorize(message, :yellow)
+    options.each { |k, v| puts " - #{k}: #{v.inspect}" }
+  end
+
+  def show_verbose_message(message)
+    return unless verbose
+    if @immediate_verbose
+      STDOUT.print "#{message}\n"
+    else
+      @verbose_messages << message
+    end
+  end
+
+  def show_status_message(message, status=nil)
+    status_icon = " "
+    output = STDOUT
+
+    if status == :success
+      status_icon = colorize("v", :green)
+    elsif status == :warning
+      status_icon = colorize("?", :yellow)
+    elsif status == :failure
+      status_icon = colorize("x", :red)
+      output = STDERR
+    end
+    if status
+      @immediate_verbose = true
+      cursor_offset = ""
+    else
+      return unless tty?
+      return if IO.console.nil?
+      rows, columns = IO.console.winsize
+      return if columns == 0
+      @immediate_verbose = false
+      vertical_offset = (4 + message.length) / columns
+      cursor_offset = "\r\e[#{vertical_offset + 1}A"
+    end
+
+    output.print "[#{status_icon}] #{message}#{cursor_offset}\n"
+
+    if @immediate_verbose && !@verbose_messages.empty?
+      @verbose_messages.each { |message| show_verbose_message(message) }
+      @verbose_messages.clear
+    end
+  end
+
+  def ask(question)
+    return unless tty?
+    STDOUT.print "[#{colorize('?', :yellow)}] #{question}"
+    return $stdin.gets.chomp.downcase.strip
+  end
+
+  def colored?
+    @color
+  end
+
+  private
+
+  def tty?
+    $stdout.tty?
+  end
+
+  def colorize(txt, color)
+    colored? ? txt.send(color) : txt
+  end
+end

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

@@ -0,0 +1,173 @@
+require 'i18n'
+
+module Hiptest
+  class DiffDisplayer
+    def initialize(diff, cli_options, language_config, file_writer)
+      @diff = diff
+      @cli_options = cli_options
+      @language_config = language_config
+      @file_writer = file_writer
+    end
+
+    def display
+      return export_as_json if @cli_options.actionwords_diff_json && @cli_options.output_directory
+      return display_as_json if @cli_options.actionwords_diff_json
+      return display_deleted if @cli_options.aw_deleted
+      return display_created if @cli_options.aw_created
+      return display_renamed if @cli_options.aw_renamed
+      return display_signature_changed if @cli_options.aw_signature_changed
+      return display_definition_changed if @cli_options.aw_definition_changed
+
+      display_summary
+    end
+
+    def display_created
+      return display_skeletons(@diff[:created])
+    end
+
+    def display_renamed
+      return if @diff[:renamed].nil?
+
+      output(@diff[:renamed].map {|renamed|
+        "#{@language_config.name_action_word(renamed[:name])}\t#{@language_config.name_action_word(renamed[:new_name])}"
+      })
+    end
+
+    def display_signature_changed
+      display_skeletons(@diff[:signature_changed])
+    end
+
+    def display_definition_changed
+      display_skeletons(@diff[:definition_changed])
+    end
+
+    def display_deleted
+      return if @diff[:deleted].nil?
+
+      output(@diff[:deleted].map {|deleted|
+        @language_config.name_action_word(deleted[:name])
+      })
+    end
+
+    def export_as_json
+      @file_writer.write_to_file(
+        "#{@cli_options.output_directory}/actionwords-diff.json",
+        I18n.t('actionwords_diff.exporting_diff_title')) {
+        JSON.pretty_generate(as_api)
+      }
+    end
+
+    def display_as_json
+      output(JSON.pretty_generate(as_api))
+    end
+
+    def as_api
+      data = {}
+
+      data[:deleted] = @diff[:deleted].map {|aw|
+        {
+          name: aw[:name],
+          name_in_code: @language_config.name_action_word(aw[:name])
+        }
+      } unless @diff[:deleted].nil?
+
+      data[:created] = @diff[:created].map {|aw|
+        {
+          name: aw[:name],
+          skeleton: actionword_skeleton(aw)
+        }
+      } unless @diff[:created].nil?
+
+      data[:renamed] = @diff[:renamed].map {|aw|
+        {
+          name: aw[:name],
+          old_name: @language_config.name_action_word(aw[:name]),
+          new_name: @language_config.name_action_word(aw[:new_name])
+        }
+      } unless @diff[:renamed].nil?
+
+      data[:signature_changed] = @diff[:signature_changed].map {|aw|
+        {
+          name: aw[:name],
+          skeleton: actionword_skeleton(aw)
+        }
+      } unless @diff[:signature_changed].nil?
+
+
+      data[:definition_changed] = @diff[:definition_changed].map {|aw|
+        {
+          name: aw[:name],
+          skeleton: actionword_skeleton(aw)
+        }
+      } unless @diff[:definition_changed].nil?
+
+      return data
+    end
+
+    def display_summary
+      command_line = @cli_options.command_line_used(exclude: [:actionwords_diff])
+
+      unless @diff[:deleted].nil?
+        puts I18n.t('actionwords_diff.summary.deleted', count: @diff[:deleted].length, command_line: command_line, list: displayable_list(@diff[:deleted]))
+        puts ""
+      end
+
+      unless @diff[:created].nil?
+        puts I18n.t('actionwords_diff.summary.created', count: @diff[:created].length, command_line: command_line, list: displayable_list(@diff[:created]))
+        puts ""
+      end
+
+      unless @diff[:renamed].nil?
+        puts I18n.t('actionwords_diff.summary.renamed', count: @diff[:renamed].length, command_line: command_line, list: displayable_list(@diff[:renamed]))
+        puts ""
+      end
+
+      unless @diff[:signature_changed].nil?
+        puts I18n.t('actionwords_diff.summary.signature_changed', count: @diff[:signature_changed].length, command_line: command_line, list: displayable_list(@diff[:signature_changed]))
+        puts ""
+      end
+
+      unless @diff[:definition_changed].nil?
+        puts I18n.t('actionwords_diff.summary.definition_changed', count: @diff[:definition_changed].length, command_line: command_line, list: displayable_list(@diff[:definition_changed]))
+        puts ""
+      end
+
+      if @diff.empty?
+        puts I18n.t('actionwords_diff.summary.empty')
+        puts ""
+      end
+    end
+
+    private
+
+    def output(lines, add_empty_line: true)
+      puts Array(lines).join("\n")
+      puts "" if add_empty_line
+    end
+
+    def displayable_list(actionwords)
+      actionwords.map {|c| "- #{c[:name]}"}.join("\n")
+    end
+
+    def actionword_skeleton(actionword)
+      return if actionwords_group_config.nil?
+
+      node_rendering_context = actionwords_group_config.build_node_rendering_context(actionword[:node])
+      actionword[:node].render(node_rendering_context)
+    end
+
+    def display_skeletons(actionwords)
+      return if actionwords.nil?
+
+      actionwords.each do |actionword|
+        output(actionword_skeleton(actionword))
+      end
+    end
+
+    def actionwords_group_config
+      @actionwords_group_config ||= @language_config.language_group_configs.select { |language_group_config|
+        language_group_config[:group_name] == "actionwords"
+      }.first
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+class Reporter
+  def initialize(listeners = nil)
+    @listeners = listeners || []
+  end
+
+  def add_listener(listener)
+    @listeners << listener
+  end
+
+  def dump_error(error, message = nil)
+    notify(:dump_error, error, message)
+  end
+
+  def show_error(message)
+    notify(:show_error, message)
+  end
+
+  def show_failure(message)
+    notify(:show_failure, message)
+  end
+
+  def show_options(options, message = nil)
+    notify(:show_options, options, message)
+  end
+
+  def show_verbose_message(message)
+    notify(:show_verbose_message, message)
+  end
+
+  def with_status_message(message, &blk)
+    notify(:show_status_message, message)
+    status = :success
+    yield
+  rescue
+    status = :failure
+    raise
+  ensure
+    notify(:show_status_message, message, status)
+  end
+
+  def success_message(message)
+    notify(:show_status_message, message, :success)
+  end
+
+  def warning_message(message)
+    notify(:show_status_message, message, :warning)
+  end
+
+  def failure_message(message)
+    notify(:show_status_message, message, :failure)
+  end
+
+  def notify(message, *args)
+    @listeners.each do |listener|
+      listener.send(message, *args)
+    end
+    nil
+  end
+
+  def ask(question)
+    askable_listener = @listeners.find { |l| l.respond_to?(:ask) }
+    return nil if askable_listener.nil?
+    return askable_listener.ask(question)
+  end
+end
+
+class NullReporter
+  def with_status_message(message, &blk)
+    yield
+  end
+
+  def method_missing(*args)
+  end
+end

data/lib/hiptest-publisher/handlebars_helper.rb

@@ -0,0 +1,314 @@
+module Hiptest
+  class HandlebarsHelper
+    def self.register_helpers(handlebars, context)
+      instance = Hiptest::HandlebarsHelper.new(handlebars, context)
+      instance.register_string_helpers
+      instance.register_custom_helpers
+    end
+
+    def initialize(handlebars, context)
+      @handlebars = handlebars
+      @context = context
+    end
+
+    def register_string_helpers
+      string_helpers = [
+        :literate,
+        :normalize,
+        :normalize_lower,
+        :normalize_with_dashes,
+        :normalize_with_spaces,
+        :underscore,
+        :capitalize,
+        :camelize,
+        :camelize_lower,
+        :camelize_upper,
+        :clear_extension,
+        :downcase,
+        :strip
+      ]
+
+      string_helpers.each do |helper|
+        @handlebars.register_helper(helper) do |context, block|
+          if block.is_a? Handlebars::Tree::Block
+            value = block.fn(context)
+          else
+            value = block
+          end
+          "#{value.to_s.send(helper)}"
+        end
+      end
+    end
+
+    def register_custom_helpers
+      self.class.instance_methods.each do |method_name|
+        if method_name.to_s.start_with? 'hh_'
+          @handlebars.register_helper(method_name.to_s.gsub(/hh_/, '')) do |*args|
+            send(method_name, *args)
+          end
+        elsif method_name.to_s.start_with? 'as_hh_'
+          @handlebars.register_as_helper(method_name.to_s.gsub(/as_hh_/, '')) do |*args|
+            send(method_name, *args)
+          end
+        end
+      end
+    end
+
+    def compute_block_value(context, value, block)
+      value.is_a?(Handlebars::Tree::Block) ? value.fn(context) : value
+    end
+
+    def hh_to_string(context, value, block = nil)
+      value = compute_block_value(context, value, block)
+      "#{value.to_s}"
+    end
+
+    def hh_join(context, items, joiner, block, else_block = nil)
+      as_hh_join(context, items, joiner, :this, block, else_block)
+    end
+
+    def as_hh_join(context, items, joiner, name, block, else_block = nil)
+      joiner = joiner.to_s
+      joiner.gsub!(/\\t/, "\t")
+      joiner.gsub!(/\\n/, "\n")
+
+      if block.nil? || block.items.empty?
+        "#{items.join(joiner)}"
+      else
+        if items.empty? && else_block
+          return else_block.fn(context)
+        end
+
+        items.map do |item|
+          context.with_temporary_context(name => item) do
+            block.fn(context)
+          end
+        end.join(joiner)
+      end
+    end
+
+    def hh_join_gherkin_dataset(context, items, block, else_block = nil)
+      items.map! { |item| item.gsub(/\|/, "\\|").gsub("\n", "\\n") }
+
+      hh_join(context, items, ' | ', block, else_block)
+    end
+
+    def hh_with(context, var, name, block)
+      context.with_temporary_context(name => var) do
+        block.fn(context)
+      end
+    end
+
+    def hh_prepend(context, str, block)
+      block.fn(context).split("\n").map do |line|
+        indented = "#{str}#{line}"
+        indented = "" if indented.strip.empty?
+        indented
+      end.join("\n")
+    end
+
+    def hh_indent(context, block)
+      indentation = @context[:indentation] || '  '
+      indentation = "\t" if indentation == '\t'
+
+      hh_prepend(context, indentation, block)
+    end
+
+    def hh_clear_empty_lines(context, block)
+      block.fn(context).split("\n").map do |line|
+        line unless line.strip.empty?
+      end.compact.join("\n")
+    end
+
+    def hh_index(context, list, index, block)
+      current_this = context.get('this')
+      context.add_item(:this, list[index.to_i])
+      rendered = block.fn(context)
+      context.add_item(:this, current_this)
+
+      return rendered
+    end
+
+    def hh_first(context, list, block)
+      hh_index(context, list, 0, block)
+    end
+
+    def hh_last(context, list, block)
+      hh_index(context, list, list.size - 1, block)
+    end
+
+    # kept for backward compatibility of customized templates
+    def hh_remove_quotes (context, s, block = nil)
+      hh_remove_double_quotes(context, s, block)
+    end
+
+    def hh_remove_double_quotes (context, s, block = nil)
+      s = compute_block_value(context,s, block)
+      s ? s.gsub('"', '') : ""
+    end
+
+    def hh_remove_single_quotes (context, s, block = nil)
+      s = compute_block_value(context,s, block)
+      s ? s.gsub('\'', '') : ""
+    end
+
+    # kept for backward compatibility of customized templates
+    def hh_escape_quotes (context, s, block = nil)
+      hh_escape_double_quotes(context, s, block)
+    end
+
+    def hh_escape_double_quotes (context, s, block = nil)
+      s = compute_block_value(context, s, block)
+      s ? s.gsub('"', '\\"') : ""
+    end
+
+    def hh_escape_single_quotes (context, s, block = nil)
+      # weird \\\\, see http://stackoverflow.com/questions/7074337/why-does-stringgsub-double-content
+      s = compute_block_value(context, s, block)
+      s ? s.gsub('\'', "\\\\'") : ""
+    end
+
+    def hh_unescape_single_quotes (context, s, block = nil)
+      # weird \\\\, see http://stackoverflow.com/questions/7074337/why-does-stringgsub-double-content
+      s = compute_block_value(context, s, block)
+      s ? s.gsub("\\'", "'") : ""
+    end
+
+    def hh_escape_backslashes_and_double_quotes (context, s, block = nil)
+      s = compute_block_value(context, s, block)
+
+      if s
+        s.gsub('\\') { |c| c*2 }.
+          gsub('"', '\\"')
+      else
+        ""
+      end
+    end
+
+    def hh_escape_new_line(context, s, block = nil)
+      s = compute_block_value(context, s, block)
+      s ? s.gsub("\n", '\\n') : ""
+    end
+
+    def hh_remove_surrounding_quotes(context, s, block = nil)
+      s = compute_block_value(context, s, block)
+
+      if s.nil?
+        ""
+      elsif surrounded_with?(s, "'") || surrounded_with?(s, '"')
+        s.slice(1...-1)
+      else
+        s
+      end
+    end
+
+    def surrounded_with?(main, sub)
+      main.start_with?(sub) && main.end_with?(sub)
+    end
+
+    def hh_comment (context, commenter, block)
+      block.fn(context).split("\n").map do |line|
+        stripped_line = line.strip
+        stripped_line.empty? ? commenter : "#{commenter} #{line}"
+      end.join("\n")
+    end
+
+    def hh_description_with_annotations (context, commenter, block)
+      value = compute_block_value(context, commenter, block)
+      value = value.split("\n").map do |line|
+        line.strip.downcase.start_with?('given', 'when', 'then', 'and', 'but', '*', '#') ? "\"#{line}\"" : line
+      end.join("\n")
+      value
+    end
+
+    def hh_curly (context, block)
+      "{#{block.fn(context)}}"
+    end
+
+    def hh_open_curly (context, block, else_block = nil)
+      "{"
+    end
+
+    def hh_close_curly (context, block, else_block = nil)
+      "}"
+    end
+
+    def hh_tab (context, block, else_block = nil)
+      "\t"
+    end
+
+    def hh_relative_path(context, filename, path_prefix = nil, block)
+      levels_count = context.get('context.relative_path').count('/')
+      name = ""
+      name << path_prefix if path_prefix
+      if levels_count == 0
+        name << filename
+      else
+        name << "../" * levels_count
+        name << filename.to_s.gsub(/\A\.\//, '')
+      end
+      name
+    end
+
+    def hh_strip_regexp_delimiters(context, regexp, block = nil)
+      regexp = compute_block_value(context, regexp, block)
+      return regexp.gsub(/(^\^)|(\$$)/, '')
+    end
+
+    def hh_remove_last_character(context, character = '', block)
+      txt = block.fn(context)
+      return txt[-1] == character ? txt[0..-2] : txt
+    end
+
+    def hh_trim_surrounding_characters(context, character, block)
+      return block.fn(context).gsub(/(\A(#{character})*)|((#{character})*\z)/, '')
+    end
+
+    def hh_replace(context, str, replacement, block)
+      return block.fn(context).gsub(str, replacement)
+    end
+
+    def hh_debug(context, block, _)
+      require 'pry'
+      binding.pry
+      ""
+    end
+
+    def hh_case(context, expression, block_whens, block_else = nil)
+      result = nil
+
+      context.with_temporary_context(__case_expression: expression, __case_result: nil) do
+        block_whens.fn(context)
+        context.get("__case_result") || (block_else && block_else.fn(context).chomp) || ''
+      end
+    end
+
+    def hh_when(context, value, block)
+      return if context.get("__case_result")
+
+      expression = context.get("__case_expression")
+      if expression == value
+        context.add_item(:__case_result, block.fn(context))
+      end
+    end
+
+    def hh_when_includes(context, value, block)
+      return if context.get("__case_result")
+
+      expression = context.get("__case_expression")
+      if expression.respond_to?(:include?) && expression.include?(value)
+        context.add_item(:__case_result, block.fn(context))
+      end
+    end
+
+    def hh_if_includes(context, expression, element, block_true, block_false = nil)
+      if expression.respond_to?(:include?) && expression.include?(element)
+        block_true.fn(context)
+      elsif block_false
+        block_false.fn(context)
+      else
+        ''
+      end
+    end
+  end
+end

data/lib/hiptest-publisher/i18n.rb

@@ -0,0 +1,5 @@
+require 'i18n'
+
+require 'hiptest-publisher/utils'
+
+I18n.load_path << Dir["#{hiptest_publisher_path}/config/locales/*.yml"]

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

@@ -0,0 +1,32 @@
+module Hiptest
+  class ActionwordIndexer
+    def initialize(project)
+      @project = project
+      @indexed = {}
+      index_actionwords
+    end
+
+    def index_actionwords
+      @project.each_sub_nodes(Hiptest::Nodes::Actionword) 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