kronk 1.6.2 → 1.7.0

data/lib/kronk/path/transaction.rb

@@ -11,9 +11,12 @@
 #     {:name => "Tory",  :id => "12345"},
 #   ]
 #
-#   # Select all element names but delete the one at index 2
+#   # Select all element names, delete the one at index 2,
+#   # and move the element with the value "Tory" to the same path but
+#   # with the key renamed to "boo"
 #   Transaction.run data do |t|
 #     t.select "*/name"
+#     t.move "**=Tory" => "%%/boo"
 #     t.delete "2"
 #   end
 #
@@ -21,7 +24,7 @@
 #   #  {:name => "Jamie"},
 #   #  {:name => "Adam"},
 #   #  {:name => "Grant"},
-#   #  {:name => "Tory"},
+#   #  {"boo" => "Tory"},
 #   # ]
 
 class Kronk::Path::Transaction
@@ -36,6 +39,8 @@ class Kronk::Path::Transaction
   end
 
 
+  attr_accessor :actions
+
   ##
   # Create a new Transaction instance with a the data object to perform
   # operations on.
@@ -43,12 +48,7 @@ class Kronk::Path::Transaction
   def initialize data
     @data     = data
     @new_data = nil
-    @actions  = {
-      :select => [],
-      :delete => [],
-      :move   => {},
-      :map    => {}
-    }
+    @actions  = []
 
     @make_array = {}
   end
@@ -71,10 +71,14 @@ class Kronk::Path::Transaction
   # pass the :keep_indicies => true option.
 
   def results opts={}
-    new_data = transaction_select @data, *@actions[:select]
-    new_data = transaction_map    @data,  @actions[:map]
-    new_data = transaction_move   @data,  @actions[:move]
-    new_data = transaction_delete @data, *@actions[:delete]
+    new_data  = @data
+    prev_type = nil
+    prev_data = nil
+
+    @actions.each do |type, paths|
+      new_data = send("transaction_#{type}", new_data, *paths)
+    end
+
     remake_arrays new_data, opts[:keep_indicies]
   end
 
@@ -104,9 +108,22 @@ class Kronk::Path::Transaction
   end
 
 
+  def remap_make_arrays new_path, old_path # :nodoc:
+    @make_array[new_path] = true and return if @make_array[old_path]
+
+    @make_array.keys.each do |path|
+      if path[0...old_path.length] == old_path
+        path[0...old_path.length] = new_path
+      end
+    end
+  end
+
+
   def transaction_select data, *data_paths # :nodoc:
-    transaction data, data_paths, true do |new_curr_data, curr_data, key|
-      new_curr_data[key] = curr_data[key]
+    return data if data_paths.empty?
+
+    transaction data, data_paths, true do |sdata, cdata, key, path, tpath|
+      sdata[key] = cdata[key]
     end
   end
 
@@ -118,41 +135,31 @@ class Kronk::Path::Transaction
   end
 
 
-  def transaction_move data, match_target_hash # :nodoc:
-    return data if match_target_hash.empty?
+  def transaction_move data, *path_pairs # :nodoc:
+    return data if path_pairs.empty?
     path_val_hash = {}
 
-    match_target_hash.each do |data_path, path_map|
-      transaction data, [data_path] do |new_curr_data, cdata, key, path|
-        mapped_path = path.make_path path_map
-        path_val_hash[mapped_path] = new_curr_data.delete key
-        if @make_array[path]
-          @make_array.delete path
-          @make_array[mapped_path] = true
-        end
+    new_data =
+      transaction data, path_pairs do |sdata, cdata, key, path, tpath|
+        path_val_hash[tpath] = sdata.delete key
+        remap_make_arrays(tpath, path)
       end
-    end
 
-    force_assign_paths @new_data, path_val_hash
+    force_assign_paths new_data, path_val_hash
   end
 
 
-  def transaction_map data, match_target_hash # :nodoc:
-    return data if match_target_hash.empty?
+  def transaction_map data, *path_pairs # :nodoc:
+    return data if path_pairs.empty?
     path_val_hash = {}
 
-    match_target_hash.each do |data_path, path_map|
-      Kronk::Path.find data_path, data do |sdata, key, spath|
-        mapped_path = spath.make_path path_map
-        path_val_hash[mapped_path] = sdata[key]
-        if @make_array[spath]
-          @make_array.delete spath
-          @make_array[mapped_path] = true
-        end
-      end
+    transaction data, path_pairs do |sdata, cdata, key, path, tpath|
+      tpath ||= path
+      path_val_hash[tpath] = sdata.delete key
+      remap_make_arrays(tpath, path)
     end
 
-    force_assign_paths @new_data, path_val_hash
+    force_assign_paths data.class.new, path_val_hash
   end
 
 
@@ -160,13 +167,17 @@ class Kronk::Path::Transaction
     data_paths = data_paths.compact
     return @new_data || data if data_paths.empty?
 
-    @new_data ||= create_empty ? Hash.new : data.dup
+    @new_data = create_empty ? Hash.new : data.dup
 
     if Array === @new_data
       @new_data = ary_to_hash @new_data
     end
 
     data_paths.each do |data_path|
+      # If data_path is an array, the second element is the path where the value
+      # should be mapped to.
+      data_path, target_path = data_path
+
       Kronk::Path.find data_path, data do |obj, k, path|
         curr_data     = data
         new_curr_data = @new_data
@@ -175,7 +186,8 @@ class Kronk::Path::Transaction
           break unless new_curr_data
 
           if i == path.length - 1
-            yield new_curr_data, curr_data, key, path if block_given?
+            tpath = path.make_path target_path if target_path
+            yield new_curr_data, curr_data, key, path, tpath if block_given?
 
           else
             if create_empty
@@ -202,7 +214,7 @@ class Kronk::Path::Transaction
 
   def force_assign_paths data, path_val_hash # :nodoc:
     return data if path_val_hash.empty?
-    @new_data ||= (data.dup rescue [])
+    @new_data = (data.dup rescue [])
 
     path_val_hash.each do |path, value|
       curr_data     = data
@@ -216,7 +228,7 @@ class Kronk::Path::Transaction
           new_curr_data          = ary_to_hash new_curr_data
           prev_data[prev_key]    = new_curr_data if prev_data
           @new_data              = new_curr_data if i == 0
-          @make_array[prev_path] = true
+          @make_array[prev_path] = true          if i == 0
         end
 
         last      = i == path.length - 1
@@ -226,7 +238,7 @@ class Kronk::Path::Transaction
 
         # new_curr_data is a hash from here on
 
-        @make_array.delete prev_path unless Integer === key
+        @make_array.delete prev_path unless is_integer?(key)
 
         new_curr_data[key] = value and break if last
 
@@ -234,7 +246,7 @@ class Kronk::Path::Transaction
           new_curr_data[key] ||= curr_data[key]
 
         elsif !ary_or_hash?(new_curr_data[key])
-          new_curr_data[key] = Integer === next_key ? [] : {}
+          new_curr_data[key] = is_integer?(next_key) ? [] : {}
         end
 
         @make_array[curr_path] = true if Array === new_curr_data[key]
@@ -250,6 +262,11 @@ class Kronk::Path::Transaction
   end
 
 
+  def is_integer? item # :nodoc:
+    item.to_s.to_i.to_s == item.to_s
+  end
+
+
   def ary_or_hash? obj # :nodoc:
     Array === obj || Hash === obj
   end
@@ -272,7 +289,7 @@ class Kronk::Path::Transaction
 
   def clear
     @new_data = nil
-    @actions.each{|k,v| v.clear}
+    @actions.clear
     @make_array.clear
   end
 
@@ -281,7 +298,11 @@ class Kronk::Path::Transaction
   # Queues path selects for transaction.
 
   def select *paths
-    @actions[:select].concat paths
+    if @actions.last && @actions.last[0] == :select
+      @actions.last[1].concat paths
+    else
+      @actions << [:select, paths]
+    end
   end
 
 
@@ -289,7 +310,7 @@ class Kronk::Path::Transaction
   # Queues path deletes for transaction.
 
   def delete *paths
-    @actions[:delete].concat paths
+    @actions << [:delete, paths]
   end
 
 
@@ -297,21 +318,21 @@ class Kronk::Path::Transaction
   # Queues path moving for transaction. Moving a path will attempt to
   # keep the original data structure and only affect the given paths.
   # Empty hashes or arrays after a move are deleted.
-  #   t.move "my/path/1..4/key" => "new_path/%d/key",
-  #          "other/path/*"     => "moved/%d"
+  #   t.move "my/path/1..4/key" => "new_path/%1/key",
+  #          "other/path/*"     => "moved/%1"
 
   def move path_maps
-    @actions[:move].merge! path_maps
+    @actions << [:move, Array(path_maps)]
   end
 
 
   ##
   # Queues path mapping for transaction. Mapping a path will only keep the
   # mapped values, completely replacing the original data structure.
-  #   t.move "my/path/1..4/key" => "new_path/%d/key",
-  #          "other/path/*"     => "moved/%d"
+  #   t.map "my/path/1..4/key" => "new_path/%1/key",
+  #         "other/path/*"     => "moved/%1"
 
   def map path_maps
-    @actions[:map].merge! path_maps
+    @actions << [:map, Array(path_maps)]
   end
 end

data/lib/kronk/path.rb

@@ -136,16 +136,20 @@ class Kronk
     end
 
 
+    SPECIAL_CHARS = "*?()|/."
+    R_SPECIAL_CHARS = /[\0#{Regexp.escape SPECIAL_CHARS}]/u
+
     ##
     # Joins an Array into a path String.
 
     def self.join path_arr, escape=true
-      path_esc = "*?()|/."
-      path_arr.map! do |k|
-        k.to_s.gsub(/([#{path_esc}])/){|m| "\\#{m}"}
-      end if escape
-
-      path_arr.join(DCH)
+      path_str = path_arr.join("\0")
+      if escape
+        path_str.gsub!(R_SPECIAL_CHARS){|c| c == "\0" ? DCH : "\\#{c}"}
+      else
+        path_str.gsub! "\0", DCH
+      end
+      path_str
     end
 
 
@@ -282,6 +286,7 @@ class Kronk
             end
           end
 
+          # Make sure we're not trying to access /./thing
           unless key =~ /^\.?$/ && !value
             matcher = Matcher.new :key        => key,
                                   :value      => value,

data/lib/kronk/player/benchmark.rb

@@ -17,10 +17,10 @@ class Kronk
 
     class ResultSet
 
-      attr_reader :byterate, :count, :fastest, :hostname, :precision,
+      attr_reader :byterate, :count, :fastest, :precision,
                   :slowest, :total_bytes
 
-      def initialize uri, start_time
+      def initialize start_time
         @times = Hash.new(0)
         @count = 0
         @r5XX  = 0
@@ -38,8 +38,6 @@ class Kronk
 
         @start_time = start_time
         @total_time = 0
-
-        @hostname = "#{uri.scheme}://#{uri.host}:#{uri.port}" if uri
       end
 
 
@@ -55,7 +53,7 @@ class Kronk
         @slowest = time if !@slowest || @slowest < time
         @fastest = time if !@fastest || @fastest > time
 
-        log_path resp.uri.path, time if resp.uri
+        log_path resp.uri.to_s, time if resp.uri
 
         @total_bytes += resp.raw.bytes.count
 
@@ -139,14 +137,13 @@ class Kronk
       end
 
 
-      def slowest_paths
-        @paths.to_a.sort{|x,y| y[1] <=> x[1]}[0..9]
+      def slowest_reqs
+        @slowest_reqs ||= @paths.to_a.sort{|x,y| y[1] <=> x[1]}[0..9]
       end
 
 
       def to_s
         out = <<-STR
-Host:          #{@hostname || "<IO>"}
 Completed:     #{@count}
 400s:          #{@r4XX}
 500s:          #{@r5XX}
@@ -173,9 +170,11 @@ Request Percentages (ms)
   100%    #{self.percentages[100]} (longest request)
         STR
 
-        out << "
-Avg. Slowest Paths (ms, #)
-#{slowest_paths.map{|arr| "  #{(arr[1])}  #{arr[0]}"}.join "\n" }" if @hostname
+        unless slowest_reqs.empty?
+          out << "
+Avg. Slowest Requests (ms, #)
+#{slowest_reqs.map{|arr| "  #{arr[1]}  #{arr[0]}"}.join "\n" }"
+        end
 
         out
       end
@@ -203,7 +202,7 @@ Avg. Slowest Paths (ms, #)
       kronk.responses.each_with_index do |resp, i|
         mutex.synchronize do
           @count += 1
-          @results[i] ||= ResultSet.new(resp.uri, @start_time)
+          @results[i] ||= ResultSet.new(@start_time)
           @results[i].add_result resp
 
           puts "#{@count} requests" if @count % @div == 0

data/lib/kronk/player/input_reader.rb

@@ -12,6 +12,7 @@ class Kronk
     attr_accessor :io, :parser, :buffer
 
     def initialize string_or_io, parser=nil
+      @io_buf = ""
       @buffer = []
       @parser = parser || Kronk::Player::RequestParser
       @io     = string_or_io
@@ -25,10 +26,10 @@ class Kronk
     def get_next
       return if eof?
 
-      @buffer << @io.gets if @buffer.empty?
+      @buffer << gets if @buffer.empty?
 
-      until @io.eof?
-        line = @io.gets
+      until @io.eof? && @io_buf.empty?
+        line = gets
         next unless line
 
         if @parser.start_new?(line) || @buffer.empty?
@@ -44,6 +45,42 @@ class Kronk
     end
 
 
+    ##
+    # Read one line from @io, thread-non-blocking.
+
+    def gets
+      return @io.gets if StringIO === @io
+
+      next_line = io_buf_line
+      return next_line if next_line
+
+      until @io.eof?
+        selected, = select [@io], nil, nil, 0.05
+
+        if selected.nil? || selected.empty?
+          Thread.pass
+          next
+        end
+
+        @io_buf << @io.readpartial(1024)
+
+        next_line = io_buf_line
+        return next_line if next_line
+      end
+    end
+
+
+    ##
+    # Get the first line of the io buffer.
+
+    def io_buf_line
+      index = @io_buf.index "\n"
+      return unless index
+
+      @io_buf.slice!(0..index)
+    end
+
+
     ##
     # Returns true if there is no more input to read from.
 

data/lib/kronk/player/request_parser.rb

@@ -7,15 +7,18 @@ class Kronk
   class Player::RequestParser
 
     ##
-    # Returns true-ish if the line given is the start of a new request.
+    # Returns true if the line given is the start of a new request.
 
     def self.start_new? line
       line =~ Request::REQUEST_LINE_MATCHER
+      # Make sure we have a host ($2) or path ($3 || $4) before proceeding.
+      !!($2 || $3 || $4)
     end
 
 
     ##
     # Parse a single http request kronk options hash.
+    # See Kronk::Request.parse for more about request parsing.
 
     def self.parse string
       Kronk::Request.parse_to_hash string

data/lib/kronk/player/stream.rb

@@ -11,11 +11,11 @@ class Kronk
   #   io2   = StringIO.new "this is the rest"
   #
   #   kronk = Kronk.new
-  #   kronk.retrieve io1
+  #   kronk.request io1
   #   out.result kronk
   #   #=> "23\r\nthis is the first chunk\r\n"
   #
-  #   kronk.retrieve io2
+  #   kronk.request io2
   #   out.result kronk
   #   #=> "16\r\nthis is the rest\r\n"
   #

data/lib/kronk/player/suite.rb

@@ -7,7 +7,9 @@ class Kronk
 
     def start
       @results = []
-      $stdout.puts "Started"
+      msg = "Started"
+      msg << (Player.async ? " (async)" : " (threaded)")
+      $stdout.puts msg
       super
     end
 
@@ -17,7 +19,7 @@ class Kronk
 
       @results <<
         if kronk.diff
-          status = "F"             if kronk.diff.count > 0
+          status = "F"             if kronk.diff.any?
           text   = diff_text kronk if status == "F"
           time   =
             (kronk.responses[0].time.to_f + kronk.responses[1].time.to_f) / 2
@@ -27,7 +29,7 @@ class Kronk
         elsif kronk.response
           begin
             # Make sure response is parsable
-            kronk.response.stringify
+            kronk.response.parsed_body if kronk.response.parser
           rescue => e
             error e, kronk, mutex
             return
@@ -100,7 +102,8 @@ class Kronk
 
     def resp_text kronk
       <<-STR
-  Request: #{kronk.response.code} - #{kronk.response.uri}
+  Request: #{kronk.response.code} - #{kronk.response.request.http_method} \
+#{kronk.response.uri}
   Options: #{kronk.options.inspect}
       STR
     end
@@ -108,8 +111,12 @@ class Kronk
 
     def diff_text kronk
       <<-STR
-  Request: #{kronk.responses[0].code} - #{kronk.responses[0].uri}
-           #{kronk.responses[1].code} - #{kronk.responses[1].uri}
+  Request: #{kronk.responses[0].code} - \
+#{kronk.responses[0].request.http_method} \
+#{kronk.responses[0].uri}
+           #{kronk.responses[1].code} - \
+#{kronk.responses[0].request.http_method} \
+#{kronk.responses[1].uri}
   Options: #{kronk.options.inspect}
   Diffs: #{kronk.diff.count}
       STR
@@ -117,12 +124,12 @@ class Kronk
 
 
     def error_text err, kronk=nil
-      str = "#{err.class}: #{err.message}"
+      str = "  #{err.class}: #{err.message}"
 
       if kronk
-        str << "\n  Options: #{kronk.options.inspect}\n\n"
+        str << "\n  Options: #{kronk.options.inspect}\n"
       else
-        str << "\n #{err.backtrace}\n\n"
+        str << "\n #{err.backtrace}\n"
       end
 
       str