chef 0.10.0.beta.5 → 0.10.0.beta.6

data/lib/chef/knife/core/node_presenter.rb

@@ -0,0 +1,103 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/knife/core/text_formatter'
+require 'chef/knife/core/generic_presenter'
+
+class Chef
+  class Knife
+    module Core
+
+      # This module may be included into a knife subcommand class to automatically
+      # add configuration options used by the NodePresenter
+      module NodeFormattingOptions
+        # :nodoc:
+        # Would prefer to do this in a rational way, but can't be done b/c of
+        # Mixlib::CLI's design :(
+        def self.included(includer)
+          includer.class_eval do
+            option :medium_output,
+              :short   => '-m',
+              :long    => '--medium',
+              :boolean => true,
+              :default => false,
+              :description => 'Include normal attributes in the output'
+
+            option :long_output,
+              :short   => '-l',
+              :long    => '--long',
+              :boolean => true,
+              :default => false,
+              :description => 'Include all attributes in the output'
+          end
+        end
+      end
+
+      #==Chef::Knife::Core::NodePresenter
+      # A customized presenter for Chef::Node objects. Supports variable-length
+      # output formats for displaying node data
+      class NodePresenter < GenericPresenter
+
+        # Converts a Chef::Node object to a string suitable for output to a
+        # terminal. If config[:medium_output] or config[:long_output] are set
+        # the volume of output is adjusted accordingly. Uses colors if enabled
+        # in the the ui object.
+        def summarize(data)
+          if data.kind_of?(Chef::Node)
+            node = data
+            summarized=<<-SUMMARY
+#{ui.color('Node Name:', :bold)}   #{ui.color(node.name, :bold)}
+#{key('Environment:')} #{node.chef_environment}
+#{key('FQDN:')}        #{node[:fqdn]}
+#{key('IP:')}          #{node[:ipaddress]}
+#{key('Run List:')}    #{node.run_list}
+#{key('Roles:')}       #{Array(node[:roles]).join(', ')}
+#{key('Recipes')}      #{Array(node[:recipes]).join(', ')}
+#{key('Platform:')}    #{node[:platform]} #{node[:platform_version]}
+SUMMARY
+            if config[:medium_output] || config[:long_output]
+              summarized +=<<-MORE
+#{key('Attributes:')}
+#{text_format(node.normal_attrs)}
+MORE
+            end
+            if config[:long_output]
+              summarized +=<<-MOST
+#{key('Default Attributes:')}
+#{text_format(node.default_attrs)}
+#{key('Override Attributes:')}
+#{text_format(node.override_attrs)}
+#{key('Automatic Attributes (Ohai Data):')}
+#{text_format(node.automatic_attrs)}
+MOST
+            end
+            summarized
+          else
+            super
+          end
+        end
+
+        def key(key_text)
+          ui.color(key_text, :cyan)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/chef/knife/core/object_loader.rb

@@ -0,0 +1,75 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+class Chef
+  class Knife
+    module Core
+      class ObjectLoader
+
+        attr_reader :ui
+        attr_reader :klass
+
+        def initialize(klass, ui)
+          @klass = klass
+          @ui = ui
+        end
+
+        def load_from(repo_location, *components)
+          unless object_file = find_file(repo_location, *components)
+            ui.error "Could not find or open file for #{components.join(' ')}"
+            exit 1
+          end
+          object_from_file(object_file)
+        end
+
+        def find_file(repo_location, *components)
+          if file_exists_and_is_readable?(File.expand_path( components.last ))
+            File.expand_path( components.last )
+          else
+            relative_path = File.join(Dir.pwd, repo_location, *components)
+            if file_exists_and_is_readable?(relative_path)
+              relative_path
+            else
+              nil
+            end
+          end
+        end
+
+        def object_from_file(filename)
+          case filename
+          when /\.(js|json)$/
+            Chef::JSONCompat.from_json(IO.read(filename))
+          when /\.rb$/
+            r = klass.new
+            r.from_file(filename)
+            r
+          else
+            ui.fatal("File must end in .js, .json, or .rb")
+            exit 30
+          end
+        end
+
+        def file_exists_and_is_readable?(file)
+          File.exists?(file) && File.readable?(file)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/chef/knife/{subcommand_loader.rb → core/subcommand_loader.rb}

@@ -72,7 +72,7 @@ class Chef
 
       def find_subcommands_via_dirglob
         # The "require paths" of the core knife subcommands bundled with chef
-        files = Dir[File.expand_path('../../knife/*.rb', __FILE__)]
+        files = Dir[File.expand_path('../../../knife/*.rb', __FILE__)]
         files.map! { |knife_file| knife_file[/#{CHEF_ROOT}#{Regexp.escape(File::SEPARATOR)}(.*)\.rb/,1] }
         files
       end

data/lib/chef/knife/core/text_formatter.rb

@@ -0,0 +1,100 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+class Chef
+  class Knife
+    module Core
+      class TextFormatter
+
+        attr_reader :data
+        attr_reader :ui
+
+        def initialize(data, ui)
+          @ui = ui
+          @data = if data.respond_to?(:display_hash)
+            data.display_hash
+          elsif data.kind_of?(Array)
+            data
+          elsif data.respond_to?(:to_hash)
+            data.to_hash
+          else
+            data
+          end
+        end
+
+        def formatted_data
+          @formatted_data ||= text_format(data)
+        end
+
+        def text_format(data, indent=0)
+          buffer = ''
+
+          if data.respond_to?(:keys)
+            justify_width = data.keys.map {|k| k.to_s.size }.max.to_i + 2
+            data.sort.each do |key, value|
+              justified_key = ui.color("#{key}:".ljust(justify_width), :cyan)
+              if should_enumerate?(value)
+                buffer << indent_line(justified_key, indent)
+                buffer << text_format(value, indent + 1)
+              else
+                buffer << indent_key_value(justified_key, value, justify_width, indent)
+              end
+            end
+          elsif data.kind_of?(Array)
+            data.each do |item|
+              if should_enumerate?(data)
+                buffer << text_format(item, indent + 1)
+              else
+                buffer << indent_line(item, indent)
+              end
+            end
+          else
+            buffer << indent_line(stringify_value(data), indent)
+          end
+          buffer
+        end
+
+        # Ruby 1.8 Strings include enumberable, which is not what we want. So
+        # we have this heuristic to detect hashes and arrays instead.
+        def should_enumerate?(value)
+          ((value.respond_to?(:keys) && !value.empty? ) || ( value.kind_of?(Array) && value.size > 1 ))
+        end
+
+        def indent_line(string, indent)
+          ("  " * indent) << "#{string}\n"
+        end
+
+        def indent_key_value(key, value, justify_width, indent)
+          lines = value.to_s.split("\n")
+          if lines.size > 1
+            total_indent = (2 * indent) + justify_width + 1
+            indent_line("#{key} #{lines.shift}", indent) << lines.map {|l| (" " * total_indent) + l << "\n" }.join("")
+          else
+            indent_line("#{key} #{stringify_value(value)}", indent)
+          end
+        end
+
+        def stringify_value(data)
+          data.kind_of?(String) ? data : data.inspect
+        end
+
+      end
+    end
+  end
+end
+

data/lib/chef/knife/{ui.rb → core/ui.rb}

@@ -18,18 +18,37 @@
 # limitations under the License.
 #
 
+require 'forwardable'
+require 'chef/knife/core/generic_presenter'
 
 class Chef
   class Knife
+
+    #==Chef::Knife::UI
+    # The User Interaction class used by knife.
     class UI
 
+      extend Forwardable
+
       attr_reader :stdout
       attr_reader :stderr
       attr_reader :stdin
       attr_reader :config
 
+      def_delegator :@presenter, :format_list_for_display
+      def_delegator :@presenter, :format_for_display
+      def_delegator :@presenter, :format_cookbook_list_for_display
+
       def initialize(stdout, stderr, stdin, config)
         @stdout, @stderr, @stdin, @config = stdout, stderr, stdin, config
+        @presenter = Chef::Knife::Core::GenericPresenter.new(self, config)
+      end
+
+      # Creates a new +presenter_class+ object and uses it to format structured
+      # data for display. By default, a Chef::Knife::Core::GenericPresenter
+      # object is used.
+      def use_presenter(presenter_class)
+        @presenter = presenter_class.new(self, config)
       end
 
       def highline
@@ -39,26 +58,42 @@ class Chef
         end
       end
 
+      # Prints a message to stdout. Aliased as +info+ for compatibility with
+      # the logger API.
       def msg(message)
         stdout.puts message
       end
 
       alias :info :msg
 
+      # Print a warning message
       def warn(message)
-        msg("WARNING: #{message}")
+        msg("#{color('WARNING:', :yellow, :bold)} #{message}")
       end
 
+      # Print an error message
       def error(message)
-        msg("ERROR: #{message}")
+        msg("#{color('ERROR:', :red, :bold)} #{message}")
       end
 
+      # Print a message describing a fatal error.
       def fatal(message)
-        msg("FATAL: #{message}")
+        msg("#{color('FATAL:', :red, :bold)} #{message}")
+      end
+
+      def color(string, *colors)
+        if color?
+          highline.color(string, *colors)
+        else
+          string
+        end
       end
 
-      def color(*args)
-        highline.color(*args)
+      # Should colored output be used? For output to a terminal, this is
+      # determined by the value of `config[:color]`. When output is not to a
+      # terminal, colored output is never used
+      def color?
+        config[:color] && stdout.tty?
       end
 
       def ask(*args, &block)
@@ -69,6 +104,19 @@ class Chef
         highline.list(*args)
       end
 
+      # Formats +data+ using the configured presenter and outputs the result
+      # via +msg+. Formatting can be customized by configuring a different
+      # presenter. See +use_presenter+
+      def output(data)
+        msg @presenter.format(data)
+      end
+
+      # Determines if the output format is a data interchange format, i.e.,
+      # JSON or YAML
+      def interchange?
+        @presenter.interchange?
+      end
+
       def ask_question(question, opts={})
         question = question + "[#{opts[:default]}] " if opts[:default]
 
@@ -90,74 +138,6 @@ class Chef
         stdout.puts data
       end
 
-      def output(data)
-        case config[:format]
-        when "json", nil
-          stdout.puts Chef::JSONCompat.to_json_pretty(data)
-        when "yaml"
-          require 'yaml'
-          stdout.puts YAML::dump(data)
-        when "text"
-          # If you were looking for some attribute and there is only one match
-          # just dump the attribute value
-          if data.length == 1 and config[:attribute]
-            stdout.puts data.values[0]
-          else
-            PP.pp(data, stdout)
-          end
-        else
-          raise ArgumentError, "Unknown output format #{config[:format]}"
-        end
-      end
-
-      def format_list_for_display(list)
-        config[:with_uri] ? list : list.keys.sort { |a,b| a <=> b }
-      end
-
-      def format_for_display(data)
-        if config[:attribute]
-          config[:attribute].split(".").each do |attr|
-            if data.respond_to?(:[])
-              data = data[attr]
-            elsif data.nil?
-              nil # don't get no method error on nil
-            else data.respond_to?(attr.to_sym)
-              data = data.send(attr.to_sym)
-            end
-          end
-          { config[:attribute] => data.respond_to?(:to_hash) ? data.to_hash : data }
-        elsif config[:run_list]
-          data = data.run_list.run_list
-          { "run_list" => data }
-        elsif config[:environment]
-          if data.respond_to?(:chef_environment)
-            {"chef_environment" => data.chef_environment}
-          else
-            # this is a place holder for now. Feel free to modify (i.e. add other cases). [nuo]
-            data
-          end
-        elsif config[:id_only]
-          data.respond_to?(:name) ? data.name : data["id"]
-        else
-          data
-        end
-      end
-
-      def format_cookbook_list_for_display(item)
-        if config[:with_uri]
-          item
-        else
-          versions_by_cookbook = item.inject({}) do |collected, ( cookbook, versions )|
-            collected[cookbook] = versions["versions"].map {|v| v['version']}
-            collected
-          end
-          key_length = versions_by_cookbook.keys.map {|name| name.size }.max + 2
-          versions_by_cookbook.sort.map do |cookbook, versions|
-            "#{cookbook.ljust(key_length)} #{versions.join(',')}"
-          end
-        end
-      end
-
       def edit_data(data, parse_output=true)
         output = Chef::JSONCompat.to_json_pretty(data)