knife-essentials 0.8.6 → 0.9.0

data/lib/chef/knife/diff_essentials.rb

@@ -26,6 +26,11 @@ class Chef
         :boolean => true,
         :description => "Only show names and statuses of modified files: Added, Deleted, Modified, and Type Changed."
 
+      option :diff_filter,
+        :long => '--diff-filter=[(A|D|M|T)...[*]]',
+        :description => "Select only files that are Added (A), Deleted (D), Modified (M), or have their type (i.e. regular file, directory) changed (T). Any combination of the filter characters (including none) can be used. When * (All-or-none) is added to the combination, all paths are selected if
+           there is any file that matches other criteria in the comparison; if there is no file that matches other criteria, nothing is selected."
+
       def run
         if config[:name_only]
           output_mode = :name_only
@@ -38,7 +43,7 @@ class Chef
         # Get the matches (recursively)
         error = false
         patterns.each do |pattern|
-          found_match = ChefFS::CommandLine.diff_print(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, output_mode, proc { |entry| format_path(entry) } ) do |diff|
+          found_match = ChefFS::CommandLine.diff_print(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, output_mode, proc { |entry| format_path(entry) }, config[:diff_filter] ) do |diff|
             stdout.print diff
           end
           if !found_match

data/lib/chef_fs/command_line.rb

@@ -21,7 +21,7 @@ require 'chef_fs/file_system'
 module ChefFS
   module CommandLine
 
-    def self.diff_print(pattern, a_root, b_root, recurse_depth, output_mode, format_path = nil)
+    def self.diff_print(pattern, a_root, b_root, recurse_depth, output_mode, format_path = nil, diff_filter = nil)
       if format_path.nil?
         format_path = proc { |entry| entry.path_for_printing }
       end
@@ -33,71 +33,77 @@ module ChefFS
         old_path = format_path.call(old_entry)
         new_path = format_path.call(new_entry)
 
-        if get_content && old_value && new_value
-          result = ''
-          result << "diff --knife #{old_path} #{new_path}\n"
-          if old_value == :none
-            result << "new file\n"
-            old_path = "/dev/null"
-            old_value = ''
+        case type
+        when :common_subdirectories
+          if output_mode != :name_only && output_mode != :name_status
+            yield "Common subdirectories: #{new_path}\n"
           end
-          if new_value == :none
+
+        when :directory_to_file
+          next if diff_filter && diff_filter !~ /T/
+          if output_mode == :name_only
+            yield "#{new_path}\n"
+          elsif output_mode == :name_status
+            yield "T\t#{new_path}\n"
+          else
+            yield "File #{old_path} is a directory while file #{new_path} is a regular file\n"
+          end
+
+        when :file_to_directory
+          next if diff_filter && diff_filter !~ /T/
+          if output_mode == :name_only
+            yield "#{new_path}\n"
+          elsif output_mode == :name_status
+            yield "T\t#{new_path}\n"
+          else
+            yield "File #{old_path} is a regular file while file #{new_path} is a directory\n"
+          end
+
+        when :deleted
+          next if diff_filter && diff_filter !~ /D/
+          if output_mode == :name_only
+            yield "#{new_path}\n"
+          elsif output_mode == :name_status
+            yield "D\t#{new_path}\n"
+          elsif old_value
+            result = "diff --knife #{old_path} #{new_path}\n"
             result << "deleted file\n"
-            new_path = "/dev/null"
-            new_value = ''
+            result << diff_text(old_path, '/dev/null', old_value, '')
+            yield result
+          else
+            yield "Only in #{format_path.call(old_entry.parent)}: #{old_entry.name}\n"
           end
-          result << diff_text(old_path, new_path, old_value, new_value)
-          yield result
-        else
-          case type
-          when :common_subdirectories
-            if output_mode != :name_only && output_mode != :name_status
-              yield "Common subdirectories: #{new_path}\n"
-            end
-          when :directory_to_file
-            if output_mode == :name_only
-              yield "#{new_path}\n"
-            elsif output_mode == :name_status
-              yield "T\t#{new_path}\n"
-            else
-              yield "File #{old_path} is a directory while file #{new_path} is a regular file\n"
-            end
-          when :file_to_directory
-            if output_mode == :name_only
-              yield "#{new_path}\n"
-            elsif output_mode == :name_status
-              yield "T\t#{new_path}\n"
-            else
-              yield "File #{old_path} is a regular file while file #{new_path} is a directory\n"
-            end
-          when :deleted
-            if output_mode == :name_only
-              yield "#{new_path}\n"
-            elsif output_mode == :name_status
-              yield "D\t#{new_path}\n"
-            else
-              yield "Only in #{format_path.call(old_entry.parent)}: #{old_entry.name}\n"
-            end
-          when :added
-            if output_mode == :name_only
-              yield "#{new_path}\n"
-            elsif output_mode == :name_status
-              yield "A\t#{new_path}\n"
-            else
-              yield "Only in #{format_path.call(new_entry.parent)}: #{new_entry.name}\n"
-            end
-          when :modified
-            if output_mode == :name_only
-              yield "#{new_path}\n"
-            elsif output_mode == :name_status
-              yield "M\t#{new_path}\n"
-            end
-          when :both_nonexistent
-          when :added_cannot_upload
-          when :deleted_cannot_download
-          when :same
-            # Skip these silently
+
+        when :added
+          next if diff_filter && diff_filter !~ /A/
+          if output_mode == :name_only
+            yield "#{new_path}\n"
+          elsif output_mode == :name_status
+            yield "A\t#{new_path}\n"
+          elsif new_value
+            result = "diff --knife #{old_path} #{new_path}\n"
+            result << "new file\n"
+            result << diff_text('/dev/null', new_path, '', new_value)
+            yield result
+          else
+            yield "Only in #{format_path.call(new_entry.parent)}: #{new_entry.name}\n"
           end
+        when :modified
+          next if diff_filter && diff_filter !~ /M/
+          if output_mode == :name_only
+            yield "#{new_path}\n"
+          elsif output_mode == :name_status
+            yield "M\t#{new_path}\n"
+          else
+            result = "diff --knife #{old_path} #{new_path}\n"
+            result << diff_text(old_path, new_path, old_value, new_value)
+            yield result
+          end
+        when :both_nonexistent
+        when :added_cannot_upload
+        when :deleted_cannot_download
+        when :same
+          # Skip these silently
         end
       end
       found_match
@@ -229,19 +235,6 @@ module ChefFS
     end
 
     def self.diff_text(old_path, new_path, old_value, new_value)
-      # Reformat JSON for a nicer diff.
-      if old_path =~ /\.json$/
-        begin
-          reformatted_old_value = canonicalize_json(old_value)
-          reformatted_new_value = canonicalize_json(new_value)
-          old_value = reformatted_old_value
-          new_value = reformatted_new_value
-        rescue
-          # If JSON parsing fails, we just won't change any values and fall back
-          # to normal diff.
-        end
-      end
-
       # Copy to tempfiles before diffing
       # TODO don't copy things that are already in files!  Or find an in-memory diff algorithm
       begin

data/lib/chef_fs/data_handler/client_data_handler.rb

@@ -0,0 +1,28 @@
+require 'chef_fs/data_handler/data_handler_base'
+require 'chef/api_client'
+
+module ChefFS
+  module DataHandler
+    class ClientDataHandler < DataHandlerBase
+      def normalize(client, entry)
+        super(client, {
+          'name' => remove_dot_json(entry.name),
+          'admin' => false,
+          'validator' => false,
+          'json_class' => 'Chef::ApiClient',
+          'chef_type' => 'client'
+        })
+      end
+
+      def preserve_key(key)
+        return key == 'name'
+      end
+
+      def chef_class
+        Chef::ApiClient
+      end
+
+      # There is no Ruby API for Chef::ApiClient
+    end
+  end
+end

data/lib/chef_fs/data_handler/cookbook_data_handler.rb

@@ -0,0 +1,36 @@
+require 'chef_fs/data_handler/data_handler_base'
+require 'chef/cookbook/metadata'
+
+module ChefFS
+  module DataHandler
+    class CookbookDataHandler < DataHandlerBase
+      def normalize(cookbook, entry)
+        version = entry.name
+        name = entry.parent.name
+        result = super(cookbook, {
+          'name' => "#{name}-#{version}",
+          'version' => version,
+          'cookbook_name' => name,
+          'json_class' => 'Chef::CookbookVersion',
+          'chef_type' => 'cookbook_version',
+          'frozen?' => false,
+          'metadata' => {}
+        })
+        result['metadata'] = super(result['metadata'], {
+          'version' => version,
+          'name' => name
+        })
+      end
+
+      def preserve_key(key)
+        return key == 'cookbook_name' || key == 'version'
+      end
+
+      def chef_class
+        Chef::Cookbook::Metadata
+      end
+
+      # Not using this yet, so not sure if to_ruby will be useful.
+    end
+  end
+end

data/lib/chef_fs/data_handler/data_bag_item_data_handler.rb

@@ -0,0 +1,32 @@
+require 'chef_fs/data_handler/data_handler_base'
+require 'chef/data_bag_item'
+
+module ChefFS
+  module DataHandler
+    class DataBagItemDataHandler < DataHandlerBase
+      def normalize(data_bag_item, entry)
+        # If it's wrapped with raw_data, unwrap it.
+        if data_bag_item['json_class'] == 'Chef::DataBagItem' && data_bag_item['raw_data']
+          data_bag_item = data_bag_item['raw_data']
+        end
+        # chef_type and data_bag only come back from PUT and POST, but we'll
+        # normalize them in in case someone is comparing with those results.
+        super(data_bag_item, {
+          'chef_type' => 'data_bag_item',
+          'data_bag' => entry.parent.name,
+          'id' => remove_dot_json(entry.name)
+        })
+      end
+
+      def preserve_key(key)
+        return key == 'id'
+      end
+
+      def chef_class
+        Chef::DataBagItem
+      end
+
+      # Data bags do not support .rb files (or if they do, it's undocumented)
+    end
+  end
+end

data/lib/chef_fs/data_handler/data_handler_base.rb

@@ -0,0 +1,110 @@
+module ChefFS
+  module DataHandler
+    class DataHandlerBase
+      def minimize(object, entry)
+        default_object = default(entry)
+        object.each_pair do |key, value|
+          if default_object[key] == value && !preserve_key(key)
+            object.delete(key)
+          end
+        end
+        object
+      end
+
+      def remove_dot_json(name)
+        if name.length < 5 || name[-5,5] != ".json"
+          raise "Invalid name #{path}: must end in .json"
+        end
+        name[0,name.length-5]
+      end
+
+      def preserve_key(key)
+        false
+      end
+
+      def default(entry)
+        normalize({}, entry)
+      end
+
+      def normalize(object, defaults)
+        # Make a normalized result in the specified order for diffing
+        result = {}
+        defaults.each_pair do |key, default|
+          result[key] = object.has_key?(key) ? object[key] : default
+        end
+        object.each_pair do |key, value|
+          result[key] = value if !result.has_key?(key)
+        end
+        result
+      end
+
+      def normalize_run_list(run_list)
+        run_list.map{|item|
+          case item.to_s
+          when /^recipe\[.*\]$/
+            item # explicit recipe
+          when /^role\[.*\]$/
+            item # explicit role
+          else
+            "recipe[#{item}]"
+          end
+        }.uniq
+      end
+
+      def from_ruby(ruby)
+        chef_class.from_file(ruby).to_hash
+      end
+
+      def chef_object(object)
+        chef_class.json_create(object)
+      end
+
+      def to_ruby(object)
+        raise NotImplementedError
+      end
+
+      def chef_class
+        raise NotImplementedError
+      end
+
+      def to_ruby_keys(object, keys)
+        result = ''
+        keys.each do |key|
+          if object[key]
+            if object[key].is_a?(Hash)
+              if object[key].size > 0
+                result << key
+                first = true
+                object[key].each_pair do |k,v|
+                  if first
+                    first = false
+                  else
+                    result << ' '*key.length
+                  end
+                  result << " #{k.inspect} => #{v.inspect}\n"
+                end
+              end
+            elsif object[key].is_a?(Array)
+              if object[key].size > 0
+                result << key
+                first = true
+                object[key].each do |value|
+                  if first
+                    first = false
+                  else
+                    result << ", "
+                  end
+                  result << value.inspect
+                end
+                result << "\n"
+              end
+            elsif !object[key].nil?
+              result << "#{key} #{object[key].inspect}\n"
+            end
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/chef_fs/data_handler/environment_data_handler.rb

@@ -0,0 +1,38 @@
+require 'chef_fs/data_handler/data_handler_base'
+require 'chef/environment'
+
+module ChefFS
+  module DataHandler
+    class EnvironmentDataHandler < DataHandlerBase
+      def normalize(environment, entry)
+        super(environment, {
+          'name' => remove_dot_json(entry.name),
+          'description' => '',
+          'cookbook_versions' => {},
+          'default_attributes' => {},
+          'override_attributes' => {},
+          'json_class' => 'Chef::Environment',
+          'chef_type' => 'environment'
+        })
+      end
+
+      def preserve_key(key)
+        return key == 'name'
+      end
+
+      def chef_class
+        Chef::Environment
+      end
+
+      def to_ruby(object)
+        result = to_ruby_keys(object, %w(name description default_attributes override_attributes))
+        if object['cookbook_versions']
+          object['cookbook_versions'].each_pair do |name, version|
+            result << "cookbook #{name.inspect}, #{version.inspect}"
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/chef_fs/data_handler/node_data_handler.rb

@@ -0,0 +1,34 @@
+require 'chef_fs/data_handler/data_handler_base'
+require 'chef/node'
+
+module ChefFS
+  module DataHandler
+    class NodeDataHandler < DataHandlerBase
+      def normalize(node, entry)
+        result = super(node, {
+          'name' => remove_dot_json(entry.name),
+          'json_class' => 'Chef::Node',
+          'chef_type' => 'node',
+          'chef_environment' => '_default',
+          'override' => {},
+          'normal' => {},
+          'default' => {},
+          'automatic' => {},
+          'run_list' => []
+        })
+        result['run_list'] = normalize_run_list(result['run_list'])
+        result
+      end
+
+      def preserve_key(key)
+        return key == 'name'
+      end
+
+      def chef_class
+        Chef::Node
+      end
+
+      # Nodes do not support .rb files
+    end
+  end
+end