kronk 1.0.0

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2010-11-19
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,14 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/kronk
+lib/kronk.rb
+lib/kronk/data_set.rb
+lib/kronk/diff.rb
+lib/kronk/plist_parser.rb
+lib/kronk/request.rb
+lib/kronk/response.rb
+lib/kronk/xml_parser.rb
+test/test_kronk.rb

data/README.txt

@@ -0,0 +1,118 @@
+= kronk
+
+* https://github.com/yaksnrainbows/kronk
+
+== DESCRIPTION:
+
+Kronk runs diffs against data from live and cached http responses. 
+Kronk was made possible by the sponsoring of AT&T Interactive.
+
+== FEATURES/PROBLEMS:
+
+* Parse and diff data from http response body and/or headers.
+
+* Include or exclude particular data points.
+
+* Supports json, rails-ish xml, and plist.
+
+* Support for custom data parsers.
+
+== FUTURE:
+
+* Line numbered and custom diff output.
+
+* Auto-queryer with optional param randomizing.
+
+* Support for test suites.
+
+* Support for proxies, ssl, and http auth.
+
+== SYNOPSIS:
+
+Check if your json response returns the same data as your xml variety:
+
+  $ kronk http://host.com/path.json http://host.com/path.xml
+
+Compare headers only but only content type and date:
+
+  $ kronk http://host.com/path1 http://host.com/path2 -I Content-Type,Date
+
+Compare body structure only:
+
+  $ kronk http://host.com/path.json http://host.com/path.xml --struct
+
+Call comparison with similar uri suffixes:
+
+  $ kronk http://host.com/path.json http://host.com/path.xml --suff '?page=1'
+
+Compare body and headers:
+
+  $ kronk http://host.com/path.json http://host.com/path.xml -i
+
+Compare body and content type header:
+
+  $ kronk http://host.com/path.json http://host.com/path.xml -i Content-Type
+
+Compare response with the previous call:
+
+  $ kronk http://host.com/path --prev
+
+Compare response with a local file:
+
+  $ kronk http://host.com/path.json ./saved_response.json
+
+Do a simple text diff on the http response, including headers:
+
+  $ kronk http://host.com/A/path.json http://host.com/B/path.json --raw -i
+
+Run it to display formatted data:
+
+  $ kronk http://host.com/path.json
+
+  $ kronk http://host.com/path.json -i
+
+Run it to display raw data with headers:
+
+  $ kronk http://host.com/path.json --raw -i
+  
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* sudo gem install kronk
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 Jeremie Castagna
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,20 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugin :isolate
+
+Hoe.spec 'kronk' do
+  developer('Jeremie Castagna', 'yaksnrainbows@gmail.com')
+
+  self.extra_deps << ['plist',         '>=3.1.0']
+  self.extra_deps << ['json',          '>=1.2.0']
+  self.extra_deps << ['nokogiri',      '>=1.3.3']
+  self.extra_deps << ['i18n',          '>=0.5.0']
+  self.extra_deps << ['activesupport', '>=2.0.0']
+
+  self.extra_dev_deps << ['mocha', '>=0.9.10']
+end
+
+# vim: syntax=ruby

data/bin/kronk

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'kronk'
+
+rescue LoadError => e
+  raise unless e.message =~ %r{no such file to load -- kronk}
+
+  $: << File.join(File.dirname(__FILE__), "../lib")
+  require 'kronk'
+end
+
+Kronk.run

data/lib/kronk.rb

@@ -0,0 +1,404 @@
+require 'rubygems'
+require 'plist'
+require 'json'
+require 'nokogiri'
+
+# Support for new and old versions of ActiveSupport
+begin
+  require 'active_support/inflector'
+rescue LoadError
+  require 'activesupport'
+end
+
+require 'net/http'
+require 'optparse'
+
+class Kronk
+
+  # This gem's version.
+  VERSION = '1.0.0'
+
+
+  require 'kronk/data_set'
+  require 'kronk/diff'
+  require 'kronk/response'
+  require 'kronk/request'
+  require 'kronk/plist_parser'
+  require 'kronk/xml_parser'
+
+
+  # Default config file to load. Defaults to ~/.kronk.
+  DEFAULT_CONFIG_FILE = File.expand_path "~/.kronk"
+
+
+  # Default cache file.
+  DEFAULT_CACHE_FILE = File.expand_path "~/.kronk_cache"
+
+
+  # Default Content-Type header to parser mapping.
+  DEFAULT_CONTENT_TYPES = {
+    'js'      => 'JSON',
+    'json'    => 'JSON',
+    'plist'   => 'PlistParser',
+    'xml'     => 'XMLParser'
+  }
+
+
+  # Default config to use.
+  DEFAULT_CONFIG = {
+    :content_types  => DEFAULT_CONTENT_TYPES.dup,
+    :diff_format    => :ascii_diff,
+    :cache_file     => DEFAULT_CACHE_FILE,
+    :requires       => []
+  }
+
+
+  ##
+  # Read the Kronk config hash.
+
+  def self.config
+    @config ||= DEFAULT_CONFIG
+  end
+
+
+  ##
+  # Load a config file and apply to Kronk.config.
+
+  def self.load_config filepath=DEFAULT_CONFIG_FILE
+    conf          = YAML.load_file DEFAULT_CONFIG_FILE
+    content_types = conf.delete :content_types
+
+    if conf[:requires]
+      requires = [*conf.delete(:requires)]
+      self.config[:requires] ||= []
+      self.config[:requires].concat requires
+    end
+
+    self.config[:content_types].merge!(content_types) if content_types
+    self.config.merge! conf
+  end
+
+
+  ##
+  # Load the config-based requires.
+
+  def self.load_requires
+    return unless config[:requires]
+    config[:requires].each{|lib| require lib }
+  end
+
+
+  ##
+  # Creates the default config file at the given path.
+
+  def self.make_config_file filepath=DEFAULT_CONFIG_FILE
+    File.open filepath, "w+" do |file|
+      file << DEFAULT_CONFIG.to_yaml
+    end
+  end
+
+
+  ##
+  # Find a fully qualified ruby namespace/constant.
+
+  def self.find_const namespace
+    consts = namespace.split "::"
+    curr = self
+
+    until consts.empty? do
+      curr = curr.const_get consts.shift
+    end
+
+    curr
+  end
+
+
+  ##
+  # Returns the config-defined parser class for a given content type.
+
+  def self.parser_for content_type
+    parser_pair =
+      config[:content_types].select do |key, value|
+        (content_type =~ %r{#{key}}) && value
+      end
+
+    return if parser_pair.empty?
+
+    parser = parser_pair[0][1]
+    parser = find_const parser if String === parser || Symbol === parser
+    parser
+  end
+
+
+  ##
+  # Make requests, parse the responses and compare the data.
+  # If the second argument is omitted or is passed :cache, will
+  # attempt to compare with the last made request. If there was no last
+  # request will compare against nil.
+  #
+  # Supports the following options:
+  # :data:: Hash/String - the data to pass to the http request
+  # :headers:: Hash - extra headers to pass to the request
+  # :http_method:: Symbol - the http method to use; defaults to :get
+  # :ignore_data:: String/Array - defines which data points to exclude
+  # :with_headers:: Bool/String/Array - defines which headers to include
+  # :raw:: Bool - run diff on raw strings
+  #
+  # Returns a diff object.
+
+  def self.compare query1, query2=:cache, options={}
+    diff =
+      if options[:raw]
+        raw_diff query1, query2, options
+      else
+        data_diff query1, query2, options
+      end
+
+    diff
+  end
+
+
+  ##
+  # Return a diff object from two responses' raw data.
+
+  def self.raw_diff query1, query2, options={}
+    resp1 = Request.retrieve query1, options
+    resp2 = Request.retrieve query2, options
+
+    Diff.new resp1.selective_string(options), resp2.selective_string(options)
+  end
+
+
+  ##
+  # Return a diff object from two parsed responses.
+
+  def self.data_diff query1, query2, options={}
+    resp1 = Request.retrieve query1, options
+    resp2 = Request.retrieve query2, options
+
+    Diff.new_from_data resp1.selective_data(options),
+                       resp2.selective_data(options),
+                       options
+  end
+
+
+  ##
+  # Runs the kronk command with the given terminal args.
+
+  def self.run argv=ARGV
+    begin
+      load_config
+
+    rescue Errno::ENOENT
+      make_config_file
+
+      $stderr << "\nNo config file was found.\n\n"
+      $stderr << "Created default config in #{DEFAULT_CONFIG_FILE}\n"
+      $stderr << "Edit file if necessary and try again.\n"
+      exit 1
+    end
+
+    options = parse_args argv
+
+    config[:requires].concat options[:requires] if options[:requires]
+    load_requires
+
+    options[:cache_response] = config[:cache_file] if config[:cache_file]
+
+    uri1, uri2 = options.delete :uris
+
+    if uri1 && uri2
+      diff = compare uri1, uri2, options
+      puts diff.formatted(config[:diff_format])
+
+    elsif options[:raw]
+      puts Request.retrieve(uri1, options).selective_string(options)
+
+    else
+      data = Request.retrieve(uri1, options).selective_data options
+      puts Diff.ordered_data_string(data, options[:struct])
+    end
+
+  rescue Request::NotFoundError, Response::MissingParser => e
+    $stderr << "\nError: #{e.message}\n"
+    exit 2
+  end
+
+
+  ##
+  # Parse ARGV
+
+  def self.parse_args argv
+    options = {
+      :with_headers    => false,
+      :no_body         => false,
+      :uris            => []
+    }
+
+    options[:only_data], options[:ignore_data] = parse_data_path_args argv
+
+    opts = OptionParser.new do |opt|
+      opt.program_name = File.basename $0
+      opt.version = VERSION
+      opt.release = nil
+
+      opt.banner = <<-STR
+Kronk runs diffs against data from live and cached http responses.
+
+  Usage:
+    #{opt.program_name} --help
+    #{opt.program_name} --version
+    #{opt.program_name} uri1 [uri2] [options...] [-- data-paths]
+
+  Examples:
+    #{opt.program_name} http://example.com/A
+    #{opt.program_name} http://example.com/B --prev --raw
+    #{opt.program_name} http://example.com/B.xml local/file/B.json
+    #{opt.program_name} file1.json file2.json -- **/key1=val1 -root/key?
+
+  Arguments after -- will be used to focus the diff on specific data points.
+  If the data paths start with a '-' the matched data points will be removed.
+
+  Options:
+      STR
+
+      opt.on('-d', '--data STR', String,
+             'Post data with the request') do |value|
+        options[:data] = value
+        options[:http_method] ||= 'POST'
+      end
+
+
+      opt.on('--prev', 'Use last response to diff against') do
+        options[:uris] << :cache
+      end
+
+
+      opt.on('--suff STR', String,
+             'Add common path items to the end of each URI') do |value|
+        options[:uri_suffix] = value
+      end
+
+
+      opt.on('-H', '--header STR', String,
+             'Header to pass to the server request') do |value|
+        options[:headers] ||= {}
+
+        key, value = value.split ": ", 2
+        options[:headers][key] = value
+      end
+
+
+      opt.on('-i', '--include [header1,header2]', Array,
+             'Include all or given headers in response') do |value|
+        options[:with_headers] ||= []
+
+        if value
+          options[:with_headers].concat value if
+            Array === options[:with_headers]
+        else
+          options[:with_headers] = true
+        end
+      end
+
+
+      opt.on('-I', '--head [header1,header2]', Array,
+             'Use all or given headers only in the response') do |value|
+        options[:with_headers] ||= []
+
+        if value
+          options[:with_headers].concat value if
+            Array === options[:with_headers]
+        else
+          options[:with_headers] = true
+        end
+
+        options[:no_body] = true
+      end
+
+
+      opt.on('-L', '--location [NUM]', Integer,
+             'Follow the location header always or num times') do |value|
+        options[:follow_redirects] = value || true
+      end
+
+
+      opt.on('-X', '--request STR', String,
+             'The request method to use') do |value|
+        options[:http_method] = value
+      end
+
+
+      opt.on('-r', '--require lib1,lib2', Array,
+             'Require a library or gem') do |value|
+        options[:requires] ||= []
+        options[:requires].concat value
+      end
+
+
+      opt.on('--raw', 'Run diff on the raw data returned') do
+        options[:raw] = true
+      end
+
+
+      opt.on('--struct', 'Run diff on the data structure') do
+        options[:struct] = true
+      end
+
+
+      opt.on('--ascii', 'Return ascii formatted diff') do
+        config[:diff_format] = :ascii_diff
+      end
+
+
+      opt.on('--color', 'Return color formatted diff') do
+        config[:diff_format] = :color_diff
+      end
+
+
+      #opt.on('-v', '--verbose', 'Make the operation more talkative') do
+      #  options[:verbose] = true
+      #end
+
+      opt.separator nil
+    end
+
+    opts.parse! argv
+
+    options[:uris].concat argv
+    options[:uris].slice!(2..-1)
+
+    if options[:uris].empty?
+      $stderr << "\nError: You must enter at least one URI\n\n"
+      $stderr << opts.to_s
+      exit 1
+    end
+
+    options
+  end
+
+
+  ##
+  # Searches ARGV and returns data paths to add or exclude in the diff.
+  # Returns the array [only_paths, except_paths]
+
+  def self.parse_data_path_args argv
+    return unless argv.include? "--"
+
+    data_paths = argv.slice! argv.index("--")..-1
+    data_paths.shift
+
+    only_paths   = nil
+    except_paths = nil
+
+    data_paths.each do |path|
+      if path[0,1] == "-"
+        (except_paths ||= []) << path[1..-1]
+      else
+        (only_paths ||= []) << path
+      end
+    end
+
+    [only_paths, except_paths]
+  end
+end