hiptest-publisher 0.2.0

data/lib/hiptest-publisher/renderer.rb

@@ -0,0 +1,87 @@
+require 'handlebars'
+require 'hiptest-publisher/nodes_walker'
+require 'hiptest-publisher/handlebars_helper'
+require 'hiptest-publisher/render_context_maker'
+
+module Hiptest
+  class Renderer < Hiptest::Nodes::Walker
+    attr_reader :rendered
+    include RenderContextMaker
+
+    def self.render(node, language, context)
+      context[:language] = language
+
+      renderer = Hiptest::Renderer.new(context)
+      renderer.walk_node(node)
+      renderer.rendered[node]
+    end
+
+    def initialize(context)
+      super(:children_first)
+      @rendered = {}
+      @context = context
+      @handlebars = Handlebars::Context.new
+      register_partials()
+
+      Hiptest::HandlebarsHelper.register_helpers(@handlebars, @context)
+    end
+
+    def call_node_walker(node)
+      if node.is_a? Hiptest::Nodes::Node
+        @rendered_children = {}
+        node.children.each {|name, child| @rendered_children[name] = @rendered[child]}
+        @rendered[node] = render_node(node, super(node))
+      elsif node.is_a? Array
+        @rendered[node] = node.map {|item| @rendered[item]}
+      else
+        @rendered[node] = node
+      end
+    end
+
+    def searched_folders()
+      folders = []
+      if @context.has_key?(:framework)
+        folders << "#{@context[:language]}/#{@context[:framework]}"
+      end
+      folders << [@context[:language], 'common']
+      folders.flatten.map {|path| "#{hiptest_publisher_path}/lib/templates/#{path}"}
+    end
+
+    def register_partials()
+      searched_folders.reverse.each do |path|
+        next unless File.directory?(path)
+        Dir.entries(path).select do |file_name|
+          file_path = File.join(path, file_name)
+          next unless File.file?(file_path) && file_name.start_with?('_')
+          @handlebars.register_partial(file_name[1..-5], File.read(file_path))
+        end
+      end
+    end
+
+    def render_node(node, render_context)
+      render_context = {} if render_context.nil?
+      render_context[:node] = node
+      render_context[:rendered_children] = @rendered_children
+      render_context[:context] = @context
+
+      template = get_template_path(node)
+      @handlebars.compile(File.read(template)).send(:call, render_context)
+    end
+
+    def get_template_by_name(name, extension)
+      searched_folders.map do |path|
+        template_path = File.join(path, "#{name}.#{extension}")
+        template_path if File.file?(template_path)
+      end.compact.first
+    end
+
+    def get_template_path(node, extension = 'hbs')
+      normalized_name = node.class.name.split('::').last.downcase
+      unless @context[:forced_templates][normalized_name].nil?
+        normalized_name = @context[:forced_templates][normalized_name]
+      end
+
+      get_template_by_name(normalized_name, extension)
+    end
+  end
+end

data/lib/hiptest-publisher/string.rb

@@ -0,0 +1,52 @@
+require 'i18n'
+
+require_relative 'utils'
+
+class String
+  def literate
+    I18n.enforce_available_locales = false
+    I18n.transliterate(self)
+  end
+
+  def normalize
+    literated = self.literate
+    literated.strip.gsub(/\s+/, '_').gsub(/\W/, '')
+  end
+
+  def normalize_lower
+    literated = self.literate
+    literated.strip.gsub(/\s+/, '_').gsub(/\W/, '').downcase
+  end
+
+  def underscore
+    # based on:
+    # http://stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
+    normalized = self.normalize
+    normalized.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+
+  def camelize
+    normalized = self.normalize
+    normalized.split('_').map {|w| w.empty? ? "" : "#{w[0].upcase}#{w[1..-1]}"}.join
+  end
+
+  def camelize_lower
+    normalized = self.normalize
+    normalized.split('_').enum_for(:each_with_index).map do |w, i|
+      if w.empty?
+        ""
+      elsif i == 0
+        "#{w[0].downcase}#{w[1..-1]}"
+      else
+        "#{w[0].upcase}#{w[1..-1]}"
+      end
+    end.join
+  end
+
+  def clear_extension
+    self.split('.')[0]
+  end
+end

data/lib/hiptest-publisher/utils.rb

@@ -0,0 +1,47 @@
+require 'open-uri'
+require 'openssl'
+require 'colorize'
+
+def hiptest_publisher_path
+  Gem.loaded_specs['hiptest-publisher'].full_gem_path
+rescue
+  '.'
+end
+
+def make_filter(options)
+  ids = options.filter_ids.split(',').map {|id| "filter[]=id:#{id}"}
+  tags = options.filter_tags.split(',').map {|tag| "filter[]=tag:#{tag}"}
+
+  filter = (ids + tags).join("&")
+  filter.empty? ? '' : "&#{filter}"
+end
+
+def fetch_project_export(options)
+  url = "#{options.site}/publication/#{options.token}/#{options.leafless_export ? 'leafless_tests' : 'project'}?future=1#{make_filter(options)}"
+
+  puts "URL: #{url}".white if options.verbose
+  open(url, :ssl_verify_mode => OpenSSL::SSL::VERIFY_NONE)
+end
+
+def trace_exception(exception)
+  line = "-" * 80
+  puts line.yellow
+  puts "#{exception.class.name}: #{exception.message}".red
+  puts "#{exception.backtrace.map {|l| "  #{l}\n"}.join}".yellow
+  puts line.yellow
+end
+
+def show_status_message(message, status=nil)
+  status_icon = " "
+  line_end = status.nil? ? "" : "\n"
+  output = STDOUT
+
+  if status == :success
+    status_icon = "v".green
+  elsif status == :failure
+    status_icon = "x".red
+    output = STDERR
+  end
+
+  output.print "[#{status_icon}] #{message}\r#{line_end}"
+end

data/lib/hiptest-publisher/xml_parser.rb

@@ -0,0 +1,294 @@
+require 'nokogiri'
+require 'colorize'
+
+require_relative 'nodes'
+require_relative 'utils'
+
+module Hiptest
+  class XMLParser
+    attr_reader :project
+
+    def initialize(source, options = nil)
+      @source = source
+      @xml = Nokogiri::XML(source)
+      @options = options
+    end
+
+    def build_nullliteral(value = nil)
+      Hiptest::Nodes::NullLiteral.new
+    end
+
+    def build_stringliteral(value)
+      if value.is_a? String
+        Hiptest::Nodes::StringLiteral.new(value)
+      else
+        Hiptest::Nodes::StringLiteral.new(value.content)
+      end
+    end
+
+    def build_numericliteral(value)
+      if value.is_a? Numeric
+        Hiptest::Nodes::NumericLiteral.new(value)
+      else
+        Hiptest::Nodes::NumericLiteral.new(value.content)
+      end
+    end
+
+    def build_booleanliteral(value)
+      if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        Hiptest::Nodes::BooleanLiteral.new(value)
+      else
+        Hiptest::Nodes::BooleanLiteral.new(value.content)
+      end
+    end
+
+    def build_var(variable)
+      Hiptest::Nodes::Variable.new(variable.content)
+    end
+
+    def build_field(field)
+      Hiptest::Nodes::Field.new(
+        build_node(css_first(field, '> base > *')),
+        css_first_content(field, '> name'))
+    end
+
+    def build_index(index)
+      Hiptest::Nodes::Index.new(
+        build_node(css_first(index, '> base > *')),
+        build_node(css_first(index, '> expression > *')))
+    end
+
+    def build_binary_expression(operation)
+      Hiptest::Nodes::BinaryExpression.new(
+        build_node(css_first(operation, '> left > *')),
+        css_first_content(operation, '> operator'),
+        build_node(css_first(operation, '> right > *')))
+    end
+
+    def build_unary_expression(operation)
+      Hiptest::Nodes::UnaryExpression.new(
+        css_first_content(operation, '> operator'),
+        build_node(css_first(operation, '> expression > *')))
+    end
+
+    def build_operation(operation)
+      if css_first(operation, '> left').nil?
+        build_unary_expression(operation)
+      else
+        build_binary_expression(operation)
+      end
+    end
+
+    def build_parenthesis(parenthesis)
+      Hiptest::Nodes::Parenthesis.new(
+        build_node(css_first(parenthesis)))
+    end
+
+    def build_list(list)
+      Hiptest::Nodes::List.new(build_node_list(list.css('> item > *')))
+    end
+
+    def build_dict(dict)
+      items = dict.element_children.map do |item|
+        Hiptest::Nodes::Property.new(
+          item.name,
+          build_node(css_first(item)))
+      end
+      Hiptest::Nodes::Dict.new(items)
+    end
+
+    def build_template(template)
+      Hiptest::Nodes::Template.new(build_node_list(template.css('> *')))
+    end
+
+    def build_assign(assign)
+      Hiptest::Nodes::Assign.new(
+        build_node(css_first(assign, 'to > *')),
+        build_node(css_first(assign, 'value > *')))
+    end
+
+    def build_call(call)
+      Hiptest::Nodes::Call.new(
+        css_first_content(call, '> actionword'),
+        build_arguments(call))
+    end
+
+    def build_arguments(arguments)
+      build_node_list(arguments.css('> arguments > argument'))
+    end
+
+    def build_argument(argument)
+      value = css_first(argument, '> value')
+      Hiptest::Nodes::Argument.new(
+        css_first_content(argument, 'name'),
+        value ? build_node(value) : nil)
+    end
+
+    def build_if(if_then)
+      Hiptest::Nodes::IfThen.new(
+        build_node(css_first(if_then, '> condition > *')),
+        build_node_list(if_then.css('> then > *')),
+        build_node_list(if_then.css('> else > *')))
+    end
+
+    def build_step(step)
+      first_prop = css_first(step)
+      Hiptest::Nodes::Step.new(
+        first_prop.name,
+        build_node(css_first(first_prop)))
+    end
+
+    def build_while(while_loop)
+      Hiptest::Nodes::While.new(
+        build_node(css_first(while_loop, '> condition > *')),
+        build_node_list(while_loop.css('> body > *')))
+    end
+
+    def build_tag(tag)
+      Hiptest::Nodes::Tag.new(
+        css_first_content(tag, '> key'),
+        css_first_content(tag, '> value'))
+    end
+
+    def build_parameter(parameter)
+      default_value = css_first(parameter, '> default_value')
+
+      Hiptest::Nodes::Parameter.new(
+        css_first_content(parameter, 'name'),
+        default_value ? build_node(default_value) : nil)
+    end
+
+    def build_default_value(node)
+      build_node(css_first(node))
+    end
+
+    def build_value(node)
+      build_node(css_first(node))
+    end
+
+    def build_tags(item)
+      build_node_list(item.css('> tags tag'))
+    end
+
+    def build_parameters(item)
+      build_node_list(item.css('> parameters > parameter'))
+    end
+
+    def build_steps(item)
+      build_node_list(item.css('> steps > *'))
+    end
+
+    def build_actionword(actionword)
+      Hiptest::Nodes::Actionword.new(
+        css_first_content(actionword, 'name'),
+        build_tags(actionword),
+        build_parameters(actionword),
+        build_steps(actionword))
+    end
+
+    def build_scenario(scenario)
+      Hiptest::Nodes::Scenario.new(
+        css_first_content(scenario, 'name'),
+        css_first_content(scenario, 'description'),
+        build_tags(scenario),
+        build_parameters(scenario),
+        build_steps(scenario),
+        css_first_content(scenario, 'folderUid'),
+        build_node(css_first(scenario, 'datatable'), Hiptest::Nodes::Datatable))
+    end
+
+    def build_datatable(datatable)
+      Hiptest::Nodes::Datatable.new(build_node_list(datatable.css('> dataset')))
+    end
+
+    def build_dataset(dataset)
+      Hiptest::Nodes::Dataset.new(
+        css_first_content(dataset, '> name'),
+        build_node_list(dataset.css('> arguments argument')))
+    end
+
+    def build_actionwords(actionwords)
+      build_node_list(actionwords.css('> actionword'), Hiptest::Nodes::Actionwords)
+    end
+
+    def build_scenarios(scenarios)
+      build_node_list(scenarios.css('> scenario'), Hiptest::Nodes::Scenarios)
+    end
+
+    def build_tests(tests)
+      build_node_list(tests.css('> test'), Hiptest::Nodes::Tests)
+    end
+
+    def build_test(test)
+      Hiptest::Nodes::Test.new(
+        css_first_content(test, 'name'),
+        css_first_content(test, 'description'),
+        build_tags(test),
+        build_steps(test)
+      )
+    end
+
+    def build_folder(folder)
+      Hiptest::Nodes::Folder.new(
+        css_first_content(folder, 'uid'),
+        css_first_content(folder, 'parentUid'),
+        css_first_content(folder, 'name'))
+    end
+
+    def build_testPlan(test_plan)
+      tp = Hiptest::Nodes::TestPlan.new(
+        build_node_list(test_plan.css('> folder')))
+
+      tp.organize_folders
+      return tp
+    end
+
+    def build_project
+      project = css_first(@xml, 'project')
+
+      @project = Hiptest::Nodes::Project.new(
+        css_first_content(project, '> name'),
+        css_first_content(project, '> description'),
+        build_node(css_first(project, '> testPlan'), Hiptest::Nodes::TestPlan),
+        build_node(css_first(project, '> scenarios'), Hiptest::Nodes::Scenarios),
+        build_node(css_first(project, '> actionwords'), Hiptest::Nodes::Actionwords),
+        build_node(css_first(project, '> tests'), Hiptest::Nodes::Tests))
+
+      @project.assign_scenarios_to_folders
+      return @project
+    end
+
+    private
+
+    def build_node(node, default_node=nil)
+      if node.nil? && default_node
+        return default_node.new
+      end
+      self.send("build_#{node.name}", node)
+    rescue Exception => exception
+      if @options && @options.verbose
+        puts "Unable to build: \n#{node}".blue
+        trace_exception(exception)
+      end
+    end
+
+    def build_node_list(l, container_class=nil)
+      items = l.map {|item| build_node(item)}
+
+      unless container_class.nil?
+        container_class.new(items)
+      else
+        items
+      end
+    end
+
+    def css_first(node, selector = '> *')
+      node.css(selector).first
+    end
+
+    def css_first_content(node, selector = '> *')
+      sub_node = css_first(node, selector)
+      sub_node.nil? ? nil : sub_node.content
+    end
+  end
+end