kronk 1.4.0 → 1.5.0

data/lib/kronk/data_renderer.rb

@@ -0,0 +1,146 @@
+class Kronk
+
+  ##
+  # Creates ordered data strings for rendering to the output.
+
+  module DataRenderer
+
+    ##
+    # Returns a ruby data string that is diff-able, meaning sorted by
+    # Hash keys when available.
+
+    def self.ruby data, struct_only=false
+      ordered_data_string data, struct_only do |type, obj|
+        case type
+        when :key_assign then " =>"
+        when :key        then obj.inspect
+        when :value      then obj.inspect
+        when :struct
+          (obj == true || obj == false) ? "Boolean" : obj.class
+        end
+      end
+    end
+
+    ##
+    # Returns a json data string that is diff-able, meaning sorted by
+    # Hash keys when available.
+
+    def self.json data, struct_only=false
+      ordered_data_string data, struct_only do |type, obj|
+        case type
+        when :key_assign then ":"
+        when :key
+          (Symbol === obj ? obj.inspect : obj.to_s).to_json
+        when :value
+          (Symbol === obj ? obj.inspect : obj).to_json
+        when :struct
+          ((obj == true || obj == false) ? "Boolean" : obj.class).to_json
+        end
+      end
+    end
+
+
+    def self.ordered_data_string data, struct_only=false, indent=nil, &block
+      i_width  = Kronk.config[:indentation] || 1
+      indent ||= 0
+      indent += i_width
+
+      case data
+
+      when Hash
+        return "{}" if data.empty?
+
+        output = "{\n"
+
+        sorted_keys = sort_any data.keys
+
+        data_values =
+          sorted_keys.map do |key|
+            value   = data[key]
+            pad     = " " * indent
+            subdata = ordered_data_string value, struct_only, indent, &block
+            "#{pad}#{ yield(:key, key) }#{ yield(:key_assign) } #{subdata}"
+          end
+
+        output << data_values.join(",\n") << "\n"
+        output << "#{" " * (indent - i_width)}}"
+
+      when Array
+        return "[]" if data.empty?
+
+        output = "[\n"
+
+        data_values =
+          data.map do |value|
+            pad = " " * indent
+            "#{pad}#{ordered_data_string value, struct_only, indent, &block}"
+          end
+
+        output << data_values.join(",\n") << "\n"
+        output << "#{" " * (indent - i_width)}]"
+
+      else
+        struct_only ? yield(:struct, data) : yield(:value, data)
+      end
+    end
+
+
+
+    ##
+    # Sorts an array of any combination of string, integer, or symbols.
+
+    def self.sort_any arr
+      i = 1
+      until i >= arr.length
+        j        = i-1
+        val      = arr[i]
+        prev_val = arr[j]
+
+        loop do
+          if smaller?(val, arr[j])
+            arr[j+1] = arr[j]
+            j = j - 1
+            break if j < 0
+
+          else
+            break
+          end
+        end
+
+        arr[j+1] = val
+
+        i = i.next
+      end
+
+      arr
+    end
+
+
+    ##
+    # Compares Numerics, Strings, and Symbols and returns true if the left
+    # side is 'smaller' than the right side.
+
+    def self.smaller? left, right
+      case left
+      when Numeric
+        case right
+        when Numeric then right > left
+        else              true
+        end
+
+      when Symbol
+        case right
+        when Numeric then false
+        when Symbol  then right.to_s > left.to_s
+        else              true
+        end
+
+      when String
+        case right
+        when String  then right > left
+        else              false
+        end
+      end
+    end
+  end
+end

data/lib/kronk/diff.rb

@@ -19,99 +19,11 @@ class Kronk
     # Returns a data string that is diff-able, meaning sorted by
     # Hash keys when available.
 
-    def self.ordered_data_string data, struct_only=false, indent=0
-      case data
-
-      when Hash
-        output = "{\n"
-
-        sorted_keys = sort_any data.keys
-
-        data_values =
-          sorted_keys.map do |key|
-            value   = data[key]
-            pad     = " " * indent
-            subdata = ordered_data_string value, struct_only, indent + 1
-            "#{pad}#{key.inspect} => #{subdata}"
-          end
-
-        output << data_values.join(",\n") << "\n" unless data_values.empty?
-        output << "#{" " * indent}}"
-
-      when Array
-        output = "[\n"
-
-        data_values =
-          data.map do |value|
-            pad = " " * indent
-            "#{pad}#{ordered_data_string value, struct_only, indent + 1}"
-          end
-
-        output << data_values.join(",\n") << "\n" unless data_values.empty?
-        output << "#{" " * indent}]"
-
+    def self.ordered_data_string data, struct_only=false
+      case Kronk.config[:render_lang].to_s
+      when 'ruby' then DataRenderer.ruby(data, struct_only)
       else
-        return data.inspect unless struct_only
-        return "Boolean" if data == true || data == false
-        data.class
-      end
-    end
-
-
-    ##
-    # Sorts an array of any combination of string, integer, or symbols.
-
-    def self.sort_any arr
-      i = 1
-      until i >= arr.length
-        j        = i-1
-        val      = arr[i]
-        prev_val = arr[j]
-
-        loop do
-          if smaller?(val, arr[j])
-            arr[j+1] = arr[j]
-            j = j - 1
-            break if j < 0
-
-          else
-            break
-          end
-        end
-
-        arr[j+1] = val
-
-        i = i.next
-      end
-
-      arr
-    end
-
-
-    ##
-    # Compares Numerics, Strings, and Symbols and returns true if the left
-    # side is 'smaller' than the right side.
-
-    def self.smaller? left, right
-      case left
-      when Numeric
-        case right
-        when Numeric then right > left
-        else              true
-        end
-
-      when Symbol
-        case right
-        when Numeric then false
-        when Symbol  then right.to_s > left.to_s
-        else              true
-        end
-
-      when String
-        case right
-        when String  then right > left
-        else              false
-        end
+        DataRenderer.json(data, struct_only)
       end
     end
 

data/lib/kronk/path/transaction.rb

@@ -94,6 +94,7 @@ class Kronk::Path::Transaction
 
 
   def transaction_select data, *data_paths # :nodoc:
+    data_paths = data_paths.compact
     return data if data_paths.empty?
 
     new_data = Hash.new
@@ -129,6 +130,7 @@ class Kronk::Path::Transaction
 
 
   def transaction_delete data, *data_paths # :nodoc:
+    data_paths = data_paths.compact
     return data if data_paths.empty?
 
     new_data = data.dup

data/lib/kronk/player.rb

@@ -0,0 +1,233 @@
+class Kronk
+
+  ##
+  # The Player class is used for running multiple requests and comparisons and
+  # providing useful output through Player::Output classes.
+  # Kronk includes a Suite (test-like) output, a Stream (chunked) output,
+  # and a Benchmark output.
+
+  class Player
+
+    attr_accessor :number, :concurrency, :queue, :count, :input,
+                  :output, :mutex, :threads, :reader_thread
+
+    ##
+    # Create a new Player for batch diff or response validation.
+    # Supported options are:
+    # :concurrency:: Fixnum - The maximum number of concurrent requests to make
+    # :number:: Fixnum - The number of requests to make
+    # :io:: IO - The IO instance to read from
+    # :output:: Class - The output class to use (see Player::Output)
+    # :parser:: Class - The IO parser to use.
+
+    def initialize opts={}
+      @number      = opts[:number]
+      @concurrency = opts[:concurrency]
+      @concurrency = 1 if !@concurrency || @concurrency <= 0
+      self.output_from opts[:output] || Suite
+
+      @count     = 0
+      @queue     = []
+      @threads   = []
+      @input     = InputReader.new opts[:io], opts[:parser]
+      @last_req  = nil
+
+      @mutex = Mutex.new
+    end
+
+
+    ##
+    # The kind of output to use. Typically Player::Suite or Player::Stream.
+    # Takes an output class or a string that represents a class constant.
+
+    def output_from new_output
+      return @output = new_output.new(self) if Class === new_output
+
+      klass =
+        case new_output.to_s
+        when /^(Player::)?benchmark$/i then Benchmark
+        when /^(Player::)?stream$/i    then Stream
+        when /^(Player::)?suite$/i     then Suite
+        else
+          Kronk.find_const new_output
+        end
+
+      @output = klass.new self if klass
+    end
+
+
+    ##
+    # Adds kronk request hash options to queue.
+    # See Kronk#compare for supported options.
+
+    def queue_req kronk_opts
+      @queue << kronk_opts
+    end
+
+
+    ##
+    # Populate the queue by reading from the given IO instance and
+    # parsing it into kronk options.
+    #
+    # Default parser is RequestParser. See InputReader for parser requirements.
+
+    def from_io io, parser=nil
+      @input.io     = io
+      @input.parser = parser if parser
+      @input
+    end
+
+
+    ##
+    # Process the queue to compare two uris.
+    # If options are given, they are merged into every request.
+
+    def compare uri1, uri2, opts={}
+      return Cmd.compare uri1, uri2, @queue.shift.merge(opts) if single_request?
+
+      process_queue do |kronk_opts|
+        process_compare uri1, uri2, kronk_opts.merge(opts)
+      end
+    end
+
+
+    ##
+    # Process the queue to request uris.
+    # If options are given, they are merged into every request.
+
+    def request uri, opts={}
+      return Cmd.request(uri, @queue.shift.merge(opts)) if single_request?
+
+      process_queue do |kronk_opts|
+        process_request uri, kronk_opts.merge(opts)
+      end
+    end
+
+
+    ##
+    # Check if we're only processing a single case.
+    # If so, yield a single item and return immediately.
+
+    def single_request?
+      @queue << next_request if @queue.empty? && (!@number || @number <= 1)
+      @queue.length == 1 && @input.eof?
+    end
+
+
+    ##
+    # Start processing the queue and reading from IO if available.
+    # Calls Output#start method and returns the value of Output#completed
+    # once processing is finished.
+    #
+    # Yields queue item until queue and io (if available) are empty and the
+    # totaly number of requests to run is met (if number is set).
+
+    def process_queue
+      @reader_thread = try_fill_queue
+
+      trap 'INT' do
+        @threads.each{|t| t.kill}
+        @threads.clear
+        @reader_thread.kill
+        output_results
+        exit 2
+      end
+
+      @output.start
+      @count = 0
+
+      until finished?
+        @threads.delete_if{|t| !t.alive? }
+        next if @threads.length >= @concurrency || @queue.empty?
+
+        @threads << Thread.new(@queue.shift) do |kronk_opts|
+          yield kronk_opts if block_given?
+        end
+
+        @count += 1
+      end
+
+      @threads.each{|t| t.join}
+      @threads.clear
+
+      @reader_thread.kill
+
+      output_results
+    end
+
+
+    ##
+    # Attempt to fill the queue by reading from the IO instance.
+    # Starts a new thread and returns the thread instance.
+
+    def try_fill_queue
+      Thread.new do
+        loop do
+          break if !@number && @input.eof?
+          next  if @queue.length >= @concurrency * 2
+
+          max_new = @concurrency * 2 - @queue.length
+
+          max_new.times do
+            @queue << next_request
+            break if !@number && @input.eof?
+          end
+        end
+      end
+    end
+
+
+    ##
+    # Gets the next request to perform and always returns a Hash.
+    # Tries from input first, then from the last item in the queue.
+    # If both fail, returns an empty Hash.
+
+    def next_request
+      @last_req = @input.get_next || @queue.last || @last_req || Hash.new
+    end
+
+
+    ##
+    # Returns true if processing queue should be stopped, otherwise false.
+
+    def finished?
+      (@number && @count >= @number) || @queue.empty? &&
+      @input.eof? && @count > 0 && !@reader_thread.alive?
+    end
+
+
+    ##
+    # Process and output the results.
+    # Calls Output#completed method.
+
+    def output_results
+      @output.completed
+    end
+
+
+    ##
+    # Run a single compare and call the Output#result or Output#error method.
+
+    def process_compare uri1, uri2, opts={}
+      kronk = Kronk.new opts
+      kronk.compare uri1, uri2
+      @output.result kronk, @mutex
+
+    rescue Kronk::Exception, Response::MissingParser, Errno::ECONNRESET => e
+      @output.error e, kronk, @mutex
+    end
+
+
+    ##
+    # Run a single request and call the Output#result or Output#error method.
+
+    def process_request uri, opts={}
+      kronk = Kronk.new opts
+      kronk.retrieve uri
+      @output.result kronk, @mutex
+
+    rescue Kronk::Exception, Response::MissingParser, Errno::ECONNRESET => e
+      @output.error e, kronk, @mutex
+    end
+  end
+end