kronk 1.3.1 → 1.4.0

data/lib/kronk/path/transaction.rb

@@ -0,0 +1,204 @@
+##
+# Path Transactions are a convenient way to apply selections and deletions
+# to complex data structures without having to know what state the data will
+# be in after each operation.
+#
+#   data = [
+#     {:name => "Jamie", :id => "12345"},
+#     {:name => "Adam",  :id => "54321"},
+#     {:name => "Kari",  :id => "12345"},
+#     {:name => "Grant", :id => "12345"},
+#     {:name => "Tory",  :id => "12345"},
+#   ]
+#
+#   # Select all element names but delete the one at index 2
+#   Transaction.run data do |t|
+#     t.select "*/name"
+#     t.delete "2"
+#   end
+#
+#   # => [
+#   #  {:name => "Jamie"},
+#   #  {:name => "Adam"},
+#   #  {:name => "Grant"},
+#   #  {:name => "Tory"},
+#   # ]
+
+class Kronk::Path::Transaction
+
+  ##
+  # Create new Transaction instance and run it with a block.
+  # Equivalent to:
+  #   Transaction.new(data).run(opts)
+
+  def self.run data, opts={}, &block
+    new(data).run opts, &block
+  end
+
+
+  ##
+  # Create a new Transaction instance with a the data object to perform
+  # operations on.
+
+  def initialize data
+    @data    = data
+    @actions = Hash.new{|h,k| h[k] = []}
+
+    @make_array = []
+  end
+
+
+  ##
+  # Run operations as a transaction.
+  # See Transaction#results for supported options.
+
+  def run opts={}, &block
+    clear
+    yield self if block_given?
+    results opts
+  end
+
+
+  ##
+  # Returns the results of the transaction operations.
+  # To keep the original indicies of modified arrays, and return them as hashes,
+  # pass the :keep_indicies => true option.
+
+  def results opts={}
+    new_data = transaction_select @data, *@actions[:select]
+    new_data = transaction_delete new_data, *@actions[:delete]
+    new_data = remake_arrays new_data, opts[:keep_indicies]
+    new_data
+  end
+
+
+  def remake_arrays new_data, except_modified=false # :nodoc:
+    @make_array.each do |path_arr|
+      key  = path_arr.last
+      obj = Kronk::Path.data_at_path path_arr[0..-2], new_data
+
+      next unless Hash === obj[key]
+      next if except_modified &&
+        obj[key].length !=
+          Kronk::Path.data_at_path(path_arr, @data).length
+
+      obj[key] = hash_to_ary obj[key]
+    end
+
+    new_data = hash_to_ary new_data if
+      Array === @data && Hash === new_data &&
+      (!except_modified || @data.length == new_data.length)
+
+    new_data
+  end
+
+
+  def transaction_select data, *data_paths # :nodoc:
+    return data if data_paths.empty?
+
+    new_data = Hash.new
+
+    data_paths.each do |data_path|
+      Kronk::Path.find data_path, data do |obj, 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] ||= Hash.new
+
+            # Tag data item for conversion to Array.
+            # Hashes are used to conserve position of Array elements.
+            if Array === curr_data[key]
+              @make_array << path[0..i]
+            end
+
+            new_curr_data = new_curr_data[key]
+            curr_data     = curr_data[key]
+          end
+        end
+      end
+    end
+
+    new_data
+  end
+
+
+  def transaction_delete data, *data_paths # :nodoc:
+    return data if data_paths.empty?
+
+    new_data = data.dup
+
+    if Array === new_data
+      new_data = ary_to_hash new_data
+    end
+
+    data_paths.each do |data_path|
+      Kronk::Path.find data_path, data do |obj, 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.delete key
+
+          else
+            new_curr_data[key] = curr_data[key].dup
+
+            if Array === new_curr_data[key]
+              new_curr_data[key] = ary_to_hash new_curr_data[key]
+              @make_array << path[0..i]
+            end
+
+            new_curr_data = new_curr_data[key]
+            curr_data     = curr_data[key]
+          end
+        end
+      end
+    end
+
+    new_data
+  end
+
+
+  def ary_to_hash ary # :nodoc:
+    hash = {}
+    ary.each_with_index{|val, i| hash[i] = val}
+    hash
+  end
+
+
+  def hash_to_ary hash # :nodoc:
+    hash.keys.sort.map{|k| hash[k] }
+  end
+
+
+  ##
+  # Clears the queued actions and cache.
+
+  def clear
+    @actions.clear
+    @make_array.clear
+  end
+
+
+  ##
+  # Queues path selects for transaction.
+
+  def select *paths
+    @actions[:select].concat paths
+  end
+
+
+  ##
+  # Queues path deletes for transaction.
+
+  def delete *paths
+    @actions[:delete].concat paths
+  end
+end

data/lib/kronk/request.rb

@@ -41,7 +41,7 @@ class Kronk
 
 
     ##
-    # Returns the value from a url, file, or cache as a String.
+    # Returns the value from a url, file, or IO as a String.
     # Options supported are:
     # :data:: Hash/String - the data to pass to the http request
     # :query:: Hash/String - the data to append to the http request path
@@ -55,7 +55,7 @@ class Kronk
     def self.retrieve uri, options={}
       if IO === uri || StringIO === uri
         resp = retrieve_io uri, options
-      elsif uri == :cache || File.file?(uri)
+      elsif File.file? uri
         resp = retrieve_file uri, options
       else
         resp = retrieve_uri uri, options
@@ -87,9 +87,7 @@ class Kronk
       Kronk::Cmd.verbose "Reading file:  #{path}\n"
 
       options = options.dup
-
-      path = Kronk::DEFAULT_CACHE_FILE if path == :cache
-      resp = nil
+      resp    = nil
 
       File.open(path, "rb") do |file|
 
@@ -324,6 +322,69 @@ class Kronk
     end
 
 
+    ##
+    # Parses a nested query. Stolen from Rack.
+
+    def self.parse_nested_query qs, d=nil
+      params = {}
+      d ||= "&;"
+
+      (qs || '').split(%r{[#{d}] *}n).each do |p|
+        k, v = CGI.unescape(p).split('=', 2)
+        normalize_params(params, k, v)
+      end
+
+      params
+    end
+
+
+    ##
+    # Stolen from Rack.
+
+    def self.normalize_params params, name, v=nil
+      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
+      k = $1 || ''
+      after = $' || ''
+
+      return if k.empty?
+
+      if after == ""
+        params[k] = v
+
+      elsif after == "[]"
+        params[k] ||= []
+        raise TypeError,
+          "expected Array (got #{params[k].class.name}) for param `#{k}'" unless
+            params[k].is_a?(Array)
+
+        params[k] << v
+
+      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
+        child_key = $1
+        params[k] ||= []
+        raise TypeError,
+          "expected Array (got #{params[k].class.name}) for param `#{k}'" unless
+            params[k].is_a?(Array)
+
+        if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
+          normalize_params(params[k].last, child_key, v)
+        else
+          params[k] << normalize_params({}, child_key, v)
+        end
+
+      else
+        params[k] ||= {}
+        raise TypeError,
+          "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless
+            params[k].is_a?(Hash)
+
+        params[k] = normalize_params(params[k], after, v)
+      end
+
+      return params
+    end
+
+
     ##
     # Allow any http method to be sent
 

data/lib/kronk/response.rb

@@ -226,7 +226,7 @@ class Kronk
           data = [parsed_header(options[:with_headers]), data].compact
         end
 
-        DataSet.new(data).modify options
+        DataSet.new(data).fetch options
       end
     end
   end

data/lib/kronk/test/assertions.rb

@@ -12,8 +12,7 @@ class Kronk
         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|
+        Kronk::Path.find path, data do |d,k,p|
           found = true
           break
         end
@@ -30,8 +29,7 @@ class Kronk
         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|
+        Kronk::Path.find path, data do |d,k,p|
           found = true
           break
         end
@@ -49,8 +47,7 @@ class Kronk
         last_data = nil
         found     = false
 
-        data_set = Kronk::DataSet.new data
-        data_set.find_data path do |d,k,p|
+        Kronk::Path.find path, data do |d,k,p|
           found     = true
           last_data = d[k]
           break if d[k] == match
@@ -71,8 +68,7 @@ class Kronk
       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|
+        Kronk::Path.find path, data do |d,k,p|
           last_data = d[k]
           break if d[k] == match
         end

data/lib/kronk/test/core_ext.rb

@@ -9,14 +9,14 @@ class Kronk
 
       ##
       # Checks if the given path exists and returns the first matching path
-      # as an array of keys. Returns nil if no path is found.
+      # as an array of keys. Returns false if no path is found.
 
       def has_path? path
-        Kronk::DataSet.new(self).find_data path do |d,k,p|
+        Kronk::Path.find path, self do |d,k,p|
           return !!p
         end
 
-        nil
+        false
       end
 
 
@@ -46,15 +46,63 @@ class Kronk
       #   # returns:
       #   # {[:foo] => "bar", [:foobar, 2, :foo] => "other bar"}
 
-      def find_data path
-        found = {}
+      def find_data path, &block
+        Kronk::Path.find path, self, &block
+      end
+
+
+      ##
+      # Finds and replaces the value of any match with the given new value.
+      # Returns true if matches were replaced, otherwise false.
+      #
+      #   data = {:foo => "bar", :foobar => [:a, :b, {:foo => "other bar"}, :c]}
+      #   data.replace_at_path "**=*bar", "BAR"
+      #   #=> true
+      #
+      #   data
+      #   #=> {:foo => "BAR", :foobar => [:a, :b, {:foo => "BAR"}, :c]}
+      #
+      # Note: Specifying a limit will allow only "limit" number of items to be
+      # set but may yield unpredictible results for non-ordered Hashes.
+      # It's also important to realize that arrays are modified starting with
+      # the last index, going down.
+
+      def replace_at_path path, value, limit=nil
+        count = 0
+
+        Kronk::Path.find path, self do |data, key, path_arr|
+          count     = count.next
+          data[key] = value
+
+          return true if limit && count >= limit
+        end
+
+        return count > 0
+      end
+
+
+      ##
+      # Similar to DataExt#replace_at_path but deletes found items.
+      # Returns a hash of path/value pairs of deleted items.
+      #
+      #   data = {:foo => "bar", :foobar => [:a, :b, {:foo => "other bar"}, :c]}
+      #   data.replace_at_path "**=*bar", "BAR"
+      #   #=> {[:foo] => "bar", [:foobar, 2, :foo] => "other bar"}
+
+      def delete_at_path path, limit=nil
+        count = 0
+        out   = {}
+
+        Kronk::Path.find path, self do |data, key, path_arr|
+          count         = count.next
+          out[path_arr] = data[key]
+
+          data.respond_to(:delete_at) ? data.delete_at(key) : data.delete(key)
 
-        Kronk::DataSet.new(self).find_data path do |d,k,p|
-          found[p] = d[k]
-          yield d, k, p if block_given?
+          return true if limit && count >= limit
         end
 
-        found
+        return count > 0
       end
     end
   end

data/lib/kronk/xml_parser.rb

@@ -6,20 +6,29 @@ class Kronk
   class XMLParser
 
     ##
-    # Load required gems.
+    # Load required gems. Loads Nokogiri. ActiveSupport will attempt to be
+    # loaded if String#pluralize is not defined.
 
     def self.require_gems
       require 'nokogiri'
 
+      return if "".respond_to?(:pluralize)
+
       # Support for new and old versions of ActiveSupport
+      active_support_versions = %w{active_support/inflector activesupport}
+      asupp_i = 0
+
       begin
-        require 'active_support/inflector'
+        require active_support_versions[asupp_i]
+
       rescue LoadError => e
-        raise unless e.message =~ /-- active_support/
-        require 'activesupport'
+        raise unless e.message =~ /-- active_?support/
+        asupp_i = asupp_i.next
+        retry if asupp_i < active_support_versions.length
       end
     end
 
+
     ##
     # Takes an xml string and returns a data hash.
     # Ignores blank spaces between tags.
@@ -117,9 +126,34 @@ class Kronk
         n.name
       end
 
-      names.uniq.length == 1 && (names.length > 1 ||
-      parent_name && (names.first == parent_name ||
-      names.first.pluralize == parent_name))
+      return false unless names.uniq.length == 1
+      return true  if     names.length > 1
+      return false unless parent_name
+
+      names.first == parent_name             ||
+      names.first.respond_to?(:pluralize) &&
+        names.first.pluralize == parent_name ||
+      pluralize(names.first) == parent_name
+    end
+
+
+    ##
+    # Naïve pluralization used if String#pluralize isn't defined.
+
+    def self.pluralize str
+      case str
+      when /z$/             then "#{str}zes"
+      when /f$/             then "#{str}ves"
+      when /y$/             then "#{str}ies"
+      when /is$/            then str.sub(/is$/, "es")
+      when "child"          then "children"
+      when "person"         then "people"
+      when "foot"           then "feet"
+      when "photo"          then "photos"
+      when /([sxo]|[cs]h)$/ then "#{str}es"
+      else
+        "#{str}s"
+      end
     end
   end
 end