kronk 1.6.2 → 1.7.0

data/lib/kronk/cmd.rb

@@ -5,6 +5,23 @@ class Kronk
 
   class Cmd
 
+    ##
+    # Saves the raw http response to a cache file.
+
+    def self.cache_response resp, filepath=nil
+      filepath ||= Kronk.config[:cache_file]
+      return unless filepath
+
+      begin
+        File.open(filepath, "wb+") do |file|
+          file.write resp.raw
+        end
+      rescue => e
+        error "#{e.class}: #{e.message}"
+      end
+    end
+
+
     ##
     # Start an IRB console with the given Kronk::Response object.
 
@@ -26,6 +43,22 @@ class Kronk
     end
 
 
+    ##
+    # Try to load the config file. If not found, create the default one
+    # and exit.
+
+    def self.load_config_file
+      Kronk.load_config
+
+    rescue Errno::ENOENT
+      make_config_file
+      error "No config file was found.\n" +
+            "Created default config in #{DEFAULT_CONFIG_FILE}\n" +
+            "Edit file if necessary and try again.\n"
+      exit 2
+    end
+
+
     ##
     # Load the config-based requires.
 
@@ -48,7 +81,7 @@ class Kronk
 
 
     ##
-    # Parse ARGV
+    # Parse ARGV into options and Kronk config.
 
     def self.parse_args argv
       options = {
@@ -362,7 +395,7 @@ Parse and run diffs against data from live and cached http responses.
 
         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
+          options[:proxy][:host], options[:proxy][:port] = value.split ":", 2
         end
 
         opt.separator nil
@@ -372,6 +405,7 @@ Parse and run diffs against data from live and cached http responses.
 
       unless options[:player].empty?
         options[:player] = Player.new options[:player]
+        set_player_backend Kronk.config[:async]
       else
         options.delete :player
       end
@@ -393,7 +427,8 @@ Parse and run diffs against data from live and cached http responses.
 
       argv.clear
 
-      raise "You must enter at least one URI" if options[:uris].empty?
+      raise "You must enter at least one URI" if options[:uris].empty? &&
+                                                  options[:player].nil?
 
       options
 
@@ -409,16 +444,29 @@ Parse and run diffs against data from live and cached http responses.
     # Returns the array [only_paths, except_paths]
 
     def self.parse_data_path_args options, argv
-      return options unless argv.include? "--"
+      path_index = argv.index("--")
+      return options unless path_index && path_index < argv.length - 1
 
-      data_paths = argv.slice! argv.index("--")..-1
+      data_paths = argv.slice! path_index..-1
       data_paths.shift
 
+      options[:transform] = []
+
       data_paths.each do |path|
-        if path[0,1] == "-"
-          (options[:ignore_data] ||= []) << path[1..-1]
+        action, path = process_path path
+
+        # Merge identical actions into the same transaction action
+        if options[:transform][-1] && options[:transform][-1][0] == action
+          options[:transform][-1][1] << path
+
+        # Merge successive maps and selects together
+        elsif options[:transform][-1] &&
+          [options[:transform][-1][0], action, :map, :select].uniq.length == 2
+          options[:transform][-1][0] = :map
+          options[:transform][-1][1] << path
+
         else
-          (options[:only_data] ||= []) << path
+          options[:transform] << [action, [path]]
         end
       end
 
@@ -426,15 +474,34 @@ Parse and run diffs against data from live and cached http responses.
     end
 
 
+    ##
+    # Determine the cmd-given path's action and Kronk::Path representation.
+
+    def self.process_path path
+      case path
+      when /^-/
+        [:delete, path[1..-1]]
+      when /([^\\]>>)/
+        index = path.index $1
+        [:move, [path[0..index], path[index+3..-1]]]
+      when /([^\\]>)/
+        index = path.index $1
+        [:map, [path[0..index], path[index+2..-1]]]
+      else
+        [:select, path]
+      end
+    end
+
+
     ##
     # Ask the user for a password from stdin the command line.
 
     def self.query_password str=nil
       $stderr << "#{(str || "Password:")} "
-      system "stty -echo"
+      system "stty -echo" unless windows?
       password = $stdin.gets.chomp
     ensure
-      system "stty echo"
+      system "stty echo" unless windows?
       $stderr << "\n"
       password
     end
@@ -444,31 +511,14 @@ Parse and run diffs against data from live and cached http responses.
     # Runs the kronk command with the given terminal args.
 
     def self.run argv=ARGV
-      begin
-        Kronk.load_config
-
-      rescue Errno::ENOENT
-        make_config_file
-        error "No config file was found.\n" +
-              "Created default config in #{DEFAULT_CONFIG_FILE}\n" +
-              "Edit file if necessary and try again.\n"
-        exit 2
-      end
-
-      options = parse_args argv
+      load_config_file
 
       Kronk.load_cookie_jar
 
+      options = parse_args argv
       load_requires options.delete(:requires)
 
-      at_exit do
-        Kronk.save_cookie_jar
-        Kronk.save_history
-      end
-
-      trap 'INT' do
-        exit 2
-      end
+      set_exit_behavior
 
       uri1, uri2 = options.delete :uris
       runner     = options.delete(:player) || self
@@ -482,7 +532,7 @@ Parse and run diffs against data from live and cached http responses.
 
       exit 1 unless success
 
-    rescue Kronk::Exception, Response::MissingParser, Errno::ECONNRESET => e
+    rescue Kronk::Exception, Errno::ECONNRESET => e
       error e.message, e.backtrace
       exit 2
     end
@@ -503,13 +553,13 @@ Parse and run diffs against data from live and cached http responses.
 
     def self.request uri, options={}
       kronk = Kronk.new options
-      kronk.retrieve uri
+      kronk.request uri
       render kronk, options
     end
 
 
     ##
-    # Renders the results of a Kronk compare or retrieve
+    # Renders the results of a Kronk compare or request
     # to $stdout.
 
     def self.render kronk, options={}
@@ -557,24 +607,42 @@ Parse and run diffs against data from live and cached http responses.
 
 
     ##
-    # Saves the raw http response to a cache file.
+    # Set Player async state.
 
-    def self.cache_response resp, filepath=nil
-      filepath ||= Kronk.config[:cache_file]
-      return unless filepath
+    def self.set_player_backend async=false
+      return Kronk::Player.async = false unless
+        async == true || async.to_s == 'auto'
 
       begin
-        File.open(filepath, "wb+") do |file|
-          file.write resp.raw
-        end
-      rescue => e
-        error "#{e.class}: #{e.message}"
+        require 'kronk/async'
+        Kronk::Player.async = true
+
+      rescue LoadError => e
+        Kronk::Player.async = false
+
+        raise Kronk::Exception, "Async mode requires the em-http-request gem" if
+          async == true
+      end
+    end
+
+
+    ##
+    # Assign at_exit and trap :INT behavior.
+
+    def self.set_exit_behavior
+      at_exit do
+        Kronk.save_cookie_jar
+        Kronk.save_history
+      end
+
+      trap 'INT' do
+        exit 2
       end
     end
 
 
     ##
-    # Print and error string
+    # Print an error string
 
     def self.error str, more=nil
       $stderr.puts "\nError: #{str}"

data/lib/kronk/constants.rb

@@ -78,6 +78,7 @@ class Kronk
 
   # Default config to use.
   DEFAULT_CONFIG = {
+    :async          => 'auto',
     :content_types  => DEFAULT_CONTENT_TYPES.dup,
     :cache_file     => DEFAULT_CACHE_FILE,
     :context        => 3,

data/lib/kronk/core_ext.rb

@@ -11,7 +11,7 @@ class Kronk
 
     def has_path? path
       Kronk::Path.find path, self do |d,k,p|
-        return !!p
+        return true
       end
 
       false

data/lib/kronk/data_string.rb

@@ -0,0 +1,251 @@
+class Kronk
+
+  ##
+  # Creates ordered data string renders for diffing with character-precise
+  # path information.
+  #
+  #   dstr = DataString.new({'a' => 'foo', 'b' => 'bar', 'c' => ["one", "two"]})
+  #   # {
+  #   #  "a": "foo",
+  #   #  "b": "bar",
+  #   #  "c": [
+  #   #   "one",
+  #   #   "two"
+  #   #  ]
+  #   # }
+  #
+  #   dstr.meta[dstr.index("\"a\"")]
+  #   # /
+  #
+  #   dstr.meta[dstr.index("\"foo\"")]
+  #   # /a
+  #
+  #   dstr.meta[dstr.index("\"two\"")]
+  #   # /c/1
+
+  class DataString < String
+
+    TO_RUBY = proc do |type, obj|
+      case type
+      when :key_assign then " => "
+      when :key        then obj.inspect
+      when :value      then obj.inspect
+      when :struct
+        (obj == true || obj == false) ? "Boolean" : obj.class
+      end
+    end
+
+
+    TO_JSON = proc do |type, obj|
+      case type
+      when :key_assign then ": "
+      when :key
+        (Symbol === obj ? obj.inspect : obj.to_s).to_json
+      when :value
+        (Symbol === obj ? obj.inspect : obj).to_json
+      when :struct
+        ((obj == true || obj == false) ? "Boolean" : obj.class).to_json
+      end
+    end
+
+
+    ##
+    # Returns a ruby data string that is diff-able, meaning sorted by
+    # Hash keys when available.
+
+    def self.ruby data, opts={}
+      new(data, opts, &TO_RUBY)
+    end
+
+
+    ##
+    # Returns a json data string that is diff-able, meaning sorted by
+    # Hash keys when available.
+
+    def self.json data, opts={}
+      new(data, opts, &TO_JSON)
+    end
+
+
+    attr_accessor :data, :meta, :struct_only
+
+
+    ##
+    # Create a new DataString that is diff-able, meaning sorted by
+    # Hash keys when available.
+    #
+    # Options supported are:
+    # :indentation:: Integer - how many spaces to indent by; default 1
+    # :render_lang:: String - output to 'ruby' or 'json'; default 'json'
+    # :struct:: Boolean - class names used instead of values; default nil
+    #
+    # If block is given, will yield the type of object to render and
+    # an optional object to render. Types given are :key_assign, :key, :value,
+    # or :struct. By default DataString uses the TO_JSON proc.
+
+    def initialize data=nil, opts={}, &block
+      @struct_only = opts[:struct]
+      @indentation = opts[:indentation] || 1
+      @meta        = []
+
+      if String === data
+        super data
+        @data = nil
+
+      else
+        super ""
+        data    = Kronk::Path.pathed(data) if Kronk.config[:render_paths]
+        @data   = data
+        block ||= Kronk.config[:render_lang].to_s == 'ruby' ? TO_RUBY : TO_JSON
+      end
+
+      render data, &block if data && block
+    end
+
+
+    ##
+    # Turns a data set into an ordered string output for diff-ing.
+
+    def render data, path=[], &block
+      indent   = (path.length + 1) * @indentation
+      pad      = " " * indent
+
+      case data
+
+      when Hash
+        append("{}", path) and return if data.empty?
+        append "{\n", path
+
+        sort_any(data.keys).each_with_index do |key, i|
+          append "#{pad}#{ yield(:key, key) }#{ yield(:key_assign) }", path
+
+          value    = data[key]
+          new_path = path.dup << key
+          render value, new_path, &block
+
+          append(",", path) unless i == data.length - 1
+          append("\n", path)
+        end
+
+        append(("#{" " * (indent - @indentation)}}"), path)
+
+      when Array
+        append("[]", path) and return if data.empty?
+        append "[\n", path
+
+        (0...data.length).each do |key|
+          append pad, path
+
+          value    = data[key]
+          new_path = path.dup << key
+          render value, new_path, &block
+
+          append(",", path) unless key == data.length - 1
+          append("\n", path)
+        end
+
+        append(("#{" " * (indent - @indentation)}]"), path)
+
+      else
+        output = @struct_only ? yield(:struct, data) : yield(:value, data)
+        append output.to_s, path
+      end
+    end
+
+
+    alias append_arrow <<
+
+    ##
+    # Add a string with metadata to the data string.
+
+    def append str, metadata=nil
+      @meta.concat([metadata] * str.length)
+      self.append_arrow str
+    end
+
+    ##
+    # Similar to String#<< but adds metadata.
+
+    def << str
+      if str.class == self.class
+        @meta.concat str.meta
+      else
+        @meta.concat([@meta.last] * str.length)
+      end
+      super str
+    end
+
+
+    ##
+    # Similar to String#[] but keeps metadata.
+
+    def [] arg
+      dstr = self.class.new super
+      dstr.meta = @meta[arg]
+      dstr
+    end
+
+
+    ##
+    # Similar to String#split but keeps metadata.
+
+    def split pattern=$;, *more
+      arr      = super
+      i        = 0
+      interval = 0
+      interval = (self.length - arr.join.length) / (arr.length - 1) if
+        arr.length > 1
+
+      arr.map do |str|
+        ds = self.class.new str
+        ds.meta = @meta[i,str.length]
+        i += str.length + interval
+        ds
+      end
+    end
+
+
+    protected
+
+    ##
+    # Sorts an array of any combination of string, integer, or symbols.
+
+    def sort_any arr
+      i = 1
+      until i >= arr.length
+        j        = i-1
+        val      = arr[i]
+        prev_val = arr[j]
+
+        loop do
+          if smaller?(val, arr[j])
+            arr[j+1] = arr[j]
+            j = j - 1
+            break if j < 0
+
+          else
+            break
+          end
+        end
+
+        arr[j+1] = val
+
+        i = i.next
+      end
+
+      arr
+    end
+
+
+    CLASS_ORDER = {Fixnum => 2, String => 1, Symbol => 0}
+
+    ##
+    # Compares Numerics, Strings, and Symbols and returns true if the left
+    # side is 'smaller' than the right side.
+
+    def smaller? left, right
+      left.class == right.class && left.to_s < right.to_s ||
+        CLASS_ORDER[left.class] < CLASS_ORDER[right.class]
+    end
+  end
+end