kronk 1.0.0

data/lib/kronk/data_set.rb

@@ -0,0 +1,230 @@
+class Kronk
+
+  ##
+  # Wraps a complex data structure to provide a search-driven interface.
+
+  class DataSet
+
+    attr_accessor :data
+
+    def initialize data
+      @data = data
+    end
+
+
+    ##
+    # Keep only specific data points from the data structure.
+
+    def collect_data_points data_paths
+      new_data = @data.class.new
+
+      [*data_paths].each do |data_path|
+        find_data data_path 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] ||= curr_data[key].class.new
+              new_curr_data        = new_curr_data[key]
+              curr_data            = curr_data[key]
+            end
+          end
+        end
+      end
+
+      @data = new_data
+    end
+
+
+    ##
+    # Remove specific data points from the data structure.
+
+    def delete_data_points data_paths
+      [*data_paths].each do |data_path|
+        find_data data_path do |obj, k, p|
+          case obj
+          when Hash  then obj.delete k
+          when Array then obj.delete_at k
+          end
+        end
+      end
+
+      @data
+    end
+
+
+    ##
+    # Find specific data points from a nested hash or array data structure.
+    # If a block is given, will pass it any matched parent data object,
+    # key, and full path.
+    #
+    # Data points must be an Array or String with a glob-like format.
+    # Special characters are: / * = | \ and are interpreted as follows:
+    # :key/ - walk down tree by one level from key
+    # :*/key - walk down tree from any parent with key as a child
+    # :key1|key2 - return elements with key value of key1 or key2
+    # :key=val - return elements where key has a value of val
+    # :key\* - return root-level element with key "key*"
+    #
+    # Other examples:
+    #   find_data data, root/**=invalid|
+    #   # Returns an Array of grand-children key/value pairs
+    #   # where the value is 'invalid' or blank
+
+    def find_data data_path, curr_path=nil, &block
+      self.class.find_data @data, data_path, curr_path, &block
+    end
+
+
+    ##
+    # See DataSet#find_data
+
+    def self.find_data data, data_path, curr_path=nil, &block
+      curr_path ||= []
+
+      key, value, rec, data_path = parse_data_path data_path
+
+      yield_data_points data, key, value, rec, curr_path do |d, k, p|
+
+        if data_path
+          find_data d[k], data_path, p, &block
+        else
+          yield d, k, p
+        end
+      end
+    end
+
+
+    ##
+    # Parses a given data point and returns an array with the following:
+    # - Key to match
+    # - Value to match
+    # - Recursive matching
+    # - New data path value
+
+    def self.parse_data_path data_path
+      data_path  = data_path.dup
+      key        = nil
+      value      = nil
+      recursive  = false
+
+      until key && key != "**" || value || data_path.empty? do
+        value = data_path.slice!(%r{((.*?[^\\])+?/)})
+        (value ||= data_path).sub!(/\/$/, '')
+
+        data_path = nil if value == data_path
+
+        key   = value.slice! %r{((.*?[^\\])+?=)}
+        key, value = value, nil if key.nil?
+        key.sub!(/\=$/, '')
+
+        value = parse_path_item value if value
+
+        if key =~ /^\*{2,}$/
+          if data_path && !value
+            key, value, rec, data_path = parse_data_path(data_path)
+          else
+            key = /.*/
+          end
+
+          recursive = true
+        else
+          key = parse_path_item key
+        end
+      end
+
+      data_path = nil if data_path && data_path.empty?
+
+      [key, value, recursive, data_path]
+    end
+
+
+    ##
+    # Decide whether to make path item a regex or not.
+
+    def self.parse_path_item str
+      if str =~ /(^|[^\\])([\*\?\|])/
+        str.gsub!(/(^|[^\\])(\*|\?)/, '\1.\2')
+        str = /^(#{str})$/
+      else
+        str.gsub! "\\", ""
+      end
+
+      str
+    end
+
+
+    ##
+    # Yield data object and key, if a specific key or value matches
+    # the given data.
+
+    def self.yield_data_points data, mkey, mvalue=nil,
+                               recursive=false, path=nil, &block
+
+      return unless Hash === data || Array === data
+      path ||= []
+
+      each_data_item data do |key, value|
+        curr_path = path.dup << key
+
+        found = match_data_item(mkey, key) &&
+                match_data_item(mvalue, value)
+
+        yield data, key, curr_path if found
+        yield_data_points data[key], mkey, mvalue, true, curr_path, &block if
+          recursive
+      end
+    end
+
+
+    ##
+    # Check if data key or value is a match for nested data searches.
+
+    def self.match_data_item item1, item2
+      return if !item1.nil? && (Array === item2 || Hash === item2)
+
+      if Regexp === item1
+        item2.to_s =~ item1
+      elsif item1.nil?
+        true
+      else
+        item2.to_s == item1.to_s
+      end
+    end
+
+
+    ##
+    # Universal iterator for Hash and Array objects.
+
+    def self.each_data_item data, &block
+      case data
+
+      when Hash
+        data.each(&block)
+
+      when Array
+        i = 0
+
+        # We need to iterate through the array this way
+        # in case items in it get deleted.
+
+        while i < data.length do
+          index = i
+          old_length = data.length
+
+          block.call index, data[index]
+
+          adj = old_length - data.length
+          adj = 0 if adj < 0
+
+          i = i.next - adj
+        end
+      end
+    end
+  end
+end

data/lib/kronk/diff.rb

@@ -0,0 +1,210 @@
+class Kronk
+
+
+  ##
+  # Creates simple diffs as formatted strings or arrays, from two strings or
+  # data objects.
+
+  class Diff
+
+
+    ##
+    # Creates a new diff from two data objects.
+
+    def self.new_from_data data1, data2, options={}
+      new ordered_data_string(data1, options[:struct]),
+          ordered_data_string(data2, options[:struct])
+    end
+
+
+    ##
+    # Returns a data string that is diff-able, meaning sorted by
+    # Hash keys when available.
+
+    def self.ordered_data_string data, struct_only=false, indent=0
+      case data
+
+      when Hash
+        output = "{\n"
+
+        key_width = 0
+        data.keys.each do |k|
+          key_width = k.inspect.length if k.inspect.length > key_width
+        end
+
+        data_values =
+          data.map do |key, value|
+            pad = " " * indent
+            subdata = ordered_data_string value, struct_only, indent + 1
+            "#{pad}#{key.inspect} => #{subdata}"
+          end
+
+        output << data_values.sort.join(",\n") << "\n"
+        output << "#{" " * indent}}"
+
+      when Array
+        output = "[\n"
+
+        data_values =
+          data.map do |value|
+            pad = " " * indent
+            "#{pad}#{ordered_data_string value, struct_only, indent + 1}"
+          end
+
+        output << data_values.join(",\n") << "\n"
+        output << "#{" " * indent}]"
+
+      else
+        return data.inspect unless struct_only
+        return "Boolean" if data == true || data == false
+        data.class
+      end
+    end
+
+
+    attr_accessor :str1, :str2, :char, :format
+
+    def initialize str1, str2, char=/\r?\n/
+      @str1 = str1
+      @str2 = str2
+      @char = char
+      @diff_ary = nil
+      @format = Kronk.config[:diff_format] || :ascii_diff
+    end
+
+
+    ##
+    # Returns a diff array with the following format:
+    #   str1 = "match1\nmatch2\nstr1 val"
+    #   str1 = "match1\nin str2\nmore str2\nmatch2\nstr2 val"
+    #
+    #   Diff.new(str1, str2).create_diff
+    #   ["match 1",
+    #    [[], ["in str2", "more str2"]],
+    #    "match 2",
+    #    [["str1 val"], ["str2 val"]]]
+
+    def create_diff
+      diff_ary = []
+      sub_diff = nil
+
+      arr1 = @str1.split @char
+      arr2 = @str2.split @char
+
+      until arr1.empty? && arr2.empty?
+        item1, item2 = arr1.shift, arr2.shift
+
+        if item1 == item2
+          if sub_diff
+            diff_ary << sub_diff
+            sub_diff = nil
+          end
+
+          diff_ary << item1
+          next
+        end
+
+        match1 = arr1.index item2
+        match2 = arr2.index item1
+
+        if match1
+          diff_ary.concat diff_match(item1, match1, arr1, 0, sub_diff)
+          sub_diff = nil
+
+        elsif match2
+          diff_ary.concat diff_match(item2, match2, arr2, 1, sub_diff)
+          sub_diff = nil
+
+        elsif !item1.nil? || !item2.nil?
+          sub_diff ||= [[],[]]
+          sub_diff[0] << item1 if item1
+          sub_diff[1] << item2 if item2
+        end
+      end
+
+      diff_ary << sub_diff if sub_diff
+
+      diff_ary
+    end
+
+
+    ##
+    # Create a diff from a match.
+
+    def diff_match item, match, arr, side, sub_diff
+      sub_diff ||= [[],[]]
+
+      index = match - 1
+      added = [item]
+      added.concat arr.slice!(0..index) if index >= 0
+
+      sub_diff[side].concat(added)
+      [sub_diff, arr.shift]
+    end
+
+
+    ##
+    # Returns a formatted output as a string.
+    # Custom formats may be achieved by passing a block.
+
+    def formatted format=@format, join_char="\n", &block
+      block ||= method format
+
+      diff_array.map do |item|
+        block.call item.dup
+      end.flatten.join join_char
+    end
+
+
+    ##
+    # Formats a single diff element to the default diff format.
+
+    def ascii_diff item
+      case item
+      when String
+        "  #{item}"
+      when Array
+        item[0] = item[0].map{|str| "- #{str}"}
+        item[1] = item[1].map{|str| "+ #{str}"}
+        item
+      else
+        "  #{item.inspect}"
+      end
+    end
+
+
+    ##
+    # Formats a single diff element with colors.
+
+    def color_diff item
+      case item
+      when String
+        item
+      when Array
+        item[0] = item[0].map{|str| "\033[31m#{str}\033[0m"}
+        item[1] = item[1].map{|str| "\033[32m#{str}\033[0m"}
+        item
+      else
+        item.inspect
+      end
+    end
+
+
+    ##
+    # Returns the cached diff array when available, otherwise creates it.
+
+    def diff_array
+      @diff_ary ||= create_diff
+    end
+
+    alias to_a diff_array
+
+
+    ##
+    # Returns a diff string with the default format.
+
+    def to_s
+      formatted
+    end
+  end
+end

data/lib/kronk/plist_parser.rb

@@ -0,0 +1,15 @@
+class Kronk
+
+  ##
+  # Simple plist wrapper to add :parse method.
+
+  class PlistParser
+
+    ##
+    # Alias for Plist.parse_xml
+
+    def self.parse plist
+      Plist.parse_xml plist
+    end
+  end
+end