xibdiff 0.1.0

data/README.txt

@@ -0,0 +1 @@
+xibdiff - a tool for diffing XIB/NIB files created in Interface Builder

data/Rakefile

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+#$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'lib')))
+require 'rubygems'
+
+require 'xibdiff.gemspec'

data/lib/XibDiffLogger.rb

@@ -0,0 +1,25 @@
+class XibDiffLogger
+  @@obj_path = []
+
+  @@separator = '/'
+
+  def self.obj_path
+    @@obj_path.join(@@separator)
+  end
+
+  def self.msg(msg)
+    "#{obj_path}: #{msg}"
+  end
+
+  def self.log(msg)
+    puts msg(msg)
+  end
+
+  def self.push(e)
+    @@obj_path << e
+  end
+
+  def self.pop
+    @@obj_path.pop
+  end
+end

data/lib/XibDiffObjectAdditions.rb

@@ -0,0 +1,83 @@
+module ArrayPrettyPrint
+  def to_pretty_str(indent,var=nil)
+    res = ""
+    self.each_with_index do |e,i|
+      preamble = "#{i} = "
+      res += preamble
+      if e.respond_to? 'to_pretty_str'
+        res += e.to_pretty_str(indent + " " * preamble.length,var)
+      else
+        res += e.to_s
+      end
+      res += "\n" + indent
+    end
+    res
+  end
+end
+
+module HashPrettyPrint
+  def to_pretty_str(indent,var=nil)
+    res = ""
+    each_pair do |k,v|
+      # ignore certain keys
+      next if var and var[:ignore_keys] and var[:ignore_keys].include? k
+
+      preamble = "#{k} = "
+      res += preamble
+      if v.respond_to? 'to_pretty_str'
+        res += v.to_pretty_str(indent + " " * preamble.length,var)
+      else
+        res += v.to_s
+      end
+      res += "\n" + indent
+    end
+    res
+  end
+end
+
+module DistanceTo
+  def distance_to(other,var=nil)
+    d = 0 # assume they're equal
+    if self.class != other.class
+      d += 1000
+    elsif self.class == Array
+      if self.length != other.length
+        d += 100
+      else
+        self.each_with_index do |e,i|
+          d += e.distance_to(other[i],var)
+        end
+      end
+    elsif self.class == Hash
+      if self.keys.length != other.keys.length
+        d += 50
+      elsif self.keys != other.keys
+        d += 50
+      else
+        self.each_pair do |k,v|
+          # ignore certain keys
+          next if var and var[:ignore_keys] and var[:ignore_keys].include? k
+
+          d += v.distance_to(other[k],var)
+        end
+      end
+    else
+      # At this point, self and other should be of the same
+      # class, and not an Array nor a Hash
+      d += 1 if self.eql? other
+    end
+    d
+  end
+end
+
+Object.class_eval do
+  include DistanceTo
+end
+
+Array.class_eval do
+  include ArrayPrettyPrint
+end
+
+Hash.class_eval do
+  include HashPrettyPrint
+end

data/lib/XibDiffObjectComparison.rb

@@ -0,0 +1,91 @@
+module XibDiffObjectComparison
+  def compare_generic(a,b,var=nil)
+    if a.class != b.class
+      XibDiffLogger.log "items have different classes: a:#{a.class}  b:#{b.class}"
+    elsif a.class == Hash
+      compare_generic_dicts(a,b,var)
+    elsif a.class == Array
+      compare_generic_arrays(a,b,var)
+    else
+      XibDiffLogger.log "items differ: a:#{a}  b:#{b}" unless a == b
+    end
+  end
+  
+  def compare_generic_arrays(a,b,var=nil)
+    a_idxs = (0..a.length-1).to_a
+    b_idxs = (0..b.length-1).to_a
+  
+    a_idxs.each do |a_idx|
+      obj_name  = a_idx.to_s
+      obj_name += ":#{a[a_idx][var[:name_key]]}" if var[:name_key] and not a[a_idx][var[:name_key]].nil?
+      XibDiffLogger.push obj_name
+      min_dist   = 0
+      best_match = -1
+  
+      b_idxs.each do |b_idx|
+        dist = a[a_idx].distance_to(b[b_idx],var)
+        if dist == 0 # a[a_idx] == b[b_idx]
+          min_dist   = 0
+          best_match = b_idx
+          break
+        elsif best_match == -1 || dist < min_dist
+          best_match = b_idx
+          min_dist   = dist
+        end
+      end
+  
+      if best_match == -1
+        XibDiffLogger.log "removed"
+      else
+        b_idxs.delete best_match
+  
+        if a_idx != best_match
+          XibDiffLogger.log "moved to position #{best_match}"
+        end
+  
+        if min_dist > 0
+          compare_generic(a[a_idx],b[best_match],var)
+        end
+      end
+      XibDiffLogger.pop
+    end
+  
+    b_idxs.each do |b_idx|
+      preamble = "added => "
+      XibDiffLogger.log "#{preamble}#{b[b_idx].to_pretty_str(" " * XibDiffLogger.XibDiffLogger.msg(preamble).length,var)}"
+    end
+  end
+  
+  def compare_generic_dicts(a,b,var=nil)
+    # Pre: a.class == Hash, b.class == Hash
+    in_a_and_b = []
+    # for each key on dict a
+    a.each_pair do |k,v|
+      # skip items on ignored list
+      next if var and var[:ignore_keys] and var[:ignore_keys].include? k
+  
+      # check if it's in b
+      if b[k].nil?
+        XibDiffLogger.log "removed '#{k}'"
+      else
+        in_a_and_b << b[k] # add to intersection list
+  
+        XibDiffLogger.push(k)
+        compare_generic(v,b[k],var) # recursive compare
+        XibDiffLogger.pop
+      end
+    end
+  
+    # check if missing key in b
+    b.each_pair do |k,v|
+      # skip items on ignored list
+      next if var and var[:ignore_keys] and var[:ignore_keys].include? k
+  
+      if !in_a_and_b.include? v
+        preamble = "added '#{k}' => "
+        XibDiffLogger.log "#{preamble}#{v.to_pretty_str(" " * XibDiffLogger.msg(preamble).length,var)}" if v.class == Hash
+        XibDiffLogger.log "#{preamble}#{v}#{" " * XibDiffLogger.msg(preamble).length}"                  if v.class != Hash
+      end
+    end
+  end
+end

data/lib/XibDiffXibComparison.rb

@@ -0,0 +1,192 @@
+require 'XibDiffObjectComparison'
+
+include XibDiffObjectComparison
+
+module XibDiffXibComparison
+  def compare_classes(*c)
+    XibDiffLogger.push(c[0]['class'])
+    compare_generic( c[0], c[1], nil )
+    XibDiffLogger.pop
+  end
+
+  def compare_class_dicts(*class_dict)
+    in_a_and_b = []
+    class_dict[0].each_pair do |key,value|
+      # search for class 'key' in the second hash
+      if class_dict[1][key].nil?
+        XibDiffLogger.push key
+        XibDiffLogger.log "deleted."
+        XibDiffLogger.pop
+      else
+        in_a_and_b << key
+        compare_classes(value, class_dict[1][key])
+      end
+    end
+
+    class_dict[1].each_pair do |k,v|
+      if !(in_a_and_b.include? k)
+        XibDiffLogger.push k
+        preamble = "added => "
+        XibDiffLogger.log "#{preamble}#{v.to_pretty_str(" " * XibDiffLogger.msg(preamble).length)}"
+        XibDiffLogger.pop
+      end
+    end
+  end
+
+  def compare_hierarchy_arrays(*hierarchy_array)
+    in_a_and_b = []
+    hierarchy_array[0].each do |item|
+      XibDiffLogger.push item['label']
+      # search for object named the same in the other dict
+      hierarchy_array[1].each do |other_item|
+        if other_item['label'] == item['label']
+          in_a_and_b << item['label']
+
+          # now compare the two
+          compare_generic(item, other_item, :name_key => 'label', :ignore_keys => ['object-id'])
+        end
+      end
+
+      # Check if not found
+      if in_a_and_b.last != item['label']
+        XibDiffLogger.log "deleted."
+      end
+      XibDiffLogger.pop
+    end
+
+    # check for the missing ones
+    hierarchy_array[1].each do |item|
+      if !(in_a_and_b.include? item['label'])
+        XibDiffLogger.push item['label']
+        preamble = "added => "
+        XibDiffLogger.log "#{preamble}#{item.to_pretty_str(" " * XibDiffLogger.msg(preamble).length, :ignore_keys => ['object-id'])}"
+        XibDiffLogger.pop
+      end
+    end
+  end
+
+  def dict_with_path_to_object_id(hierarchy_array)
+    dict = {}
+    stack = [ { :obj => hierarchy_array, :path => [] } ]
+
+    while not stack.empty?
+      top = stack.pop
+      obj = top[:obj]
+      path = top[:path]
+      if obj.class == Array
+        obj.each_with_index do |e,i|
+          obj_name  = i.to_s
+          obj_name += ":#{e['label']}" if e['label']
+          stack << { :obj => e, :path => (Array.new(path) << obj_name) }
+        end
+      elsif obj.class == Hash
+        obj_path  = path.join('/')
+        obj_path += ":#{obj['label']}" if obj['label']
+        dict[obj_path] = obj['object-id'] if obj['object-id']
+        obj.each_pair do |k,v|
+          stack << { :obj => v, :path => Array.new(path) } if v.class == Array and k == 'children'
+          stack << { :obj => v, :path => (Array.new(path) << k) } if k != 'children' and ( v.class == Array or v.class == Hash )
+        end
+      end
+    end
+    
+    dict
+  end
+
+  def compare_object_arrays(*params)
+    a_dict = params[0]
+    a_objs = params[1]
+    b_dict = params[2]
+    b_objs = params[3]
+    
+    a_keys = a_dict.keys.sort
+    b_keys = b_dict.keys.sort
+
+    a_idx = b_idx = 0
+    while a_idx < a_keys.length or b_idx < b_keys.length
+      a_key = a_keys[a_idx]
+      b_key = b_keys[b_idx]
+
+      if ( a_key and b_key and (a_key < b_key) ) or ( a_key and b_key.nil? )
+        # Removed object
+        XibDiffLogger.push a_key
+        XibDiffLogger.log "deleted."
+        XibDiffLogger.pop
+
+        a_idx += 1
+      elsif ( a_key and b_key and (a_key > b_key) ) or ( a_key.nil? and b_key )
+        # Added object
+        XibDiffLogger.push b_key
+        preamble = "added => "
+        XibDiffLogger.log "#{preamble}#{b_objs[b_dict[b_key].to_s].to_pretty_str(" " * XibDiffLogger.msg(preamble).length )}"
+        XibDiffLogger.pop
+
+        b_idx += 1
+      else # a_key and b_key and a_key == b_key
+        XibDiffLogger.push a_key # or b_key, doesn't matter
+        compare_generic(a_objs[a_dict[a_key].to_s], b_objs[b_dict[b_key].to_s])
+        XibDiffLogger.pop
+
+        a_idx += 1
+        b_idx += 1
+      end
+    end
+  end
+
+  def connection_map_for_connection_array(dict, conns)
+    map = {}
+    conns.each_pair do |k,v|
+      key  = "#{dict[v['source-id']]} => #{dict[v['destination-id']]} #{v['type']}"
+      key += " #{v['label']}"                   if v['type'] == 'IBCocoaOutletConnection' or v['type'] == 'IBCocoaActionConnection'
+      key += " #{v['binding']}:#{v['keypath']}" if v['type'] == 'IBBindingConnection'
+      value = k
+
+      map[key] = value
+    end
+    map
+  end
+
+  def compare_connection_arrays(*params)
+    a_dict  = params[0]
+    a_conns = params[1]
+    b_dict  = params[2]
+    b_conns = params[3]
+
+    # build connection map array
+    a_map = connection_map_for_connection_array(a_dict, a_conns)
+    b_map = connection_map_for_connection_array(b_dict, b_conns)
+
+    a_keys = a_map.keys.sort
+    b_keys = b_map.keys.sort
+
+    a_idx = b_idx = 0
+    while a_idx < a_keys.length or b_idx < b_keys.length
+      a_key = a_keys[a_idx]
+      b_key = b_keys[b_idx]
+
+      if ( a_key and b_key and (a_key < b_key) ) or ( a_key and b_key.nil? )
+        # Removed object
+        XibDiffLogger.push a_key
+        XibDiffLogger.log "deleted."
+        XibDiffLogger.pop
+
+        a_idx += 1
+      elsif ( a_key and b_key and (a_key > b_key) ) or ( a_key.nil? and b_key )
+        # Added object
+        XibDiffLogger.push b_key
+        preamble = "added => "
+        XibDiffLogger.log "#{preamble}#{b_conns[b_map[b_key].to_s].to_pretty_str(" " * XibDiffLogger.msg(preamble).length )}"
+        XibDiffLogger.pop
+
+        b_idx += 1
+      else # a_key and b_key and a_key == b_key
+        XibDiffLogger.push a_key # or b_key, doesn't matter
+        compare_generic(a_conns[a_map[a_key].to_s], b_conns[b_map[b_key].to_s])
+        XibDiffLogger.pop
+
+        a_idx += 1
+        b_idx += 1
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: xibdiff
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Igor Sales
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-04 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: xibdiff is a ruby command-line tool to diff two nib or xib files.
+email: 
+- self@igorsales.ca
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- README.txt
+- Rakefile
+- lib/XibDiffLogger.rb
+- lib/XibDiffObjectAdditions.rb
+- lib/XibDiffObjectComparison.rb
+- lib/XibDiffXibComparison.rb
+has_rdoc: true
+homepage: http://github.com/igorsales/xibdiff
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: xibdiff
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: XIB/NIB diff tool for Mac OS X
+test_files: []
+