csv-diff-report 0.3.2 → 0.3.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7c9a403ac0808911b994a8d1ecc167144d7c66d9
+  data.tar.gz: 9a8a75226e7845440c668375b3e57f919fe8510a
+SHA512:
+  metadata.gz: caf42e6d6dbcbea5243d416a8165d2dcb49b07dbab81d1e2e61092c7dbdc058350746753374701628153645e60241669b7880bdf591c921545888154ac011121
+  data.tar.gz: 66a15dfc2bcf8376ccca15135d457ab1f4669c7f70d667078f644a6312520e6284c4d1143b67e8c7d101fbd613b52ee2d4e0e5d3f9e4c798c81bb9f5aa6865e1

data/README.md

@@ -87,6 +87,54 @@ Output Options
 
 ```
 
+
+## .csvdiff Files
+
+The csvdiff command-line tool supports both file and directory diffs. As
+directories may contain files of different formats, .csvdiff files can be
+used to match file names to file types, and specify the appropriate diff
+settings for each file type.
+
+A .csvdiff file can be placed in either the working directory from which the
+csvdiff command is run, or the FROM directory. It consists of a YAML-formatted
+file with the following top-level keys:
+
+- defaults: Contains settings to be applied across all file types unless
+  overridden for a specific file type.
+- file_types: A hash whose keys are the file type labels used to describe
+  files of that type, and whose values are the various diff settings to use
+  for that file type.
+
+### .csvdiff Settings
+
+All settings that can be specified on the command-line can also be specified via
+.csvdiff for each file type. In addition, several additional settings are
+available via .csvdiff that are not available on the command-line. These
+additional settings are as follows:
+
+- pattern: Specifies the file name pattern that is used to match a file name to
+  a file type. File types are checked in the order listed, so more general
+  patterns must appear later in the .csvdiff file to avoid masking more specific
+  patterns; e.g. a pattern of * will match every file, so it should appear as
+  the pattern setting of the last entry in the file_types hash to ensure other
+  more specific patterns get a chance to match a given file name first.
+- exclude_pattern: Specifies an exclusion pattern for file names. Can be useful
+  when a single pattern is correct for a file-type but for a class of exceptions.
+- ignore: A boolean flag that can be used to ignore processing of matching files.
+  Useful when a directory contains files that should not be diffed in addition to
+  those that should.
+- include: A Hash of field names or indexes to either a regular expression or a
+  lambda expression which must be satisfied for records in the source to be diffed.
+  Any records with values in the corresponding columns will not be included in the
+  diff if the value in that column does not satisfy the regular expression or
+  lambda.
+- exclude: A Hash of field names or indexes to either a regular expression or a
+  lambda expression which must *not* be satisfied for records in the source to be
+  diffed. Any records with values in the corresponding columns will not be included
+  in the diff if the value in that column satisfies the regular expression or
+  lambda.
+
+
 ## Unique Row Identifiers
 
 CSVDiff is preferable over a standard line-by-line diff when row order is
@@ -144,6 +192,7 @@ B below Root.
 Note: If you aren't interested in changes in the order of siblings, then you could use
 CSVDiff with a :key_field option of column 1, and specify the :ignore_moves option.
 
+
 ## Warnings
 
 When processing and diffing files, CSVDiff may encounter problems with the data or
@@ -167,7 +216,7 @@ column in the data. In this case, a diff can be created simply via:
 diff = CSVDiff.new(file1, file2)
 ```
 
-### Specifynig Unique Row Identifiers
+### Specifying Unique Row Identifiers
 
 Often however, rows are not uniquely identifiable via the first column in the file.
 In a parent-child hierarchy, for example, combinations of parent and child may be
@@ -253,6 +302,23 @@ diff = CSVDiff.new(file1, file2, parent_field: 'Date', child_fields: ['HomeTeam'
                    ignore_fields: ['CreatedAt', 'UpdatedAt'])
 ```
 
+### Filtering Rows
+
+If you need to filter source data before running the diff process, you can use the :include
+and :exclude options to do so. Both options take a Hash as their value; the hash should have
+keys that are the field names or indexes (0-based) on which to filter, and whose values are
+regular expressions or lambdas to be applied to values of the corresponding field. Rows will
+only be diffed if they satisfy :include conditions, and do not satisfy :exclude conditions.
+```ruby
+# Generate a diff of Arsenal home games not refereed by Clattenburg
+diff = CSVDiff.new(file1, file2, parent_field: 'Date', child_fields: ['HomeTeam', 'AwayTeam'],
+                   include: {HomeTeam: 'Arsenal'}, exclude: {Referee: /Clattenburg/})
+
+# Generate a diff of games played over the Xmas/New Year period
+diff = CSVDiff.new(file1, file2, parent_field: 'Date', child_fields: ['HomeTeam', 'AwayTeam'],
+                   include: {Date: lambda{ |d| holiday_period.include?(Date.strptime(d, '%y/%m/%d')) } })
+```
+
 ### Ignoring Certain Changes
 
 CSVDiff identifies Adds, Updates, Moves and Deletes; any of these changes can be selectively

data/lib/csv-diff-report/cli.rb

@@ -11,7 +11,20 @@ class CSVDiff
         # Define an on_parse handler for field names or indexes. Splits the
         # supplied argument value on commas, and converts numbers to Fixnums.
         register_parse_handler(:parse_fields) do |val, arg, hsh|
-            val.split(',').map{ |fld| fld =~ /^\d+$/ ? fld.to_i : fld }
+            val.split(',').map{ |fld|
+                case fld
+                when /^\d+$/ then fld.to_i
+                when /^:(.+)/ then $1.intern
+                else fld
+                end
+            }
+        end
+        register_parse_handler(:parse_delimiter) do |val, arg, hsh|
+            case val
+            when /TAB/i, '\\t' then "\t"
+            when /COMMA/i then ','
+            else val
+            end
         end
 
         title 'CSV-Diff'
@@ -25,50 +38,60 @@ class CSVDiff
         positional_arg :pattern, 'A file name pattern to use to filter matching files if a directory ' +
             'diff is being performed', default: '*'
 
-        usage_break 'Source Options'
+        usage_break 'Source Options:'
         keyword_arg :file_types, 'A comma-separated list of file-type names (supports wildcards) to process. ' +
             'Requires the presence of a .csvdiff file in the FROM or current directory to define ' +
-            'the file type patterns',
+            'the file type patterns.',
             short_key: 't', on_parse: :split_to_array
         keyword_arg :exclude, 'A file name pattern of files to exclude from the diff if a directory ' +
-            'diff is being performed',
+            'diff is being performed.',
             short_key: 'x'
-        keyword_arg :field_names, 'A comma-separated list of field names for each ' +
-            'field in the source files',
+        keyword_arg :field_names, 'A comma-separated list of field names for each field in the source files.' +
+            'Only required if the source files do not contain header rows, or to use different names for the fields.',
             short_key: 'f', on_parse: :split_to_array
-        keyword_arg :parent_fields, 'The parent field name(s) or index(es)',
+        keyword_arg :key_fields, 'The key field name(s) or index(es). Short-hand for specifying parent and child' +
+            'fields separately; assumes the child field is the last key field.',
+            short_key: 'k', on_parse: :parse_fields
+        keyword_arg :parent_fields, 'The parent field name(s) or index(es).',
             short_key: 'p', on_parse: :parse_fields
-        keyword_arg :child_fields, 'The child field name(s) or index(es)',
+        keyword_arg :child_fields, 'The child field name(s) or index(es).',
             short_key: 'c', on_parse: :parse_fields
-        keyword_arg :key_fields, 'The key field name(s) or index(es)',
-            short_key: 'k', on_parse: :parse_fields
-        keyword_arg :encoding, 'The encoding to use when opening the CSV files',
+        keyword_arg :delimiter, 'The field delimiter used within the file; use TAB for tab-delimited.',
+            short_key: 'd', default: ',', on_parse: :parse_delimiter
+        keyword_arg :encoding, 'The encoding to use when opening the CSV files.',
             short_key: 'e'
-        flag_arg :tab_delimited, 'If true, the file is assumed to be tab-delimited rather than comma-delimited'
-        flag_arg :diff_common_fields_only, 'If true, only fields in both files are compared'
-        flag_arg :trim_whitespace, 'If true, trim leading/trailing whitespace before comparing fields'
+        flag_arg :trim_whitespace, 'If true, trim leading/trailing whitespace before comparing fields.',
+            short_key: 'w'
         flag_arg :ignore_header, 'If true, the first line in each source file is ignored; ' +
-            'requires the use of the --field-names option to name the fields'
-        flag_arg :ignore_case, 'If true, field comparisons are performed without regard to case'
-
-        usage_break 'Diff Options'
-        keyword_arg :ignore_fields, 'The names or indexes of any fields to be ignored during the diff',
-            short_key: 'i', on_parse: :parse_fields
-        flag_arg :ignore_adds, "If true, items in TO that are not in FROM are ignored",
+            'requires the use of the --field-names option to name the fields.',
+            short_key: 'i'
+
+        usage_break 'Diff Options:'
+        flag_arg :ignore_case, 'If true, field comparisons are performed without regard to case.'
+        flag_arg :diff_common_fields_only, 'If true, only fields in both files are compared.',
+            short_key: 'C'
+        keyword_arg :ignore_fields, 'The names or indexes of any fields to be ignored during the diff.',
+            short_key: 'I', on_parse: :parse_fields
+        flag_arg :ignore_adds, "If true, items in TO that are not in FROM are ignored.",
             short_key: 'A'
-        flag_arg :ignore_deletes, "If true, items in FROM that are not in TO are ignored",
+        flag_arg :ignore_deletes, "If true, items in FROM that are not in TO are ignored.",
             short_key: 'D'
-        flag_arg :ignore_updates, "If true, changes to non-key properties are ignored",
+        flag_arg :ignore_updates, "If true, changes to properties on existing items are ignored.",
             short_key: 'U'
-        flag_arg :ignore_moves, "If true, changes in an item's position are ignored",
+        flag_arg :ignore_moves, "If true, changes in an item's position are ignored.",
             short_key: 'M'
 
-        usage_break 'Output Options'
-        keyword_arg :format, 'The format in which to produce the diff report',
-            default: 'HTML', validation: /^(html|xlsx?|te?xt)$/i
+        usage_break 'Output Options:'
+        keyword_arg :format, 'The format in which to produce the diff report: HTML, XLSX, or TXT.',
+            default: 'HTML', validation: /^(html|xlsx?|te?xt|csv)$/i
         keyword_arg :output, 'The path to save the diff report to. If not specified, the diff ' +
             'report will be placed in the same directory as the FROM file, and will be named ' +
-            'Diff_<FROM>_to_<TO>.<FORMAT>'
+            'Diff_<FROM>_to_<TO>.<FORMAT>',
+            short_key: 'o'
+        keyword_arg :output_fields, 'The names or indexes of the fields to include in the diff output.',
+            short_key: 'O', on_parse: :parse_fields
+        keyword_arg :include_matched, 'If true, fields that match on lines with differences are included ' +
+            'in the diff output; by default, matching fields are not included in the diff output.'
 
 
         # Parses command-line options, and then performs the diff.
@@ -98,11 +121,11 @@ class CSVDiff
         # Process a CSVDiffReport using +arguments+ to determine all options.
         def process(arguments)
             options = {}
-            exclude_args = [:from, :to, :tab_delimited, :ignore_case]
+            exclude_args = [:from, :to, :delimiter, :ignore_case]
             arguments.each_pair do |arg, val|
                 options[arg] = val if val && !exclude_args.include?(arg)
             end
-            options[:csv_options] = {:col_sep => "\t"} if arguments.tab_delimited
+            options[:csv_options] = {:col_sep => arguments.delimiter}
             options[:case_sensitive] = !arguments.ignore_case
             rep = CSVDiff::Report.new
             rep.diff(arguments.from, arguments.to, options)

data/lib/csv-diff-report/excel.rb

@@ -37,6 +37,7 @@ class CSVDiff
                 @xl_styles['Update'] = s.add_style :fg_color => '0000A0', :bg_color => 'F0F0FF'
                 @xl_styles['Move'] = s.add_style :fg_color => '4040FF'
                 @xl_styles['Delete'] = s.add_style :fg_color => 'FF0000', :strike => true
+                @xl_styles['Matched'] = s.add_style :fg_coler => 'A0A0A0'
             end
             xl
         end
@@ -79,18 +80,16 @@ class CSVDiff
         def xl_diff_sheet(xl, file_diff)
             sheet_name = file_diff.options[:sheet_name] ||
                 File.basename(file_diff.left.path, File.extname(file_diff.left.path))
-            all_fields = [:row, :action]
-            all_fields << :sibling_position unless file_diff.options[:ignore_moves]
+            out_fields = output_fields(file_diff)
             freeze_cols = file_diff.options[:freeze_cols] ||
-                (all_fields.length + file_diff.left.key_fields.max + 1)
-            all_fields.concat(file_diff.diff_fields)
+                (out_fields.select{ |f| f.is_a?(Symbol) }.length + file_diff.left.key_fields.length)
             xl.workbook.add_worksheet(name: sheet_name) do |sheet|
-                sheet.add_row(all_fields.map{ |f| f.is_a?(Symbol) ? titleize(f) : f },
+                sheet.add_row(out_fields.map{ |f| f.is_a?(Symbol) ? titleize(f) : f },
                               :style => @xl_styles['Title'])
                 file_diff.diffs.sort_by{|k, v| v[:row] }.each do |key, diff|
                     sheet.add_row do |row|
                         chg = diff[:action]
-                        all_fields.each_with_index do |field, i|
+                        out_fields.each_with_index do |field, i|
                             cell = nil
                             comment = nil
                             old = nil
@@ -108,9 +107,12 @@ class CSVDiff
                                     style = @xl_styles[chg]
                                     comment = old
                                 end
-                            else
+                            elsif d
                                 new = d
                                 style = @xl_styles[chg] if i == 1
+                            elsif file_diff.options[:include_matched]
+                                style = @xl_styles['Matched']
+                                d = file_diff.right[key] && file_diff.right[key][field]
                             end
                             case new
                             when String

data/lib/csv-diff-report/html.rb

@@ -55,6 +55,7 @@ class CSVDiff
                     .delete {background-color: white; color: #FF0000; text-decoration: line-through;}
                     .update {background-color: white; color: #0000A0;}
                     .move {background-color: white; color: #0000A0;}
+                    .matched {background-color: white; color: #A0A0A0;}
                     .bold {font-weight: bold;}
                     .center {text-align: center;}
                     .right {text-align: right;}
@@ -76,11 +77,12 @@ class CSVDiff
             body << '</tbody>'
             body << '</table>'
             body << '<br>'
-            body << '<p>Differences:</p>'
+            body << '<p>Files:</p>'
             body << '<table>'
-            body << '<thead><tr>'
-            body << '<th>File</th><th>Adds</th><th>Deletes</th><th>Updates</th><th>Moves</th>'
-            body << '</tr></thead>'
+            body << '<thead>'
+            body << "<tr><th rowspan=2>File</th><th colspan=2 class='center'>Lines</th><th colspan=4 class='center'>Diffs</th></tr>"
+            body << "<tr><th>From</th><th>To</th><th>Adds</th><th>Deletes</th><th>Updates</th><th>Moves</th></tr>"
+            body << '</thead>'
             body << '<tbody>'
             @diffs.each do |file_diff|
                 label = File.basename(file_diff.left.path)
@@ -90,6 +92,8 @@ class CSVDiff
                 else
                     body << "<td>#{label}</td>"
                 end
+                body << "<td class='right'>#{file_diff.left.line_count}</td>"
+                body << "<td class='right'>#{file_diff.right.line_count}</td>"
                 body << "<td class='right'>#{file_diff.summary['Add']}</td>"
                 body << "<td class='right'>#{file_diff.summary['Delete']}</td>"
                 body << "<td class='right'>#{file_diff.summary['Update']}</td>"
@@ -126,12 +130,10 @@ class CSVDiff
             end
             body << '</p>'
 
-            all_fields = [:row, :action]
-            all_fields << :sibling_position unless file_diff.options[:ignore_moves]
-            all_fields.concat(file_diff.diff_fields)
+            out_fields = output_fields(file_diff)
             body << '<table>'
             body << '<thead><tr>'
-            all_fields.each do |fld|
+            out_fields.each do |fld|
                 body << "<th>#{fld.is_a?(Symbol) ? titleize(fld) : fld}</th>"
             end
             body << '</tr></thead>'
@@ -139,8 +141,8 @@ class CSVDiff
             file_diff.diffs.sort_by{|k, v| v[:row] }.each do |key, diff|
                 body << '<tr>'
                 chg = diff[:action]
-                all_fields.each_with_index do |field, i|
-                    old = nil
+                out_fields.each_with_index do |field, i|
+                    old, new = nil, nil
                     style = case chg
                     when 'Add', 'Delete' then chg.downcase
                     end
@@ -153,9 +155,12 @@ class CSVDiff
                         else
                             style = chg.downcase
                         end
-                    else
+                    elsif d
                         new = d
                         style = chg.downcase if i == 1
+                    elsif file_diff.options[:include_matched]
+                        style = 'matched'
+                        d = file_diff.right[key] && file_diff.right[key][field]
                     end
                     body << '<td>'
                     body << "<span class='delete'>#{CGI.escapeHTML(old.to_s)}</span>" if old

data/lib/csv-diff-report/report.rb

@@ -101,7 +101,9 @@ class CSVDiff
                     diff_dir(@left, @right, options, opt_file)
                 end
             else
-                raise ArgumentError, "Left and right must both exist and be files or directories"
+                echo ["From path '#{@left}' not found", :red] unless @left.exist?
+                echo ["To path '#{@right}' not found", :red] unless @right.exist?
+                raise ArgumentError, "Left and right must both exist and be of the same type (files or directories)"
             end
         end
 
@@ -117,7 +119,7 @@ class CSVDiff
                 xl_output(path)
             when format.to_s =~ /^html$/i || File.extname(path) =~ /html$/i
                 html_output(path)
-            when format.to_s =~ /^te?xt$/i || File.extname(path) =~ /txt$/i
+            when format.to_s =~ /^(te?xt|csv)$/i || File.extname(path) =~ /(csv|txt)$/i
                 text_output(path)
             else
                 raise ArgumentError, "Unrecognised output format: #{format}"
@@ -173,7 +175,7 @@ class CSVDiff
                     echo ["No file types are defined in .csvdiff", :yellow]
                 else
                     echo ["The file_types option can only be used when a " +
-                        ".csvdiff is present in the LEFT or current directory", :yellow]
+                        ".csvdiff is present in the FROM or current directory", :yellow]
                 end
             end
             matched_fts.uniq
@@ -183,7 +185,7 @@ class CSVDiff
         # Diff files that exist in both +left+ and +right+ directories.
         def diff_dir(left, right, options, opt_file)
             pattern = Pathname(options[:pattern] || '*')
-            exclude = options[:exclude]
+            exclude = options[:exclude_pattern]
 
             echo "  Include Pattern: #{pattern}"
             echo "  Exclude Pattern: #{exclude}" if exclude
@@ -209,7 +211,10 @@ class CSVDiff
         # @param options [Hash] The options to be passed to CSVDiff.
         def diff_file(left, right, options, opt_file)
             settings = find_file_type_settings(left, opt_file)
-            return if settings[:ignore]
+            if settings[:ignore]
+                echo "Ignoring file #{left}"
+                return
+            end
             options = settings.merge(options)
             from = open_source(left, :from, options)
             to = open_source(right, :to, options)
@@ -232,11 +237,13 @@ class CSVDiff
                 next if hsh[:pattern] == '-'
                 unless hsh[:matched_files]
                     hsh[:matched_files] = Dir[(left.dirname + hsh[:pattern]).to_s.gsub('\\', '/')]
-                    hsh[:matched_files] -= Dir[(left.dirname + hsh[:exclude]).to_s.gsub('\\', '/')] if hsh[:exclude]
+                    if hsh[:exclude_pattern]
+                        hsh[:matched_files] -= Dir[(left.dirname + hsh[:exclude_pattern]).to_s.gsub('\\', '/')]
+                    end
                 end
                 if hsh[:matched_files].include?(left.to_s)
                     settings.merge!(hsh)
-                    [:pattern, :exclude, :matched_files].each{ |k| settings.delete(k) }
+                    [:pattern, :exclude_pattern, :matched_files].each{ |k| settings.delete(k) }
                     break
                 end
             end
@@ -252,11 +259,29 @@ class CSVDiff
             out = ["Opening #{left_right.to_s.upcase} file '#{File.basename(src)}'..."]
             csv_src = CSVDiff::CSVSource.new(src.to_s, options)
             out << ["  #{csv_src.lines.size} lines read", :white]
+            if csv_src.skip_count > 0
+                out << [" (#{csv_src.skip_count} lines skipped)", :yellow]
+            end
             echo(*out)
             csv_src.warnings.each{ |warn| echo [warn, :yellow] }
             csv_src
         end
 
+
+        # Returns the fields to be output in the diff file
+        def output_fields(diff)
+            if diff.options[:output_fields]
+                diff.options[:output_fields].map do |fld|
+                    fld.is_a?(Fixnum) ? diff.diff_fields[fld] : fld
+                end
+            else
+                out_fields = [:row, :action]
+                out_fields << :sibling_position unless diff.options[:ignore_moves]
+                out_fields.concat(diff.diff_fields)
+                out_fields
+            end
+        end
+
     end
 
 end

data/lib/csv-diff-report/text.rb

@@ -11,7 +11,7 @@ class CSVDiff
 
         # Generare a diff report in TEXT format.
         def text_output(output)
-            path = "#{File.dirname(output)}/#{File.basename(output, File.extname(output))}.diff"
+            path = "#{File.dirname(output)}/#{File.basename(output, File.extname(output))}.csv"
             CSV.open(path, 'w') do |csv|
                 @diffs.each do |file_diff|
                     text_diff(csv, file_diff) if file_diff.diffs.size > 0
@@ -22,17 +22,15 @@ class CSVDiff
 
 
         def text_diff(csv, file_diff)
-            count = 0
-
-            all_fields = [:row, :action]
-            all_fields << :sibling_position unless file_diff.options[:ignore_moves]
-            all_fields.concat(file_diff.diff_fields)
-
-            csv << all_fields.map{ |fld| fld.is_a?(Symbol) ? titleize(fld) : fld }
+            out_fields = output_fields(file_diff)
+            csv << out_fields.map{ |fld| fld.is_a?(Symbol) ? titleize(fld) : fld }
             file_diff.diffs.each do |key, diff|
-                row = all_fields.map do |field|
+                row = out_fields.map do |field|
                     d = diff[field]
                     d = d.last if d.is_a?(Array)
+                    if d.nil? && file_diff.options[:include_matched]
+                        d = file_diff.right[key] && file_diff.right[key][field]
+                    end
                     d
                 end
                 csv << row

metadata

@@ -1,68 +1,60 @@
 --- !ruby/object:Gem::Specification
 name: csv-diff-report
 version: !ruby/object:Gem::Version
-  version: 0.3.2
-  prerelease: 
+  version: 0.3.4
 platform: ruby
 authors:
 - Adam Gardiner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-26 00:00:00.000000000 Z
+date: 2017-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: csv-diff
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: 0.3.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: 0.3.3
 - !ruby/object:Gem::Dependency
   name: arg-parser
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0.2'
 - !ruby/object:Gem::Dependency
   name: color-console
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0.1'
 - !ruby/object:Gem::Dependency
   name: axlsx
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -70,19 +62,26 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
-description: ! "        This library generates diff reports of CSV files, using the
-  diff capabilities\n        of the CSV Diff gem.\n\n        Unlike a standard diff
-  that compares line by line, and is sensitive to the\n        ordering of records,
-  CSV Diff identifies common lines by key field(s), and\n        then compares the
-  contents of the fields in each line.\n\n        CSV Diff Report takes the diff information
-  calculated by CSV Diff, and uses it to produce\n        Excel or HTML-based diff
-  reports. It also provides a command-line tool for generating\n        these diff
-  reports from CSV files.\n"
+description: |2
+          This library generates diff reports of CSV files, using the diff capabilities
+          of the CSV Diff gem.
+
+          Unlike a standard diff that compares line by line, and is sensitive to the
+          ordering of records, CSV-Diff identifies common lines by key field(s), and
+          then compares the contents of the fields in each line.
+
+          CSV-Diff Report takes the diff information calculated by CSV-Diff, and
+          uses it to produce Excel, HTML, or text diff reports. It also provides a
+          command-line tool (csvdiff) for generating these diff reports from CSV files.
+
+          The csvdiff command-line tool supports both file and directory diffs. As
+          directories may contain files of different formats, .csvdiff files can be
+          used to match file names to file types, and specify the appropriate diff
+          settings for each file type.
 email: adam.b.gardiner@gmail.com
 executables:
 - csvdiff
@@ -98,31 +97,29 @@ files:
 - lib/csv-diff-report/text.rb
 - lib/csv-diff-report.rb
 - lib/csv_diff_report.rb
-- !binary |-
-  YmluL2NzdmRpZmY=
+- bin/csvdiff
 homepage: https://github.com/agardiner/csv-diff-report
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 2.0.14.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: CSV Diff Report is a library for generating diff reports using the CSV Diff
   gem
 test_files: []