kronk 1.6.2 → 1.7.0

data/lib/kronk/response.rb

@@ -18,14 +18,14 @@ class Kronk
 
   class Response
 
-    class MissingParser < Exception; end
-    class InvalidParser < Exception; end
+    class MissingParser < Kronk::Exception; end
+    class InvalidParser < Kronk::Exception; end
 
 
     ENCODING_MATCHER = /(^|;\s?)charset=(.*?)\s*(;|$)/
 
     ##
-    # Read http response from a file and return a HTTPResponse instance.
+    # Read http response from a file and return a Kronk::Response instance.
 
     def self.read_file path
       file     = File.open(path, "rb")
@@ -143,7 +143,7 @@ class Kronk
     # Ruby inspect.
 
     def inspect
-      "#<#{self.class}:#{self.code} #{self['Content-Type']}>"
+      "#<#{self.class}:#{self.code} #{self['Content-Type']} #{total_bytes}bytes>"
     end
 
 
@@ -235,6 +235,16 @@ class Kronk
     end
 
 
+    ##
+    # Returns the location to redirect to. Prepends request url if location
+    # header is relative.
+
+    def location
+      return @_res['Location'] if !@request || !@request.uri
+      @request.uri.merge @_res['Location']
+    end
+
+
     ##
     # Check if this is a redirect response.
 
@@ -249,7 +259,7 @@ class Kronk
 
     def follow_redirect opts={}
       return if !redirect?
-      Request.new(@_res['Location'], opts).retrieve
+      Request.new(self.location, opts).retrieve
     end
 
 
@@ -277,8 +287,19 @@ class Kronk
     # :no_body:: Bool - Don't return the body; default nil
     # :show_headers:: Bool/String/Array - Return headers; default nil
     # :parser:: Object - The parser to use for the body; default nil
+    # :transform:: Array - Action/path(s) pairs to modify data.
+    #
+    # Deprecated Options:
     # :ignore_data:: String/Array - Removes the data from given data paths
     # :only_data:: String/Array - Extracts the data from given data paths
+    #
+    # Example:
+    #   response.selective_data :transform => [:delete, ["foo/0", "bar/1"]]
+    #   response.selective_data do |trans|
+    #     trans.delete "foo/0", "bar/1"
+    #   end
+    #
+    # See Kronk::Path::Transaction for supported transform actions.
 
     def selective_data options={}
       data = nil
@@ -294,8 +315,13 @@ class Kronk
       end
 
       Path::Transaction.run data, options do |t|
-        t.select(*options[:only_data])
-        t.delete(*options[:ignore_data])
+        # Backward compatibility support
+        t.select(*options[:only_data])   if options[:only_data]
+        t.delete(*options[:ignore_data]) if options[:ignore_data]
+
+        t.actions.concat options[:transform] if options[:transform]
+
+        yield t if block_given?
       end
     end
 
@@ -311,13 +337,16 @@ class Kronk
     # :raw:: Boolean - Force using the unparsed raw response
     # :keep_indicies:: Boolean - indicies of modified arrays display as hashes.
     # :show_headers:: Boolean/String/Array - defines which headers to include
+    #
+    # If block is given, yields a Kronk::Path::Transaction instance to make
+    # transformations on the data. See Kronk::Response#selective_data
 
-    def stringify options={}
+    def stringify options={}, &block
       options = options.empty? ? @stringify_opts : merge_stringify_opts(options)
 
       if !options[:raw] && (options[:parser] || @parser || options[:no_body])
-        data = selective_data options
-        Diff.ordered_data_string data, options[:struct]
+        data = selective_data options, &block
+        DataString.new data, options
       else
         selective_string options
       end

data/lib/kronk/test/assertions.rb

@@ -83,8 +83,8 @@ class Kronk
       # Supports all options of Kronk.compare.
 
       def assert_equal_responses uri1, uri2, options={}
-        resp1 = Kronk.retrieve(uri1, options).stringify
-        resp2 = Kronk.retrieve(uri2, options).stringify
+        resp1 = Kronk.request(uri1, options).stringify
+        resp2 = Kronk.request(uri2, options).stringify
 
         assert_equal resp1, resp2
       end

data/lib/kronk/test/helper_methods.rb

@@ -52,7 +52,7 @@ class Kronk
 
         @kronk = Kronk.new options
 
-        uri2 ? @kronk.compare(uri1, uri2) : @kronk.retrieve(uri1)
+        uri2 ? @kronk.compare(uri1, uri2) : @kronk.request(uri1)
 
         @responses = @kronk.responses
         @response  = @kronk.response

data/lib/kronk.rb

@@ -14,9 +14,10 @@ require 'yaml'
 class Kronk
 
   # This gem's version.
-  VERSION = '1.6.2'
+  VERSION = '1.7.0'
 
   require 'kronk/constants'
+  require 'kronk/queue_runner'
   require 'kronk/player'
   require 'kronk/player/output'
   require 'kronk/player/suite'
@@ -29,7 +30,7 @@ class Kronk
   require 'kronk/path/path_match'
   require 'kronk/path/matcher'
   require 'kronk/path/transaction'
-  require 'kronk/data_renderer'
+  require 'kronk/data_string'
   require 'kronk/diff/ascii_format'
   require 'kronk/diff/color_format'
   require 'kronk/diff/output'
@@ -54,18 +55,40 @@ class Kronk
   def self.load_config filepath=DEFAULT_CONFIG_FILE
     conf = YAML.load_file filepath
 
-    self.config[:requires].concat [*conf.delete(:requires)] if conf[:requires]
+    conf.each do |key, value|
+      skey = key.to_sym
 
-    [:content_types, :uri_options, :user_agents].each do |key|
-      self.config[key].merge! conf.delete(key) if conf[key]
-    end
+      case skey
+      when :content_types, :user_agents
+        conf[key].each{|k,v| self.config[skey][k.to_s] = v }
+
+      when :requires
+        self.config[skey].concat Array(value)
+
+      when :uri_options
+        conf[key].each do |matcher, opts|
+          self.config[skey][matcher.to_s] = opts
+          opts.keys.each{|k| opts[k.to_sym] = opts.delete(k) if String === k}
+        end
 
-    self.config.merge! conf
+      else
+        self.config[skey] = value
+      end
+    end
   end
 
 
   ##
-  # Find a fully qualified ruby namespace/constant.
+  # Find a fully qualified ruby namespace/constant. Supports file paths,
+  # constants, or path:Constant combinations:
+  #   Kronk.find_const "json"
+  #   #=> JSON
+  #
+  #   Kronk.find_const "namespace/mylib"
+  #   #=> Namespace::MyLib
+  #
+  #   Kronk.find_const "path/to/somefile.rb:Namespace::MyLib"
+  #   #=> Namespace::MyLib
 
   def self.find_const name_or_file, case_insensitive=false
     return name_or_file unless String === name_or_file
@@ -161,7 +184,7 @@ class Kronk
 
 
   ##
-  # Load the saved cookies file.
+  # Load the saved cookies file. Defaults to Kronk::config[:cookies_file].
 
   def self.load_cookie_jar file=nil
     file ||= config[:cookies_file]
@@ -216,13 +239,16 @@ class Kronk
 
 
   ##
-  # See Kronk#retrieve. Short for:
-  #   Kronk.new(opts).retrieve(uri)
+  # See Kronk#request. Short for:
+  #   Kronk.new(opts).request(uri)
 
-  def self.retrieve uri, opts={}
-    new(opts).retrieve uri
+  def self.request uri, opts={}
+    new(opts).request uri
   end
 
+  class << self
+    alias retrieve request
+  end
 
   attr_accessor :diff, :options, :response, :responses
 
@@ -240,12 +266,15 @@ class Kronk
   # :user_agent:: String - user agent string or alias; defaults to 'kronk'
   # :auth:: Hash - must contain :username and :password; defaults to nil
   # :proxy:: Hash/String - http proxy to use; defaults to nil
-  # :only_data:: String/Array - extracts the data from given data paths
-  # :ignore_data:: String/Array - defines which data points to exclude
   # :keep_indicies:: Boolean - indicies of modified arrays display as hashes
   # :show_headers:: Boolean/String/Array - which headers to show in output
   # :parser:: Object/String - the parser to use for the body; default nil
   # :raw:: Boolean - run diff on raw strings
+  # :transform:: Array - Action/path(s) pairs to modify data.
+  #
+  # Deprecated Options:
+  # :ignore_data:: String/Array - Removes the data from given data paths
+  # :only_data:: String/Array - Extracts the data from given data paths
 
   def initialize opts={}
     @options   = opts
@@ -260,19 +289,19 @@ class Kronk
   # Query arguments may be set to the special value :cache to use the
   # last live http response retrieved.
   #
-  # Returns a diff object.
+  # Assigns @response, @responses, @diff. Returns the Diff instance.
 
   def compare uri1, uri2
     str1 = str2 = ""
     res1 = res2 = nil
 
     t1 = Thread.new do
-          res1 = retrieve uri1
+          res1 = request uri1
           str1 = res1.stringify
          end
 
     t2 = Thread.new do
-          res2 = retrieve uri2
+          res2 = request uri2
           str2 = res2.stringify
          end
 
@@ -289,8 +318,9 @@ class Kronk
 
   ##
   # Returns a Response instance from a url, file, or IO as a String.
+  # Assigns @response, @responses, @diff.
 
-  def retrieve uri
+  def request uri
     options = Kronk.config[:no_uri_options] ? @options : options_for_uri(uri)
 
     if IO === uri || StringIO === uri
@@ -311,11 +341,11 @@ class Kronk
     resp.parser         = options[:parser] if options[:parser]
     resp.stringify_opts = options
 
-    max_rdir = options[:follow_redirects]
-    while resp.redirect? && (max_rdir == true || max_rdir.to_s.to_i > 0)
-      Cmd.verbose "Following redirect..."
-      resp     = resp.follow_redirect
-      max_rdir = max_rdir - 1 if Fixnum === max_rdir
+    rdir = options[:follow_redirects]
+    while resp.redirect? && (rdir == true || rdir.to_s.to_i > 0)
+      Cmd.verbose "Following redirect to #{resp.location}"
+      resp = resp.follow_redirect options_for_uri(resp.location)
+      rdir = rdir - 1 if Fixnum === rdir
     end
 
     @responses = [resp]
@@ -331,6 +361,8 @@ class Kronk
     raise TimeoutError, "#{uri} took too long to respond"
   end
 
+  alias retrieve request
+
 
   ##
   # Returns merged config-defined options for a given uri.

data/test/test_assertions.rb

@@ -61,7 +61,7 @@ class TestAssertions < Test::Unit::TestCase
     io        = StringIO.new mock_resp("200_response.json")
     mock_resp = Kronk::Response.new io
 
-    Kronk.expects(:retrieve).times(2).
+    Kronk.expects(:request).times(2).
       with("host.com", :foo => "bar").returns mock_resp
 
     assert_equal_responses "host.com", "host.com", :foo => "bar"
@@ -75,13 +75,13 @@ class TestAssertions < Test::Unit::TestCase
     mock_resp2 = Kronk::Response.new \
                   StringIO.new mock_resp("301_response.txt")
 
-    Kronk.expects(:retrieve).
+    Kronk.expects(:request).
       with("host1.com", :foo => "bar").returns mock_resp1
 
-    Kronk.expects(:retrieve).
+    Kronk.expects(:request).
       with("host2.com", :foo => "bar").returns mock_resp2
 
-    left  = Kronk::Diff.ordered_data_string mock_resp1.selective_data
+    left  = Kronk::DataString.new mock_resp1.selective_data
     right = mock_resp2.body
 
     assert_not_equal left, right

data/test/test_cmd.rb

@@ -98,8 +98,8 @@ class TestCmd < Test::Unit::TestCase
     argv = %w{opt1 opt2 -- path1 path2 -path3}
     Kronk::Cmd.parse_data_path_args opts, argv
 
-    assert_equal %w{path1 path2}, opts[:only_data]
-    assert_equal %w{path3}, opts[:ignore_data]
+    assert_equal [:select, %w{path1 path2}], opts[:transform][0]
+    assert_equal [:delete, %w{path3}],       opts[:transform][1]
   end
 
 
@@ -113,6 +113,34 @@ class TestCmd < Test::Unit::TestCase
   end
 
 
+  def test_parse_data_path_args_double
+    options = {}
+    argv = %w{this is --argv -- one -two -- -three four}
+
+    options = Kronk::Cmd.parse_data_path_args options, argv
+
+    assert_equal [:select, %w{one}],         options[:transform][0]
+    assert_equal [:delete, %w{two - three}], options[:transform][1]
+    assert_equal [:select, %w{four}],        options[:transform][2]
+
+    assert_equal %w{this is --argv}, argv
+  end
+
+
+  def test_parse_data_path_args_select_and_map_join
+    options = {}
+    argv = %w{this is --argv -- one two>foo -three four}
+
+    options = Kronk::Cmd.parse_data_path_args options, argv
+
+    assert_equal [:map, ['one', ['two', 'foo']]], options[:transform][0]
+    assert_equal [:delete, %w{three}],            options[:transform][1]
+    assert_equal [:select, %w{four}],             options[:transform][2]
+
+    assert_equal %w{this is --argv}, argv
+  end
+
+
   def test_query_password
     $stderr.expects(:<<).with "Password: "
     $stdin.expects(:gets).returns "mock_password\n"
@@ -322,7 +350,7 @@ class TestCmd < Test::Unit::TestCase
     assert_equal "bar",   opts[:query]
     assert_equal "/tail", opts[:uri_suffix]
     assert_equal "PUT",   opts[:http_method]
-    assert_equal({:address => "example.com", :port => "2000"}, opts[:proxy])
+    assert_equal({:host => "example.com", :port => "2000"}, opts[:proxy])
 
     opts = Kronk::Cmd.parse_args %w{uri -L 3}
     assert_equal 3, opts[:follow_redirects]
@@ -348,8 +376,8 @@ class TestCmd < Test::Unit::TestCase
 
   def test_parse_args_paths
     opts = Kronk::Cmd.parse_args %w{uri -- path1 path2 -path3}
-    assert_equal %w{path3}, opts[:ignore_data]
-    assert_equal %w{path1 path2}, opts[:only_data]
+    assert_equal [:delete, %w{path3}],       opts[:transform][1]
+    assert_equal [:select, %w{path1 path2}], opts[:transform][0]
   end
 
 
@@ -550,7 +578,7 @@ class TestCmd < Test::Unit::TestCase
     kronk = Kronk.new
     io    = StringIO.new(mock_200_response)
 
-    kronk.retrieve io
+    kronk.request io
     expect_request_output mock_200_response, :times => 2
 
     assert_equal Kronk::Cmd.render_response(kronk.response),
@@ -622,7 +650,7 @@ class TestCmd < Test::Unit::TestCase
 
   def test_render_response
     kronk = Kronk.new
-    kronk.retrieve StringIO.new(mock_200_response)
+    kronk.request StringIO.new(mock_200_response)
 
     $stdout.expects(:puts).with kronk.response.stringify
     assert Kronk::Cmd.render_response(kronk.response),
@@ -633,7 +661,7 @@ class TestCmd < Test::Unit::TestCase
   def test_render_response_lines
     with_config :show_lines => true do
       kronk = Kronk.new
-      kronk.retrieve StringIO.new(mock_200_response)
+      kronk.request StringIO.new(mock_200_response)
 
       expected = Kronk::Diff.insert_line_nums kronk.response.stringify
       $stdout.expects(:puts).with expected
@@ -650,7 +678,7 @@ class TestCmd < Test::Unit::TestCase
       io    = StringIO.new(mock_200_response)
 
       $stdout.expects(:<<).with "Reading IO #{io}\n"
-      kronk.retrieve io
+      kronk.request io
 
       expected = kronk.response.stringify
       $stdout.expects(:puts).with expected
@@ -664,7 +692,7 @@ class TestCmd < Test::Unit::TestCase
 
   def test_render_response_failed
     kronk = Kronk.new
-    kronk.retrieve StringIO.new(mock_302_response)
+    kronk.request StringIO.new(mock_302_response)
 
     $stdout.expects(:puts).with kronk.response.stringify
     assert !Kronk::Cmd.render_response(kronk.response),

data/test/test_data_string.rb

@@ -3,7 +3,8 @@ require 'test/test_helper'
 class TestDataString < Test::Unit::TestCase
 
   def setup
-    @dstr = Kronk::DataString.new "foobar", "data0"
+    @dstr = Kronk::DataString.new
+    @dstr.append "foobar", "data0"
   end
 
 
@@ -55,4 +56,244 @@ class TestDataString < Test::Unit::TestCase
       assert_equal [@dstr.meta[i]], dstr.meta
     end
   end
+
+
+  def test_ordered_data_string_json
+    expected = <<STR
+{
+ "acks": [
+  [
+   56,
+   78
+  ],
+  [
+   "12",
+   "34"
+  ]
+ ],
+ "root": [
+  [
+   "B1",
+   "B2"
+  ],
+  [
+   "A1",
+   "A2"
+  ],
+  [
+   "C1",
+   "C2",
+   [
+    "C3a",
+    "C3b"
+   ]
+  ],
+  {
+   ":tests": [
+    "D3a",
+    "D3b"
+   ],
+   "test": [
+    [
+     "D1a\\nContent goes here",
+     "D1b"
+    ],
+    "D2"
+   ]
+  }
+ ],
+ "subs": [
+  "a",
+  "b"
+ ],
+ "tests": {
+  ":foo": ":bar",
+  "test": [
+   [
+    1,
+    2
+   ],
+   2.123
+  ]
+ }
+}
+STR
+
+    assert_equal expected.strip, Kronk::DataString.new(mock_data)
+  end
+
+
+  def test_ordered_data_string_struct_json
+    expected = <<STR
+{
+ "acks": [
+  [
+   "Fixnum",
+   "Fixnum"
+  ],
+  [
+   "String",
+   "String"
+  ]
+ ],
+ "root": [
+  [
+   "String",
+   "String"
+  ],
+  [
+   "String",
+   "String"
+  ],
+  [
+   "String",
+   "String",
+   [
+    "String",
+    "String"
+   ]
+  ],
+  {
+   ":tests": [
+    "String",
+    "String"
+   ],
+   "test": [
+    [
+     "String",
+     "String"
+    ],
+    "String"
+   ]
+  }
+ ],
+ "subs": [
+  "String",
+  "String"
+ ],
+ "tests": {
+  ":foo": "Symbol",
+  "test": [
+   [
+    "Fixnum",
+    "Fixnum"
+   ],
+   "Float"
+  ]
+ }
+}
+STR
+
+    assert_equal expected.strip,
+                  Kronk::DataString.new(mock_data, :struct => true)
+
+      assert_equal Kronk::DataString.json(mock_data, :struct => true),
+                   Kronk::DataString.new(mock_data, :struct => true)
+  end
+
+
+  def test_ordered_data_string_ruby_paths
+    with_config :render_lang => 'ruby', :render_paths => true do
+      expected = <<STR
+{
+ "/acks/0/0" => 56,
+ "/acks/0/1" => 78,
+ "/acks/1/0" => "12",
+ "/acks/1/1" => "34",
+ "/root/0/0" => "B1",
+ "/root/0/1" => "B2",
+ "/root/1/0" => "A1",
+ "/root/1/1" => "A2",
+ "/root/2/0" => "C1",
+ "/root/2/1" => "C2",
+ "/root/2/2/0" => "C3a",
+ "/root/2/2/1" => "C3b",
+ "/root/3/test/0/0" => "D1a\\nContent goes here",
+ "/root/3/test/0/1" => "D1b",
+ "/root/3/test/1" => "D2",
+ "/root/3/tests/0" => "D3a",
+ "/root/3/tests/1" => "D3b",
+ "/subs/0" => "a",
+ "/subs/1" => "b",
+ "/tests/foo" => :bar,
+ "/tests/test/0/0" => 1,
+ "/tests/test/0/1" => 2,
+ "/tests/test/1" => 2.123
+}
+STR
+
+      assert_equal expected.strip, Kronk::DataString.new(mock_data)
+    end
+  end
+
+
+  def test_ordered_data_string_struct_ruby
+    with_config :render_lang => 'ruby' do
+      expected = <<STR
+{
+ "acks" => [
+  [
+   Fixnum,
+   Fixnum
+  ],
+  [
+   String,
+   String
+  ]
+ ],
+ "root" => [
+  [
+   String,
+   String
+  ],
+  [
+   String,
+   String
+  ],
+  [
+   String,
+   String,
+   [
+    String,
+    String
+   ]
+  ],
+  {
+   :tests => [
+    String,
+    String
+   ],
+   "test" => [
+    [
+     String,
+     String
+    ],
+    String
+   ]
+  }
+ ],
+ "subs" => [
+  String,
+  String
+ ],
+ "tests" => {
+  :foo => Symbol,
+  "test" => [
+   [
+    Fixnum,
+    Fixnum
+   ],
+   Float
+  ]
+ }
+}
+STR
+
+      assert_equal expected.strip,
+                    Kronk::DataString.new(mock_data, :struct => true)
+
+      assert_equal Kronk::DataString.ruby(mock_data, :struct => true),
+                   Kronk::DataString.new(mock_data, :struct => true)
+    end
+  end
 end