kronk 1.4.0 → 1.5.0

data/bin/yzma

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

data/lib/kronk/data_set.rb

@@ -1,144 +0,0 @@
-class Kronk
-
-  ##
-  # THIS CLASS IS DEPRECATED AND WILL BE REMOVED IN KRONK-1.5.x
-  #
-  # Wraps a complex data structure to provide a search-driven interface.
-
-  class DataSet
-
-    # Deep merge proc for recursive Hash merging.
-    DEEP_MERGE =
-      proc do |key,v1,v2|
-        Hash === v1 && Hash === v2 ? v1.merge(v2,&DEEP_MERGE) : v2
-      end
-
-
-    attr_accessor :data
-
-    def initialize data
-      @data = data
-    end
-
-
-    ##
-    # Modify the data object by passing inclusive or exclusive data paths.
-    # Supports the following options:
-    # :only_data:: String/Array - keep data that matches the paths
-    # :ignore_data:: String/Array - remove data that matches the paths
-    #
-    # Deprecated options:
-    # :only_data_with:: String/Array - keep data with a matched child
-    # :ignore_data_with:: String/Array - remove data with a matched child
-    #
-    # Note: the data is processed in the following order:
-    # * only_data
-    # * ignore_data
-
-    def modify options
-      warn_path_deprecation! if options[:ignore_data_with] ||
-                                options[:only_data_with]
-
-      collect_data_points options[:only_data_with], true if
-        options[:only_data_with]
-
-      delete_data_points options[:ignore_data_with], true if
-        options[:ignore_data_with]
-
-      collect_data_points options[:only_data]  if options[:only_data]
-
-      delete_data_points options[:ignore_data] if options[:ignore_data]
-
-      @data
-    end
-
-
-    ##
-    # New implementation of DataSet#modify
-
-    def fetch options
-      warn_path_deprecation! if options[:ignore_data_with] ||
-                                options[:only_data_with]
-
-      options[:only_data]   = [*options[:only_data]].compact
-      options[:ignore_data] = [*options[:ignore_data]].compact
-
-      options[:only_data].concat(
-        [*options[:only_data_with]].map!{|path| path << "/.."}
-      ) if options[:only_data_with]
-
-      options[:ignore_data].concat(
-        [*options[:ignore_data_with]].map!{|path| path << "/.."}
-      ) if options[:ignore_data_with]
-
-      Path::Transaction.run @data, options do |t|
-        t.select(*options[:only_data])
-        t.delete(*options[:ignore_data])
-      end
-    end
-
-
-    ##
-    # Keep only specific data points from the data structure.
-
-    def collect_data_points data_paths, affect_parent=false
-      Kronk::Cmd.warn "DataSet#collect_data_points deprecated. "+
-                      "Use Path::Transaction"
-
-      new_data = @data.class.new
-
-      [*data_paths].each do |data_path|
-        opts = Path.parse_regex_opts! data_path
-        data_path << "/.." if affect_parent
-
-        Path.find data_path, @data, opts do |data, k, path|
-          curr_data     = @data
-          new_curr_data = new_data
-
-          path.each_with_index do |key, i|
-            if i == path.length - 1
-              new_curr_data[key]   = curr_data[key]
-            else
-              new_curr_data[key] ||= curr_data[key].class.new
-              new_curr_data        = new_curr_data[key]
-              curr_data            = curr_data[key]
-            end
-          end
-        end
-      end
-
-      @data.replace new_data
-    end
-
-
-    ##
-    # Remove specific data points from the data structure.
-
-    def delete_data_points data_paths, affect_parent=false
-      Kronk::Cmd.warn "DataSet#delete_data_points deprecated. "+
-                      "Use Path::Transaction"
-
-      [*data_paths].each do |data_path|
-        opts = Path.parse_regex_opts! data_path
-        data_path << "/.." if affect_parent
-
-        Path.find data_path, @data, opts do |obj, k, path|
-          next unless obj.respond_to? :[]
-
-          del_method = Array === obj ? :delete_at : :delete
-          obj.send del_method, k
-        end
-      end
-
-      @data
-    end
-
-
-    private
-
-    def warn_path_deprecation!
-      Kronk::Cmd.warn "The :ignore_data_with and :only_data_with options "+
-                      "are deprecated. Use the '/..' path notation."
-    end
-  end
-end

data/lib/yzma.rb

@@ -1,174 +0,0 @@
-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

data/lib/yzma/randomizer.rb

@@ -1,54 +0,0 @@
-class Yzma
-
-  ##
-  # Randomizes params, data, and headers for Yzma requests.
-
-  class Randomizer
-
-    def initialize
-      @options = {}
-    end
-
-
-    def to_options
-      @options.dup
-    end
-
-
-    def randomize_param name, values, options={}
-      @options[:query] ||= {}
-      assign_random @options[:query], name, values, options
-    end
-
-
-    def randomize_data name, values, options={}
-      @options[:data] ||= {}
-      assign_random @options[:data], name, values, options
-    end
-
-
-    def randomize_header name, values, options={}
-      @options[:headers] ||= {}
-      assign_random @options[:headers], name, values, options
-    end
-
-
-    def assign_random obj, key, values, options={}
-      random_value = pick_random values, options
-      obj[key] = random_value if random_value
-    end
-
-
-    def pick_random val, options={}
-      val = File.readlines val if String === val
-      val = val.to_a           if Range === val
-
-      val << ""  if options[:allow_blank]
-      val << nil if options[:optional]
-
-      return if val.empty?
-
-      val[rand(val.length)]
-    end
-  end
-end

data/lib/yzma/report.rb

@@ -1,47 +0,0 @@
-class Yzma
-
-  ##
-  # Used to build and display Yzma reports.
-  # Other report types can be created by inheriting this class and
-  # overridding the 'write' method to use @data as desired.
-
-  class Report
-
-    attr_accessor :data, :header, :footer, :name
-
-    def initialize name
-      @name = name
-      @data = []
-      @header = ["#{@name} #{Time.now}"]
-      @footer = ["\n"]
-    end
-
-
-    ##
-    # Adds data and a related piece of data identification to
-    # the report.
-
-    def add identifier, data
-      @data << [identifier, data]
-    end
-
-
-    ##
-    # Generates and writes the report to the given IO instance.
-    # Defaults to STDOUT.
-
-    def write io=$stdout
-      io << @header.join("\n")
-
-      @data.each do |identifier, data|
-        if block_given?
-          io << yield(identifier, data)
-        else
-          io << "\n#{identifier.inspect}\n#{data.inspect}\n"
-        end
-      end
-
-      io << @footer.join("\n")
-    end
-  end
-end

data/test/test_data_set.rb

@@ -1,213 +0,0 @@
-require 'test/test_helper'
-
-class TestDataSet < Test::Unit::TestCase
-
-  def setup
-    @data = {
-      :key1 => {
-        :key1a => [
-          "foo",
-          "bar",
-          "foobar",
-          {:findme => "thing"}
-        ],
-        'key1b' => "findme"
-      },
-      'findme' => [
-        123,
-        456,
-        {:findme => 123456}
-      ],
-      :key2 => "foobar",
-      :key3 => {
-        :key3a => ["val1", "val2", "val3"]
-      }
-    }
-
-    @dataset = Kronk::DataSet.new @data
-
-    @dataset_mock = Kronk::DataSet.new mock_data
-
-    Kronk::Cmd.expects :warn
-  end
-
-
-  def test_modify_only_data
-    data = @dataset_mock.modify :only_data => "subs/1"
-    assert_equal({"subs" => [nil, "b"]}, data)
-  end
-
-
-  def test_modify_ignore_data
-    data = @dataset_mock.modify :ignore_data => "subs/1"
-
-    expected = mock_data
-    expected['subs'].delete_at 1
-
-    assert_equal expected, data
-  end
-
-
-  def test_modify_only_data_with
-    Kronk::Cmd.expects :warn
-    data = @dataset_mock.modify :only_data_with => "subs/1"
-    assert_equal({"subs" => ["a", "b"]}, data)
-  end
-
-
-  def test_modify_only_and_ignored_data
-    Kronk::Cmd.expects :warn
-    data = @dataset_mock.modify :ignore_data => "subs/1", :only_data => "subs/1"
-    assert_equal({"subs" => [nil]}, data)
-  end
-
-
-  def test_collect_data_points_affect_parent_array
-    data = @dataset_mock.collect_data_points "**=(A|a)?", true
-
-    expected = {
-      "root" => [nil, ["A1", "A2"]],
-      "subs" => ["a", "b"]
-    }
-
-    assert_equal expected, data
-  end
-
-
-  def test_collect_data_points_affect_parent_hash
-    data = @dataset_mock.collect_data_points "**=bar?", true
-    assert_equal({"tests"=>{:foo=>:bar, "test"=>[[1, 2], 2.123]}}, data)
-  end
-
-
-  def test_collect_data_points_single
-    data = @dataset_mock.collect_data_points "subs/1"
-    assert_equal({"subs" => [nil, "b"]}, data)
-  end
-
-
-  def test_collect_data_points_single_wildcard
-    data = @dataset_mock.collect_data_points "root/*/tests"
-    assert_equal({"root"=>[nil, nil, nil, {:tests=>["D3a", "D3b"]}]}, data)
-  end
-
-
-  def test_collect_data_points_recursive_wildcard
-    data = @dataset_mock.collect_data_points "**/test?"
-
-    expected = {
-      "tests"=>{:foo=>:bar, "test"=>[[1, 2], 2.123]},
-      "root"=>[nil, nil, nil, {
-        :tests=>["D3a", "D3b"],
-        "test"=>[["D1a\nContent goes here", "D1b"], "D2"]}]
-    }
-
-    assert_equal expected, data
-  end
-
-
-  def test_collect_data_points_recursive_wildcard_value
-    data = @dataset_mock.collect_data_points "**=(A|a)?"
-
-    expected = {
-      "root" => [nil, ["A1", "A2"]],
-      "subs" => ["a"]
-    }
-
-    assert_equal expected, data
-  end
-
-
-  def test_delete_data_points_affect_parent_array
-    data = @dataset_mock.delete_data_points "**/test/0/*", true
-
-    expected = mock_data
-    expected['root'][3]['test'].delete_at 0
-    expected['tests']['test'].delete_at 0
-
-    assert_equal expected, data
-  end
-
-
-  def test_delete_data_points_affect_parent_array_value
-    data = @dataset_mock.delete_data_points "**/test/0/*=D*", true
-
-    expected = mock_data
-    expected['root'][3]['test'].delete_at 0
-
-    assert_equal expected, data
-  end
-
-
-  def test_delete_data_points_affect_parent_hash
-    data = @dataset_mock.delete_data_points "subs/1", true
-
-    expected = mock_data
-    expected.delete 'subs'
-
-    assert_equal expected, data
-  end
-
-
-  def test_delete_data_points_affect_parent_hash_value
-    data = @dataset_mock.delete_data_points "**/*=a", true
-
-    expected = mock_data
-    expected.delete 'subs'
-
-    assert_equal expected, data
-  end
-
-
-  def test_delete_data_points_single
-    data = @dataset_mock.delete_data_points "subs/1"
-
-    expected = mock_data
-    expected['subs'].delete_at 1
-
-    assert_equal expected, data
-  end
-
-
-  def test_delete_data_points_single_wildcard
-    data = @dataset_mock.delete_data_points "root/*/tests"
-
-    expected = mock_data
-    expected['root'][3].delete :tests
-
-    assert_equal expected, data
-  end
-
-
-  def test_delete_data_points_single_wildcard_qmark
-    data = @dataset_mock.delete_data_points "subs/?"
-
-    expected = mock_data
-    expected['subs'].clear
-
-    assert_equal expected, data
-  end
-
-
-  def test_delete_data_points_recursive_wildcard
-    data = @dataset_mock.delete_data_points "**/test?"
-
-    expected = mock_data
-    expected['root'][3].delete :tests
-    expected['root'][3].delete 'test'
-    expected.delete "tests"
-
-    assert_equal expected, data
-  end
-
-
-  def test_delete_data_points_recursive_wildcard_value
-    data = @dataset_mock.delete_data_points "**=A?|a?"
-
-    expected = mock_data
-    expected['root'][1].clear
-    expected['subs'] = ["b"]
-
-    assert_equal expected, data
-  end
-end