kronk 1.2.5 → 1.3.0

data/History.rdoc

@@ -1,13 +1,41 @@
+=== 1.3.0 / 2011-06
+
+* Major Enhancements:
+
+  * Added auto-querying functionality with param randomizing.
+
+  * Added test helper methods, assertions, and core extensions.
+
+* Enhancements:
+
+  * Updated dependencies json ~>1.5, nokogiri ~>1.4, i18n >=0.5
+
+  * Reimplemented the diff logic to a LCS algorithm.
+
+  * Added support for ranges and 'index,length' pairs to DataSet path parsing.
+
+  * Moved kronk config files to the ~/.kronk folder.
+
+  * Made path matching case-insensitive.
+
+  * Deprecated and moved cmd functionality into Kronk::Cmd class.
+
+* Bugfixes:
+
+  * Fix for path lookup of parents when parent is the root data object.
+
+  * Handling of reset connection errors.
+
 === 1.2.5 / 2011-03-09
 
 * Bugfixes:
 
   * Small fix to the diff functionality.
-    Swapping left and right would not always yeild the same behavior.
+    Swapping left and right would not always yield the same behavior.
 
 === 1.2.4 / 2011-03-04
 
-* Enhancements:
+* Bugfixes:
 
   * Cleaner exit on sigint.
 

data/Manifest.txt

@@ -4,13 +4,24 @@ Manifest.txt
 README.rdoc
 Rakefile
 bin/kronk
+bin/yzma
 lib/kronk.rb
+lib/kronk/cmd.rb
 lib/kronk/data_set.rb
 lib/kronk/diff.rb
+lib/kronk/diff/ascii_format.rb
+lib/kronk/diff/color_format.rb
 lib/kronk/plist_parser.rb
 lib/kronk/request.rb
 lib/kronk/response.rb
+lib/kronk/test.rb
+lib/kronk/test/assertions.rb
+lib/kronk/test/core_ext.rb
+lib/kronk/test/helper_methods.rb
 lib/kronk/xml_parser.rb
+lib/yzma.rb
+lib/yzma/randomizer.rb
+lib/yzma/report.rb
 script/kronk_completion
 test/mocks/200_response.json
 test/mocks/200_response.plist
@@ -18,6 +29,9 @@ test/mocks/200_response.txt
 test/mocks/200_response.xml
 test/mocks/301_response.txt
 test/mocks/302_response.txt
+test/test_assertions.rb
+test/test_core_ext.rb
+test/test_helper_methods.rb
 test/test_data_set.rb
 test/test_diff.rb
 test/test_helper.rb

data/README.rdoc

@@ -11,8 +11,6 @@ Kronk was made possible by the sponsoring of AT&T Interactive.
 
 * Parse and display or diff data from http response body and/or headers.
 
-* Follow redirects automatically.
-
 * Include or exclude specific data points with file-glob-like paths.
 
 * Supports json, rails-ish xml, and plist.
@@ -27,13 +25,13 @@ Kronk was made possible by the sponsoring of AT&T Interactive.
 
 * Easy-to-read output (color or ascii, line numbers, etc).
 
-* Yes, it works on Windows.
+* URI-specific configuration.
 
-== FUTURE:
+* Helper methods for test suites.
 
-* Auto-queryer with optional param randomizing.
+* Auto-query reports with request randomization support.
 
-* Support for test suites.
+* Yes, it works on Windows.
 
 == SYNOPSIS:
 
@@ -246,7 +244,7 @@ single quotes around some of your paths.
 
 == INSTALL:
 
-  $ sudo gem install kronk
+  $ gem install kronk
 
 == DEVELOPERS:
 

data/Rakefile

@@ -3,7 +3,18 @@
 require 'rubygems'
 require 'hoe'
 
-Hoe.plugin :isolate
+
+if ENV['version']
+  gem 'kronk', ENV['version']
+else
+  $: << "lib"
+  Hoe.plugin :isolate
+end
+
+require 'kronk'
+
+puts "kronk-#{Kronk::VERSION}"
+
 
 Hoe.spec 'kronk' do
   developer('Jeremie Castagna', 'yaksnrainbows@gmail.com')
@@ -12,9 +23,9 @@ Hoe.spec 'kronk' do
   self.extra_rdoc_files = FileList['*.rdoc']
 
   self.extra_deps << ['plist',         '~>3.1.0']
-  self.extra_deps << ['json',          '~>1.2']
-  self.extra_deps << ['nokogiri',      '~>1.3']
-  self.extra_deps << ['i18n',          '~>0.5']
+  self.extra_deps << ['json',          '~>1.5']
+  self.extra_deps << ['nokogiri',      '~>1.4']
+  self.extra_deps << ['i18n',          '>=0.5']
   self.extra_deps << ['activesupport', '>=2.0.0']
   self.extra_deps << ['cookiejar',     '~>0.3.0']
   self.extra_deps << ['rack',          '~>1.0']
@@ -22,4 +33,77 @@ Hoe.spec 'kronk' do
   self.extra_dev_deps << ['mocha', '~>0.9.10']
 end
 
+
+class Object
+
+  BENCHMARKS = {}
+
+  def bm name=nil
+    start = Time.now
+    yield
+    span = Time.now - start
+
+    if BENCHMARKS[name]
+      t = BENCHMARKS[name][:time]
+      w = BENCHMARKS[name][:weight]
+
+      t = t + span
+      w += 1
+
+      BENCHMARKS[name] = {:time => t, :weight => w}
+    else
+      BENCHMARKS[name] = {:time => span, :weight => 1}
+    end
+  end
+end
+
+
+def benchmark num=1000
+  start = Time.now
+
+  num.times do
+    yield
+  end
+
+  puts "Ran #{num} times: #{(Time.now - start).to_f / num}"
+end
+
+
+namespace :bm do
+
+  desc "Run performance benchmarks on diff and parsing"
+  task :full do
+
+    benchmark(100) do
+      Kronk.compare("prod.txt", "beta.txt").count
+    end
+  end
+
+
+  desc "Run performance benchmarks on diffs"
+  task :diff do
+    left = Kronk::Request.retrieve("prod.txt").parsed_body
+    right = Kronk::Request.retrieve("beta.txt").parsed_body
+
+    diff = Kronk::Diff.new_from_data left, right
+
+    arr1 = diff.str1.split "\n"
+    arr2 = diff.str2.split "\n"
+
+    benchmark(100) do
+      #arr1.each{|i| 0.upto(5){|j| foo = j+123}}
+      #arr2.each{|i| foo = 'foobar'}
+      #arr2.each{|i| i == 'foobar'}
+      diff.create_diff
+      #diff.common_sequences arr1, arr2
+      #diff.find_common arr1, arr2
+      #`diff prod.txt beta.txt`
+    end
+
+    Object::BENCHMARKS.each do |name, bm|
+      puts "#{name} (#{bm[:weight]/100}): #{bm[:time] / 100}"
+    end rescue nil
+  end
+end
+
 # vim: syntax=ruby

data/bin/kronk

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 
+  $: << File.join(File.dirname(__FILE__), "../lib")
 begin
   require 'kronk'
 
@@ -10,4 +11,4 @@ rescue LoadError => e
   require 'kronk'
 end
 
-Kronk.run
+Kronk::Cmd.run

data/bin/yzma

@@ -0,0 +1,13 @@
+#!/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.rb

@@ -11,18 +11,13 @@ require 'yaml'
 class Kronk
 
   # This gem's version.
-  VERSION = '1.2.5'
-
-
-  ##
-  # Returns true if kronk is running on ruby for windows.
-
-  def self.windows?
-    !!(RUBY_PLATFORM.downcase =~ /mswin|mingw|cygwin/)
-  end
+  VERSION = '1.3.0'
 
 
+  require 'kronk/cmd'
   require 'kronk/data_set'
+  require 'kronk/diff/ascii_format'
+  require 'kronk/diff/color_format'
   require 'kronk/diff'
   require 'kronk/response'
   require 'kronk/request'
@@ -30,20 +25,20 @@ class Kronk
   require 'kronk/xml_parser'
 
 
-  # Default config file to load. Defaults to ~/.kronk.
-  DEFAULT_CONFIG_FILE = File.expand_path "~/.kronk"
+  # Config directory.
+  CONFIG_DIR = File.expand_path "~/.kronk"
 
+  # Default config file to load. Defaults to ~/.kronk.
+  DEFAULT_CONFIG_FILE = File.join CONFIG_DIR, "rc"
 
   # Default cache file.
-  DEFAULT_CACHE_FILE = File.expand_path "~/.kronk_cache"
-
+  DEFAULT_CACHE_FILE = File.join CONFIG_DIR, "cache"
 
   # Default cookies file.
-  DEFAULT_COOKIES_FILE = File.expand_path "~/.kronk_cookies"
-
+  DEFAULT_COOKIES_FILE = File.join CONFIG_DIR, "cookies"
 
   # Default file with history of unique URIs. (Used for autocomplete)
-  DEFAULT_HISTORY_FILE = File.expand_path "~/.kronk_history"
+  DEFAULT_HISTORY_FILE = File.join CONFIG_DIR, "history"
 
 
   # Default Content-Type header to parser mapping.
@@ -141,42 +136,12 @@ class Kronk
   ##
   # 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.make_config_file
+    Dir.mkdir CONFIG_DIR unless File.directory? CONFIG_DIR
 
-  def self.find_const namespace
-    consts = namespace.to_s.split "::"
-    curr = self
-
-    until consts.empty? do
-      curr = curr.const_get consts.shift
+    File.open DEFAULT_CONFIG_FILE, "w+" do |file|
+      file << DEFAULT_CONFIG.to_yaml
     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}([^\w]|$)}) && value
-      end.to_a
-
-    return if parser_pair.empty?
-
-    parser = parser_pair[0][1]
-    parser = find_const parser if String === parser || Symbol === parser
-    parser
   end
 
 
@@ -186,14 +151,14 @@ class Kronk
   # Returns cmd_opts Hash if none found.
 
   def self.merge_options_for_uri uri, cmd_opts={}
-    return cmd_opts if config[:no_uri_options]
+    return cmd_opts if Kronk.config[:no_uri_options]
 
     out_opts = Hash.new.merge cmd_opts
 
-    config[:uri_options].each do |matcher, options|
-      next unless (uri == matcher || uri =~ %r{#{matcher}}) && Hash === options
+    Kronk.config[:uri_options].each do |matcher, opts|
+      next unless (uri == matcher || uri =~ %r{#{matcher}}) && Hash === opts
 
-      options.each do |key, val|
+      opts.each do |key, val|
         if !out_opts[key]
           out_opts[key] = val
           next
@@ -245,39 +210,34 @@ class Kronk
 
 
   ##
-  # Ask the user for a password from stdinthe command line.
-
-  def self.query_password str=nil
-    $stderr << "#{(str || "Password:")} "
-    system "stty -echo"
-    password = $stdin.gets.chomp
-  ensure
-    system "stty echo"
-    $stderr << "\n"
-    password
-  end
+  # Find a fully qualified ruby namespace/constant.
 
+  def self.find_const namespace
+    consts = namespace.to_s.split "::"
+    curr = self
 
-  ##
-  # Load the saved cookies file.
+    until consts.empty? do
+      curr = curr.const_get consts.shift
+    end
 
-  def self.load_cookie_jar file=nil
-    file ||= config[:cookies_file]
-    @cookie_jar = YAML.load_file file if File.file? file
-    @cookie_jar ||= CookieJar::Jar.new
-    @cookie_jar.expire_cookies
-    @cookie_jar
+    curr
   end
 
 
   ##
-  # Save the cookie jar to file.
+  # Returns the config-defined parser class for a given content type.
 
-  def self.save_cookie_jar file=nil
-    file ||= config[:cookies_file]
-    File.open(file, "w") do |f|
-      f.write @cookie_jar.to_yaml
-    end
+  def self.parser_for content_type
+    parser_pair =
+      config[:content_types].select do |key, value|
+        (content_type =~ %r{#{key}([^\w]|$)}) && value
+      end.to_a
+
+    return if parser_pair.empty?
+
+    parser = parser_pair[0][1]
+    parser = find_const parser if String === parser || Symbol === parser
+    parser
   end
 
 
@@ -298,6 +258,29 @@ class Kronk
   end
 
 
+  ##
+  # Load the saved cookies file.
+
+  def self.load_cookie_jar file=nil
+    file ||= config[:cookies_file]
+    @cookie_jar = YAML.load_file file if File.file? file
+    @cookie_jar ||= CookieJar::Jar.new
+    @cookie_jar.expire_cookies
+    @cookie_jar
+  end
+
+
+  ##
+  # Save the cookie jar to file.
+
+  def self.save_cookie_jar file=nil
+    file ||= config[:cookies_file]
+    File.open(file, "w") do |f|
+      f.write @cookie_jar.to_yaml
+    end
+  end
+
+
   ##
   # Returns the Kronk history array of accessed URLs.
 
@@ -313,8 +296,10 @@ class Kronk
   # Writes the URL history to the history file.
 
   def self.save_history
+    history_str = self.history.uniq.join($/)
+
     File.open self.config[:history_file], "w" do |file|
-      file.write self.history.uniq.join($/)
+      file.write history_str
     end
   end
 
@@ -372,397 +357,94 @@ class Kronk
         Diff.ordered_data_string data, options[:struct]
 
       rescue Response::MissingParser
-        verbose "Warning: No parser for #{resp['Content-Type']} [#{uri}]"
+        Cmd.warn "No parser for #{resp['Content-Type']} [#{uri}]"
         resp.selective_string options
       end
     end
   end
 
 
+  ###
+  # Deprecated methods...
+  ###
 
-  ##
-  # Start an IRB console with the given http response object.
-
-  def self.irb resp
-    require 'irb'
-
-    $http_response = resp
-    $response = begin
-                  resp.parsed_body
-                rescue Response::MissingParser
-                  resp.body
-                end
 
-    puts "\nHTTP Response is in $http_response"
-    puts "Response data is in $response\n\n"
+  def self.deprecated method_name, replacement=nil
+    replacement &&= ", use #{replacement}"
+    replacement ||= " with no replacement"
 
-    IRB.start
-    exit 1
+    Cmd.warn "#{method_name} deprecated#{replacement}"
   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 2
-    end
-
-    load_cookie_jar
+  # Deprecated! Use Kronk::Cmd::irb
 
-    options = parse_args argv
-
-    load_requires options[:requires]
-
-    at_exit do
-      save_cookie_jar
-      save_history
-    end
-
-    trap 'INT' do
-      exit 2
-    end
-
-
-    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}\n" unless config[:brief]
-
-      if config[:verbose] || config[:brief]
-        $stdout << "Found #{diff.count} diff(s).\n"
-      end
+  def self.irb resp
+    deprecated "Kronk::irb", "Kronk::Cmd::irb"
+    Cmd.irb resp
+  end
 
-      exit 1 if diff.count > 0
 
-    else
-      out = retrieve_data_string uri1, options
-      out = Diff.insert_line_nums out if config[:show_lines]
-      puts out
-    end
+  ##
+  # Deprecated! Use Kronk::Cmd::move_config_file
 
-  rescue Request::Exception, Response::MissingParser => e
-    $stderr << "\nError: #{e.message}\n"
-    exit 2
+  def self.move_config_file
+    deprecated "Kronk::move_config_file", "Kronk::Cmd::move_config_file"
+    Cmd.move_config_file
   end
 
 
   ##
-  # Print string only if verbose
+  # Deprecated! Use Kronk::Cmd::query_password
 
-  def self.verbose str
-    $stdout << "#{str}\n" if config[:verbose]
+  def self.query_password str=nil
+    deprecated "Kronk::query_password", "Kronk::Cmd::query_password"
+    Cmd.query_password str
   end
 
 
   ##
-  # Parse ARGV
+  # Deprecated! Use Kronk::Cmd::parse_args
 
   def self.parse_args argv
-    options = {
-      :auth           => {},
-      :no_body        => false,
-      :proxy          => {},
-      :uris           => [],
-      :with_headers   => false
-    }
-
-    options = parse_data_path_args options, argv
-
-    opts = OptionParser.new do |opt|
-      opt.program_name = File.basename $0
-      opt.version = VERSION
-      opt.release = nil
-
-      opt.banner = <<-STR
-
-#{opt.program_name} #{opt.version}
-
-Parse and run 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.
-  If the data paths start with a ":" the parent of the matched data is used.
-  The ':' and '-' modifiers may be used together in that order (':-').
-
-  Options:
-      STR
-
-      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('--completion', 'Print bash completion file path and exit') do
-        file = File.join(File.dirname(__FILE__), "../script/kronk_completion")
-        puts File.expand_path(file)
-        exit 2
-      end
-
-
-      opt.on('--config STR', String,
-             'Load the given Kronk config file') do |value|
-        load_config value
-      end
-
-
-      opt.on('-q', '--brief', 'Output only whether URI responses differ') do
-        config[:brief] = true
-      end
-
-
-      opt.on('--format STR', String,
-             'Use a custom diff formatter') do |value|
-        config[:diff_format] = 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('--irb', 'Start an IRB console') do
-        options[:irb] = true
-      end
-
-
-      opt.on('--lines', 'Show line numbers') do
-        config[:show_lines] = true
-      end
-
-
-      opt.on('--no-opts', 'Turn off config URI options') do
-        config[:no_uri_options] = true
-      end
-
-
-      opt.on('--parser STR', String,
-             'Override default parser') do |value|
-        options[:parser] = value
-      end
-
-
-      opt.on('--prev', 'Use last response to diff against') do
-        options[:uris].unshift :cache
-      end
-
-
-      opt.on('--raw', 'Run diff on the raw data returned') do
-        options[:raw] = true
-      end
-
-
-      opt.on('-r', '--require lib1,lib2', Array,
-             'Require a library or gem') do |value|
-        options[:requires] ||= []
-        options[:requires].concat value
-      end
-
-
-      opt.on('--struct', 'Run diff on the data structure') do
-        options[:struct] = true
-      end
-
-
-      opt.on('-V', '--verbose', 'Make the operation more talkative') do
-        config[:verbose] = true
-      end
-
-
-      opt.separator <<-STR
-
-  HTTP Options:
-      STR
-
-      opt.on('--clear-cookies', 'Delete all saved cookies') do
-        clear_cookies!
-      end
-
-
-      opt.on('-d', '--data STR', String,
-             'Post data with the request') do |value|
-        options[:data] = value
-        options[:http_method] ||= 'POST'
-      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.strip
-      end
-
-
-      opt.on('-A', '--user-agent STR', String,
-             'User-Agent to send to server or a valid alias') do |value|
-        options[:user_agent] = value
-      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('--no-cookies', 'Don\'t use cookies for this session') do
-        options[:no_cookies] = true
-      end
-
-
-      opt.on('-?', '--query STR', String,
-             'Append query to URLs') do |value|
-        options[:query] = value
-      end
-
-
-      opt.on('--suff STR', String,
-             'Add common path items to the end of each URL') do |value|
-        options[:uri_suffix] = value
-      end
-
-
-      opt.on('--timeout INT', Integer,
-             'Timeout for http connection in seconds') do |value|
-        config[:timeout] = value
-      end
-
-
-      opt.on('-U', '--proxy-user STR', String,
-             'Set proxy user and/or password: usr[:pass]') do |value|
-        options[:proxy][:username], options[:proxy][:password] =
-          value.split ":", 2
-
-        options[:proxy][:password] ||= query_password "Proxy password:"
-      end
-
-
-      opt.on('-u', '--user STR', String,
-             'Set server auth user and/or password: usr[:pass]') do |value|
-        options[:auth][:username], options[:auth][:password] =
-          value.split ":", 2
-
-        options[:auth][:password] ||= query_password "Server password:"
-      end
-
-
-      opt.on('-X', '--request STR', String,
-             'The request method to use') do |value|
-        options[:http_method] = value
-      end
-
-
-      opt.on('-x', '--proxy STR', String,
-             'Use HTTP proxy on given port: host[:port]') do |value|
-        options[:proxy][:address], options[:proxy][:port] = value.split ":", 2
-      end
-
-      opt.separator nil
-    end
-
-    opts.parse! argv
-
-    unless $stdin.tty?
-      io = StringIO.new $stdin.read
-      options[:uris] << io
-    end
-
-    options[:uris].concat argv
-    options[:uris].slice!(2..-1)
-
-    argv.clear
+    deprecated "Kronk::parse_args", "Kronk::Cmd::parse_args"
+    Cmd.parse_args argv
+  end
 
-    raise OptionParser::MissingArgument, "You must enter at least one URI" if
-      options[:uris].empty?
 
-    options
+  ##
+  # Deprecated! Use Kronk::Cmd::parse_data_path_args
 
-  rescue => e
-    $stderr << "\nError: #{e.message}\n"
-    $stderr << "See 'kronk --help' for usage\n\n"
-    exit 1
+  def self.parse_data_path_args options, argv
+    deprecated "Kronk::parse_data_path_args", "Kronk::Cmd::parse_data_path_args"
+    Cmd.parse_data_path_args options, argv
   end
 
 
   ##
-  # Searches ARGV and returns data paths to add or exclude in the diff.
-  # Returns the array [only_paths, except_paths]
+  # Deprecated! Use Kronk::Cmd::run
 
-  def self.parse_data_path_args options, argv
-    return options unless argv.include? "--"
+  def self.run argv=ARGV
+    deprecated "Kronk::run", "Kronk::Cmd::run"
+    Cmd.run argv
+  end
 
-    data_paths = argv.slice! argv.index("--")..-1
-    data_paths.shift
 
-    data_paths.each do |path|
-      if path[0,1] == "-"
-        (options[:ignore_data] ||= []) << path[1..-1]
+  ##
+  # Deprecated! Use Kronk::Cmd::verbose
 
-      elsif path[0,2] == ":-"
-        (options[:ignore_data_with] ||= []) << path[2..-1]
+  def self.verbose str
+    deprecated "Kronk::verbose", "Kronk::Cmd::verbose"
+    Cmd.verbose str
+  end
 
-      elsif path[0,1] == ":"
-        (options[:only_data_with] ||= []) << path[1..-1]
 
-      else
-        (options[:only_data] ||= []) << path
-      end
-    end
+  ##
+  # Deprecated! Use Kronk::Cmd::windows?
 
-    options
+  def self.windows?
+    deprecated "Kronk::windows?", "Kronk::Cmd::windows?"
+    Cmd.windows?
   end
 end