kronk 1.2.5 → 1.3.0

data/lib/kronk/diff/color_format.rb

@@ -0,0 +1,49 @@
+class Kronk
+
+  class Diff
+
+    ##
+    # Format diff with ascii
+
+    class ColorFormat
+
+      def self.ensure_color
+        return unless Kronk::Cmd.windows?
+        begin
+          require 'Win32/Console/ANSI'
+        rescue LoadError
+          Cmd.warn "You must gem install win32console to use color"
+        end
+      end
+
+
+      def self.lines line_nums, col_width
+        ensure_color
+
+        out =
+          [*line_nums].map do |lnum|
+            lnum.to_s.rjust col_width
+          end.join "\033[32m"
+
+        "\033[7;31m#{out}\033[0m "
+      end
+
+
+      def self.deleted str
+        ensure_color
+        "\033[31m- #{str}\033[0m"
+      end
+
+
+      def self.added str
+        ensure_color
+        "\033[32m+ #{str}\033[0m"
+      end
+
+
+      def self.common str
+        "  #{str}"
+      end
+    end
+  end
+end

data/lib/kronk/request.rb

@@ -19,7 +19,7 @@ class Kronk
     # number of redirects left if it's an Integer.
 
     def self.follow_redirect resp, options={}
-      Kronk.verbose "Following redirect..."
+      Kronk::Cmd.verbose "Following redirect..."
 
       rdir = options[:follow_redirects]
       rdir = rdir - 1 if Integer === rdir && rdir > 0
@@ -84,7 +84,7 @@ class Kronk
     # Read http response from a file and return a HTTPResponse instance.
 
     def self.retrieve_file path, options={}
-      Kronk.verbose "Reading file:  #{path}\n"
+      Kronk::Cmd.verbose "Reading file:  #{path}\n"
 
       options = options.dup
 
@@ -95,7 +95,7 @@ class Kronk
 
         # On windows, read the full file and insert contents into
         # a StringIO to avoid failures with IO#read_nonblock
-        file = StringIO.new file.read if Kronk.windows?
+        file = StringIO.new file.read if Kronk::Cmd.windows?
 
         begin
           resp = Response.read_new file
@@ -117,7 +117,7 @@ class Kronk
     # Read the http response from an IO instance and return a HTTPResponse.
 
     def self.retrieve_io io, options={}
-      Kronk.verbose "Reading IO..."
+      Kronk::Cmd.verbose "Reading IO..."
 
       options = options.dup
 
@@ -221,7 +221,7 @@ class Kronk
                          options[:auth][:password]
         end
 
-        Kronk.verbose "Retrieving URL:  #{uri}\n"
+        Kronk::Cmd.verbose "Retrieving URL:  #{uri}\n"
 
         http.request req, data
       end
@@ -289,7 +289,7 @@ class Kronk
       user = proxy_opts[:username]
       pass = proxy_opts[:password]
 
-      Kronk.verbose "Using proxy #{addr}\n" if host
+      Kronk::Cmd.verbose "Using proxy #{addr}\n" if host
 
       Net::HTTP::Proxy host, port, user, pass
     end

data/lib/kronk/test.rb

@@ -0,0 +1,15 @@
+class Kronk
+
+  ##
+  # Test module that includes kronk assertions, request helper methods,
+  # and core extensions.
+
+  module Test
+    require 'kronk/test/assertions'
+    require 'kronk/test/core_ext'
+    require 'kronk/test/helper_methods'
+
+    include Assertions
+    include HelperMethods
+  end
+end

data/lib/kronk/test/assertions.rb

@@ -0,0 +1,97 @@
+class Kronk
+
+  module Test
+
+    module Assertions
+
+      ##
+      # Assert that the given path exists in data.
+      # Supports all DataSet#find_data path types.
+
+      def assert_data_at data, path, msg=nil
+        msg ||= "No data found at #{path.inspect} for #{data.inspect}"
+        found = false
+
+        data_set = Kronk::DataSet.new data
+        data_set.find_data path do |d,k,p|
+          found = true
+          break
+        end
+
+        assert found, msg
+      end
+
+
+      ##
+      # Assert that the given path doesn't exist in data.
+      # Supports all DataSet#find_data path types.
+
+      def assert_no_data_at data, path, msg=nil
+        msg ||= "Data found at #{path.inspect} for #{data.inspect}"
+        found = false
+
+        data_set = Kronk::DataSet.new data
+        data_set.find_data path do |d,k,p|
+          found = true
+          break
+        end
+
+        assert !found, msg
+      end
+
+
+      ##
+      # Assert that at least one data point found with the given path is equal
+      # to the given match.
+      # Supports all DataSet#find_data path types.
+
+      def assert_data_at_equal data, path, match, msg=nil
+        last_data = nil
+        found     = false
+
+        data_set = Kronk::DataSet.new data
+        data_set.find_data path do |d,k,p|
+          found     = true
+          last_data = d[k]
+          break if d[k] == match
+        end
+
+        assert found,
+          msg || "No data found at #{path.inspect} for #{data.inspect}"
+
+        assert_equal match, last_data, msg
+      end
+
+
+      ##
+      # Assert that no data points found with the given path are equal
+      # to the given match.
+      # Supports all DataSet#find_data path types.
+
+      def assert_data_at_not_equal data, path, match, msg=nil
+        last_data = nil
+
+        data_set = Kronk::DataSet.new data
+        data_set.find_data path do |d,k,p|
+          last_data = d[k]
+          break if d[k] == match
+        end
+
+        assert_not_equal match, last_data, msg
+      end
+
+
+      ##
+      # Makes request to both uris and asserts that the parsed data they
+      # return is equal. Compares response body if data is unparsable.
+      # Supports all options of Kronk.compare.
+
+      def assert_equal_responses uri1, uri2, options={}
+        resp1 = Kronk.retrieve_data_string uri1, options
+        resp2 = Kronk.retrieve_data_string uri2, options
+
+        assert_equal resp1, resp2
+      end
+    end
+  end
+end

data/lib/kronk/test/core_ext.rb

@@ -0,0 +1,65 @@
+class Kronk
+
+  module Test
+
+    ##
+    # Data manipulation and retrieval methods for Array and Hash classes.
+
+    module DataExt
+
+      ##
+      # Checks if the given path exists and returns the first matching path
+      # as an array of keys. Returns nil if no path is found.
+
+      def has_path? path
+        Kronk::DataSet.new(self).find_data path do |d,k,p|
+          return !!p
+        end
+
+        nil
+      end
+
+
+      ##
+      # Looks for data at paths matching path. Returns a hash of
+      # path array => data value pairs.
+      #
+      # If given a block will pass the parent data structure, the key
+      # or index of the item at given path, and the full path
+      # as an array of keys for each found path.
+      #
+      #   data = {:foo => "bar", :foobar => [:a, :b, {:foo => "other bar"}, :c]}
+      #   data.find_data "**/foo" do |parent, key, path|
+      #     p path
+      #     p parent[key]
+      #     puts "---"
+      #   end
+      #
+      #   # outputs:
+      #   # [:foo]
+      #   # "bar"
+      #   # ---
+      #   # [:foobar, 2, :foo]
+      #   # "other bar"
+      #   # ---
+      #
+      #   # returns:
+      #   # {[:foo] => "bar", [:foobar, 2, :foo] => "other bar"}
+
+      def find_data path
+        found = {}
+
+        Kronk::DataSet.new(self).find_data path do |d,k,p|
+          found[p] = d[k]
+          yield d, k, p if block_given?
+        end
+
+        found
+      end
+    end
+  end
+end
+
+
+Array.send :include, Kronk::Test::DataExt
+Hash.send :include, Kronk::Test::DataExt

data/lib/kronk/test/helper_methods.rb

@@ -0,0 +1,86 @@
+class Kronk
+
+  module Test
+
+    ##
+    # Kronk test helper methods to easily make and mock requests.
+    # Sets @responses, @response, @datas, @data, and @diff instance variables.
+
+    module HelperMethods
+
+      ##
+      # Do a get request for one or two URIs.
+      # See Kronk#compare for all supported options.
+
+      def get uri1, uri2=nil, options={}
+        retrieve uri1, uri2, options.merge(:http_method => :get)
+      end
+
+
+      ##
+      # Do a post request for one or two URIs.
+      # See Kronk#compare for all supported options.
+
+      def post uri1, uri2=nil, options={}
+        retrieve uri1, uri2, options.merge(:http_method => :post)
+      end
+
+
+      ##
+      # Do a put request for one or two URIs.
+      # See Kronk#compare for all supported options.
+
+      def put uri1, uri2=nil, options={}
+        retrieve uri1, uri2, options.merge(:http_method => :put)
+      end
+
+
+      ##
+      # Do a delete request for one or two URIs.
+      # See Kronk#compare for all supported options.
+
+      def delete uri1, uri2=nil, options={}
+        retrieve uri1, uri2, options.merge(:http_method => :delete)
+      end
+
+
+      protected
+
+      def retrieve uri1, uri2=nil, options={}
+        uri2, options = nil, uri2.merge(options) if Hash === uri2
+
+        if uri2
+          @responses = [Request.retrieve(uri1, options),
+                        Request.retrieve(uri2, options)]
+          @response  = @responses.last
+
+          @datas     = @responses.map do |r|
+                         begin
+                           r.selective_data options
+                         rescue Kronk::Response::MissingParser
+                           r.body
+                         end
+                       end
+
+          @data      = @datas.last
+
+          @diff      = Diff.new_from_data(*@datas)
+
+        else
+          @response  = Request.retrieve uri1, options
+          @responses = [@response]
+
+          @data      = begin
+                         @response.selective_data options
+                       rescue Kronk::Response::MissingParser
+                         @response.body
+                       end
+
+          @datas     = [@data]
+
+          @diff      = nil
+        end
+      end
+    end
+  end
+end

data/lib/yzma.rb

@@ -0,0 +1,174 @@
+require 'rubygems'
+require 'kronk'
+
+##
+# Yzma bosses Kronk around to give you meaningful diff variation
+# statistical data:
+#   Yzma.report "My Report" do
+#     compare uri1, uri2, :count => 100 do
+#       randomize_param :limit, 20..200, :optional => true, :allow_blank => true
+#
+#       randomize_param :q, %w{pizza restaurant flowers}
+#
+#       randomize_param :g, %w{91106 91203}
+#     end
+#
+#     compare uri3, uri4, :count => 10,
+#                         :title => "Second Compare"
+#   end
+
+class Yzma
+
+  require 'yzma/report'
+  require 'yzma/randomizer'
+
+
+  ##
+  # Parses ARGV for Yzma.
+
+  def self.parse_args argv
+    options = {:files => []}
+
+    opts = OptionParser.new do |opt|
+      opt.program_name = File.basename $0
+      opt.version = Kronk::VERSION
+      opt.release = nil
+
+      opt.banner = <<-STR
+
+#{opt.program_name} #{opt.version}
+
+Run diff reports between two URI requests.
+
+  Usage:
+    #{opt.program_name} --help
+    #{opt.program_name} --version
+    #{opt.program_name} file1 [file2 ...]
+      STR
+    end
+
+    opts.parse! argv
+
+    options[:files] = argv.dup
+
+    if options[:files].empty?
+      $stderr << "\nError: At least one report file must be specified.\n"
+      $stderr << "See 'yzma --help' for usage\n\n"
+      exit 1
+    end
+
+    options
+  end
+
+
+  ##
+  # Construct and run an Yzma report.
+
+  def self.report name_or_report=nil, &block
+    yzma = new name_or_report
+
+    yzma.instance_eval(&block)
+
+    yzma.report.header << "Ran #{yzma.comparisons} URI comparison(s)"
+    yzma.report.header << "Iterated a total of #{yzma.iterations} case(s)"
+
+    curr_req = nil
+
+    yzma.report.write do |req, data|
+      next unless data[:diff] > 0
+      "\n#{data[:diff]} avg diffs:\n#{req[0]} - #{req[1]}\n"
+    end
+  end
+
+
+  ##
+  # Run the Yzma command.
+
+  def self.run argv=ARGV
+    options = parse_args argv
+    options[:files].each do |file|
+      self.instance_eval File.read(file)
+    end
+
+    exit 2 if self.diffs > 0
+  end
+
+
+  class << self
+    attr_accessor :diffs
+  end
+
+  self.diffs = 0
+
+
+  attr_reader :report, :comparisons, :iterations
+
+  ##
+  # Initialize Izma with optional name.
+
+  def initialize name_or_report=nil
+    case name_or_report
+    when String
+      @name   = name_or_report
+      @report = Report.new @name
+
+    when Report
+      @report = name_or_report
+      @name   = @report.name
+
+    else
+      @name   = 'Yzma Report'
+      @report = Report.new @name
+    end
+
+    @comparisons = 0
+    @iterations  = 0
+  end
+
+
+  ##
+  # Compare two paths or uris. Second uri may be omitted.
+  # Supports all Kronk.compare options, plus:
+  # :count:: Integer - number of times to run the endpoint; default 1.
+  # :title:: String - title to display when running compares.
+
+  def compare uri1, uri2, options={}, &block
+    options = options.dup
+    count   = options.delete(:count) || 1
+    title   = options.delete(:title)  || "#{uri1} --- #{uri2}"
+
+    @comparisons = @comparisons.next
+
+    diff_avg = 0
+    diff_cnt = 0
+
+    puts title
+    1.upto(count) do |i|
+      randomizer = Randomizer.new
+      randomizer.instance_eval &block if block_given?
+
+      randomized_opts = options.merge randomizer.to_options
+
+      begin
+        diff = Kronk.compare uri1, uri2, randomized_opts
+
+        diff_avg = (diff_avg * diff_cnt + diff.count) / (diff_cnt + 1)
+        diff_cnt = diff_cnt.next
+
+        @iterations = @iterations.next
+
+        $stdout << (diff.count > 0 ? "D" : ".")
+        self.class.diffs = self.class.diffs + diff.count
+
+      rescue Kronk::Request::NotFoundError
+        $stdout << "E"
+      end
+
+      $stdout.flush
+    end
+
+    @report.add [uri1, uri2], :diff => diff_avg
+
+    $stdout << "\n\n"
+  end
+end