csv-diff 0.2 → 0.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZGY3NTBiZGFiNTQxMmZiZmMwOTE2MDIzYmEwNWQ3NTY0MzZmNjRkMg==
+    MzM3MmMzNzU5ZDE5ZTA5MGI4OGQxNTBkMTE0NWM1MzYzNDVkYTFjYQ==
   data.tar.gz: !binary |-
-    NzAyNTY1OTk3MTA3Y2ZhNjk2YWRmNTJkYTljNGZhZDY2YjQ1OTg2ZQ==
+    MDQ3Yzk3ZDc4ZTZiNTMwMzc1NGMxMTU5ZTBkMzdjMTMyNzE5OTYwMg==
 SHA512:
   metadata.gz: !binary |-
-    ZDRmODg2NDlhYTY4NDM1MWYxNjgyZGQ0MGRiZDNkYmI3MDkwYjFkZWVhOWYw
-    YmVkNDVhMjk1M2EyNjFkZGIxOGE0Y2MwOWQwMWRhNzhjZDk2N2RhZmEyZGRm
-    MjliNmM4Y2ZmNzY4ZTJkY2EzZWY4Mjg3NmU3ZjQxM2RkYTBjODE=
+    YTYxMDM1MjUxNDk3ZjE3YWUxZWJjNGFmMzQzMDUyNGJlOGUzMmI2MDVlNjg4
+    OWJiYmQxNTI2MjBlMmQzNGFkZTk0ZGY1Y2I0ZDBkODljYjc4NDQ1ZDY1ODky
+    ZDU4MDUwZjVjYWU0MTE5NTExMmExYTM0NTY1ZGMzYzc5NDkxYmE=
   data.tar.gz: !binary |-
-    YTljOGZhNDY0YzdjZGYzMTA2NTM3MzIwNDg4MTcwYWEyM2IyZTc1YWYxMjFm
-    YjMwYWU1NWMzNGVkZGRkYWYyZjUwMTQ2MWZlMjdkNjQwMjIwYWUwNmNlYjM3
-    NDlmZDk5MGNlMTk4ZDhlMzFiOGUyZTIwY2EyZTY3MjUwYjc2NWY=
+    YzU4YWM2MmZjMjE4MjlhZDgxN2IxNmI1NmU2YjFiZTcwN2ZlNTZlYzE5MzZm
+    NGJkZDNkODUzNGNlNjA2NGZlZWIyMWFmMjljOTQyNjE3OGU4YWFmY2UyZWE2
+    YzhlZmI0YTcxMGY3N2Y2ODQ5NTM3ODcyMTUzOTJkODhjNjY0YWM=

data/lib/csv-diff/algorithm.rb

@@ -13,7 +13,20 @@ class CSVDiff
         #   that uniquely identify each row.
         # @param diff_fields [Array] An array containing the names of the fields
         #   to be diff-ed.
+        # @param options [Hash] An options hash.
+        # @option options [Boolean] :ignore_adds If set to true, we ignore any
+        #  new items that appear only in +right+.
+        # @option options [Boolean] :ignore_moves If set to true, we ignore any
+        #  changes in sibling order.
+        # @option options [Boolean] :ignore_updates If set to true, we ignore any
+        #  items that exist in both +left+ and +right+.
+        # @option options [Boolean] :ignore_deletes If set to true, we ignore any
+        #  new items that appear only in +left+.
         def diff_sources(left, right, key_fields, diff_fields, options = {})
+            unless left.case_sensitive? == right.case_sensitive?
+                raise ArgumentError, "Left and right must have same settings for case-sensitivity"
+            end
+            case_sensitive = left.case_sensitive?
             left_index = left.index
             left_values = left.lines
             left_keys = left_values.keys
@@ -57,7 +70,7 @@ class CSVDiff
                             #puts "Move #{left_idx} -> #{right_idx}: #{key}"
                         end
                     end
-                    if include_updates && (changes = diff_row(left_value, right_value, diff_fields))
+                    if include_updates && (changes = diff_row(left_value, right_value, diff_fields, case_sensitive))
                         diffs[key].merge!(id.merge(changes.merge(:action => 'Update')))
                         #puts "Change: #{key}"
                     end
@@ -99,17 +112,21 @@ class CSVDiff
         #   file.
         # @param right_row [Hash] The version of the CSV row from the right/to
         #   file.
+        # @param fields [Array<String>] An array of field names to compare.
+        # @param case_sensitive [Boolean] Whether field comparisons should be
+        #   case sensitive or not.
         # @return [Hash<String, Array>] A Hash whose keys are the fields that
         #   contain differences, and whose values are a two-element array of
         #   [left/from, right/to] values.
-        def diff_row(left_row, right_row, fields)
+        def diff_row(left_row, right_row, fields, case_sensitive)
             diffs = {}
             fields.each do |attr|
                 right_val = right_row[attr]
                 right_val = nil if right_val == ""
                 left_val = left_row[attr]
                 left_val = nil if left_val == ""
-                if left_val != right_val
+                if (case_sensitive && left_val != right_val) ||
+                   (left_val.to_s.upcase != right_val.to_s.upcase)
                     diffs[attr] = [left_val, right_val]
                     #puts "#{attr}: #{left_val} -> #{right_val}"
                 end

data/lib/csv-diff/csv_diff.rb

@@ -28,13 +28,15 @@ class CSVDiff
     # @return [Array<String>] An array of field names that are compared in the
     #    diff process.
     attr_reader :diff_fields
-    # @return [Array<Fixnum>] An array of field indexes identifying the key
-    #    fields that uniquely identify each row.
+    # @return [Array<String>] An array of field namees of the key fields that
+    #    uniquely identify each row.
     attr_reader :key_fields
     # @return [Array<String>] An array of field names for the parent field(s).
     attr_reader :parent_fields
     # @return [Array<String>] An array of field names for the child field(s).
     attr_reader :child_fields
+    # @return [Hash] The options hash used for the diff.
+    attr_reader :options
 
 
     # Generates a diff between two hierarchical tree structures, provided
@@ -84,7 +86,7 @@ class CSVDiff
         @right = right.is_a?(CSVSource) ? right : CSVSource.new(right, options)
         raise "No field names found in right (to) source" unless @right.field_names && @right.field_names.size > 0
         @warnings = []
-        @diff_fields = get_diff_fields(@left.field_names, @right.field_names, options[:ignore_fields])
+        @diff_fields = get_diff_fields(@left.field_names, @right.field_names, options)
         @key_fields = @left.key_fields.map{ |kf| @diff_fields[kf] }
         diff(options)
     end
@@ -94,6 +96,7 @@ class CSVDiff
     def diff(options = {})
         @summary = nil
         @diffs = diff_sources(@left, @right, @key_fields, @diff_fields, options)
+        @options = options
     end
 
 
@@ -134,15 +137,21 @@ class CSVDiff
 
     # Given two sets of field names, determines the common set of fields present
     # in both, on which members can be diffed.
-    def get_diff_fields(left_fields, right_fields, ignore_fields)
+    def get_diff_fields(left_fields, right_fields, options)
+        ignore_fields = (options[:ignore_fields] || []).map do |f|
+            f.is_a?(Fixnum) ? right_fields[f] : f
+        end
         diff_fields = []
-        right_fields.each_with_index do |fld, i|
-            if left_fields.include?(fld)
-                diff_fields << fld unless ignore_fields && (ignore_fields.include?(fld) ||
-                                                            ignore_fields.include?(i))
-            else
-                @warnings << "Field '#{fld}' is missing from the left (from) file, and won't be diffed"
+        if options[:diff_common_fields_only]
+            right_fields.each_with_index do |fld, i|
+                if left_fields.include?(fld)
+                    diff_fields << fld unless ignore_fields.include?(fld)
+                else
+                    @warnings << "Field '#{fld}' is missing from the left (from) file, and won't be diffed"
+                end
             end
+        else
+            diff_fields = (right_fields + left_fields).uniq.reject{ |fld| ignore_fields.include?(fld) }
         end
         diff_fields
     end

data/lib/csv-diff/csv_source.rb

@@ -17,6 +17,11 @@ class CSVDiff
         # @return [Array<String>] The names of the field(s) that distinguish a
         #   child of a parent record.
         attr_reader :child_fields
+        # @return [Boolean] True if the source has been indexed with case-
+        #   sensitive keys, or false if it has been indexed using upper-case key
+        #   values.
+        attr_reader :case_sensitive
+        alias_method :case_sensitive?, :case_sensitive
         # @return [Hash<String,Hash>] A hash containing each line of the source,
         #   keyed on the values of the +key_fields+.
         attr_reader :lines
@@ -59,10 +64,13 @@ class CSVDiff
         #   identifies each row.
         # @option options [Array<String>] :key_fields The names of the fields
         #   that uniquely identifies each row.
-        # @option options [String] :parent_field The name of the field that
-        #   identifies a parent within which sibling order should be checked.
-        # @option options [String] :child_field The name of the field that
-        #   uniquely identifies a child of a parent.
+        # @option options [String] :parent_field The name of the field(s) that
+        #   identify a parent within which sibling order should be checked.
+        # @option options [String] :child_field The name of the field(s) that
+        #   uniquely identify a child of a parent.
+        # @option options [Boolean] :case_sensitive If true (the default), keys
+        #  are indexed as-is; if false, the index is built in upper-case for
+        #  case-insensitive comparisons.
         def initialize(source, options = {})
             if source.is_a?(String)
                 require 'csv'
@@ -104,6 +112,7 @@ class CSVDiff
             @lines = {}
             @index = Hash.new{ |h, k| h[k] = [] }
             @key_fields = find_field_indexes(@key_fields, @field_names) if @field_names
+            @case_sensitive = options.fetch(:case_sensitive, true)
             line_num = 0
             lines.each do |row|
                 line_num += 1
@@ -121,6 +130,7 @@ class CSVDiff
                 key_values = @key_fields.map{ |kf| field_vals[kf].to_s.upcase }
                 key = key_values.join('~')
                 parent_key = key_values[0...(@parent_fields.length)].join('~')
+                parent_key.upcase! unless @case_sensitive
                 if @lines[key]
                     @warnings << "Duplicate key '#{key}' encountered and ignored at line #{line_num}"
                 else

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: csv-diff
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: 0.3.0
 platform: ruby
 authors:
 - Adam Gardiner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-11 00:00:00.000000000 Z
+date: 2014-08-14 00:00:00.000000000 Z
 dependencies: []
 description: ! "        This library performs diffs of CSV files.\n\n        Unlike
   a standard diff that compares line by line, and is sensitive to the\n        ordering
@@ -21,7 +21,14 @@ description: ! "        This library performs diffs of CSV files.\n\n        Unl
   lend itself well to standard text diffs, as small changes\n        in the organisation
   of the tree at an upper level can lead to big movements\n        in the position
   of descendant records. By instead matching records by key,\n        CSV-Diff avoids
-  this issue, while still being able to detect changes in\n        sibling order.\n"
+  this issue, while still being able to detect changes in\n        sibling order.\n\n
+  \       This gem implements the core diff algorithm, and handles the loading and\n
+  \       diffing of CSV files. It returns a CSVDiff object, that contains the details\n
+  \       of differences in object form. This is useful for projects that need diff\n
+  \       capability, but want to handle the reporting of differences themselves.
+  For\n        a pre-built diff reporting capability, see the csv-diff-report gem,
+  which\n        provides a command-line tool for generating diff reports in HTML
+  or Excel\n        format.\n"
 email: adam.b.gardiner@gmail.com
 executables: []
 extensions: []