hiptest-publisher 0.6.3 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da8ec8699aae12338c795fa1fb399a78ecd748ff
-  data.tar.gz: 7d73cb2f8c7d16f650af43472c07f4f5308a4d78
+  metadata.gz: be7fd459ab07a79f34477a18657baa1367f26e81
+  data.tar.gz: 5548f034c80c2ecddc9e7b1ffdc3c17a64606e6b
 SHA512:
-  metadata.gz: 4fbebc2dddcc47b090219432ff98adebe85182947db14086450153b86779af7db619d60040046f230e4751c693c992e2a8f2fa5f3403f19e361523d878f2a661
-  data.tar.gz: 409ffd0c3c4e37196e6d3e74d2f40a966442ae60f6ae6faacf0e4820eebf90a0adbf113ef98ea7f1b43755830abbdc994bbfa40e3d2821bc9c611257992dcecb
+  metadata.gz: e715cabfcb276bb95d66ef79da2ec30f730775f193cbf2add0a311a309399fd3b44bf4405e44116a9c4e3f81aac1caee8651af7d5f4d45fdd89cf2d1a1d0a6c3
+  data.tar.gz: 54f46b5ad213a4a94a0ec1f90059ced3ffefb64564849d7a5ad7b2cd776d7b7a15dc048712f3d61808dffadecb423a692eedd75aeb2d56408ce8774b5a332491

data/lib/hiptest-publisher/nodes.rb

@@ -18,8 +18,8 @@ module Hiptest
         return Hiptest::Renderer.render(self, rendering_context)
       end
 
-      def each_sub_nodes(*types)
-        return to_enum(:each_sub_nodes, *types) unless block_given?
+      def each_sub_nodes(*types, deep: false)
+        return to_enum(:each_sub_nodes, *types, deep: deep) unless block_given?
         path = [self]
         parsed_nodes_id = Set.new
 
@@ -28,11 +28,12 @@ module Hiptest
 
           if current_node.is_a?(Node)
             next if parsed_nodes_id.include? current_node.object_id
+            parsed_nodes_id << current_node.object_id
 
             if types.empty? || types.any? {|type| current_node.is_a?(type)}
               yield current_node
+              next unless deep
             end
-            parsed_nodes_id << current_node.object_id
             current_node.children.each_value {|item| path << item}
           elsif current_node.is_a?(Array)
             current_node.each {|item| path << item}

data/lib/hiptest-publisher/nodes_walker.rb

@@ -1,6 +1,14 @@
 module Hiptest
   module Nodes
     class Walker
+
+      def walk_node(node)
+        walk_children(node)
+
+        node.each {|item| walk_node(item)} if node.is_a? Array
+        call_node_walker(node)
+      end
+
       private
 
       def walk_children(node)
@@ -16,30 +24,10 @@ module Hiptest
         end
       end
 
-      def walk_method_name(node)
-        walk_method_names[node.class] ||= "walk_#{node.kind}".to_sym
-      end
+      WALK_METHOD_NAMES = {}
 
-      def walk_method_names
-        @walk_method_names ||= {}
-      end
-    end
-
-    class ParentFirstWalker < Walker
-      def walk_node(node)
-        call_node_walker(node)
-        node.each {|item| walk_node(item)} if node.is_a? Array
-
-        walk_children(node)
-      end
-    end
-
-    class ChildrenFirstWalker < Walker
-      def walk_node(node)
-        walk_children(node)
-
-        node.each {|item| walk_node(item)} if node.is_a? Array
-        call_node_walker(node)
+      def walk_method_name(node)
+        WALK_METHOD_NAMES[node.class] ||= "walk_#{node.kind}".to_sym
       end
     end
   end

data/lib/hiptest-publisher/parameter_type_adder.rb

@@ -2,135 +2,103 @@ require 'hiptest-publisher/nodes_walker'
 
 module Hiptest
   module Nodes
-    class ParameterTypeAdder < ParentFirstWalker
+    class ParameterTypeAdder
       attr_reader :call_types
 
       def self.add(project)
-        walker = Hiptest::Nodes::ParameterTypeAdder.new
-        walker.walk_node(project)
-
-        Hiptest::Nodes::TypeWriter.new(walker.call_types).walk_node(project)
+        Hiptest::Nodes::ParameterTypeAdder.new.process(project)
       end
 
-      def walk_project(project)
+      def initialize
         @call_types = CallTypes.new
       end
 
-      def walk_call(call)
-        @call_types.add_callable_item(call.children[:actionword])
-      end
-
-      def walk_argument(arg)
-        get_literal_values(arg).each {|value|
-          @call_types.add_argument(arg.children[:name], value[0], value[1])
-        }
+      def process(project)
+        gather_scenarios_argument_types(project)
+        gather_call_argument_types(project)
+        write_parameter_types(project)
       end
 
-      def walk_actionword(actionword)
-        @call_types.add_callable_item(actionword.children[:name])
-      end
-
-      def walk_scenario(scenario)
-        @call_types.add_callable_item(scenario.children[:name])
+      def gather_scenarios_argument_types(project)
+        project.children[:scenarios].children[:scenarios].each do |scenario|
+          @call_types.add_callable_item(scenario.children[:name])
+          add_arguments_from(scenario.children[:datatable])
+        end
       end
 
-      private
-
-      def get_literal_values(node)
-        values = []
-        node.each_sub_nodes(StringLiteral, NumericLiteral, BooleanLiteral) do |literal|
-          values << [literal.class, literal.children[:value]]
+      def gather_call_argument_types(project)
+        project.each_sub_nodes(Call) do |call|
+          @call_types.add_callable_item(call.children[:actionword])
+          add_arguments_from(call)
         end
-        values << [NullLiteral, nil] if values.empty?
-        values
       end
-    end
 
-    class TypeWriter < ParentFirstWalker
-      def initialize(call_types)
-        @call_types = call_types
-        @callable_item_name = nil
+      def write_parameter_types(project)
+        project.each_sub_nodes(Actionword, Scenario) do |callable_item|
+          callable_item.each_sub_nodes(Parameter) do |parameter|
+            parameter.children[:type] = @call_types.type_of(callable_item.children[:name], parameter.children[:name])
+          end
+        end
       end
 
-      def walk_actionword actionword
-        @callable_item_name = actionword.children[:name]
+      def add_arguments_from(node)
+        node.each_sub_nodes(Argument) do |argument|
+          @call_types.add_argument_type(argument.children[:name], get_type(argument))
+        end
       end
 
-      def walk_scenario(scenario)
-        @callable_item_name = scenario.children[:name]
-      end
+      private
 
-      def walk_parameter parameter
-        parameter.children[:type] = @call_types.type_of(@callable_item_name, parameter.children[:name])
+      def get_type(node)
+        value = node.children[:value]
+        case value
+          when StringLiteral, Template then :String
+          when NumericLiteral then value.children[:value].include?(".") ? :float : :int
+          when BooleanLiteral then :bool
+          else :null
+        end
       end
     end
 
     class CallTypes
       def initialize
         @callable_items = {}
-        @current = nil
-      end
-
-      def select_callable_item(name)
-        @current = @callable_items[name]
+        @current_callable_item = nil
       end
 
       def add_callable_item(name)
-        @callable_items[name] = {} unless @callable_items.has_key?(name)
-        select_callable_item(name)
+        @callable_items[name] ||= {}
+        @current_callable_item = @callable_items[name]
       end
 
-      def add_argument(name, type, value)
-        add_parameter(name)
-        @current[name][:values] << {type: type, value: value}
-      end
-
-      def add_default_value(name, type, value)
-        add_parameter(name)
-        @current[name][:default] = {type: type, value: value}
+      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)
-        return unless @callable_items.has_key?(item_name)
-        parameter =  @callable_items[item_name][parameter_name]
+        callable_item =  @callable_items[item_name]
+        return :String if callable_item.nil?
+        parameter = callable_item[parameter_name]
 
-        return :String if parameter.nil? || parameter[:values].empty?
-        return type_from_values(parameter[:values])
+        return :String if parameter.nil?
+        return type_from_types(parameter[:types])
       end
 
       private
 
-      def add_parameter(name)
-        return if @current.has_key?(name)
-        @current[name] = {default: nil, values: []}
-      end
-
-      def type_from_values(values)
-        types = values.map {|val| val[:type] unless val[:type] == Hiptest::Nodes::NullLiteral}.compact.uniq
-
+      def type_from_types(types)
+        types = types - [:null]
         if types.empty?
           :null
         elsif types.length == 1
-          if types.first == Hiptest::Nodes::StringLiteral
-            :String
-          elsif types.first == Hiptest::Nodes::BooleanLiteral
-            :bool
-          elsif types.first == Hiptest::Nodes::NumericLiteral
-            determine_numeric(values)
-          end
+          types.first
+        elsif types == Set[:float, :int]
+          :float
         else
           :String
         end
       end
-
-      def determine_numeric(values)
-        types = values.map do |val|
-          next unless val[:type] == Hiptest::Nodes::NumericLiteral
-          return :float if val[:value].include?(".")
-        end.compact.uniq
-
-        :int
-      end
     end
   end
 end

data/lib/hiptest-publisher/parent_adder.rb

@@ -1,16 +1,16 @@
+require 'hiptest-publisher/nodes_walker'
+
 module Hiptest
   module Nodes
-    class ParentAdder < ParentFirstWalker
+    class ParentAdder
       def self.add(project)
-        Hiptest::Nodes::ParentAdder.new.walk_node(project)
+        Hiptest::Nodes::ParentAdder.new.process(project)
       end
 
-      def walk_node(node)
-        super(node)
-        return unless node.is_a? Hiptest::Nodes::Node
-
+      def process(node)
         node.each_direct_children {|child|
           child.parent ||= node
+          process(child)
         }
       end
     end

data/lib/hiptest-publisher/render_context_maker.rb

@@ -93,7 +93,7 @@ module Hiptest
     private
 
     def has_step?(item)
-      item.each_sub_nodes do |node|
+      item.each_sub_nodes(deep: true) do |node|
         return true if node.is_a?(Hiptest::Nodes::Step)
       end
       false

data/lib/hiptest-publisher/renderer.rb

@@ -6,7 +6,7 @@ require 'hiptest-publisher/handlebars_helper'
 require 'hiptest-publisher/render_context_maker'
 
 module Hiptest
-  class Renderer < Hiptest::Nodes::ChildrenFirstWalker
+  class Renderer < Hiptest::Nodes::Walker
     attr_reader :rendered
     include RenderContextMaker
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiptest-publisher
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.6.4
 platform: ruby
 authors:
 - Hiptest R&D
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-21 00:00:00.000000000 Z
+date: 2015-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize