vagrant-plugins 0.1.0 → 0.2.0

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# v0.2.0
+
+* Adds a verbose flag. Informs about plugin features such as "provides commands" or "action hook" etc.
+* Adds a `--no-heads` flag. Swicth off the column descriptions.
+* Revamped the internal UI component to use a nifty DSL to describe the column layout.
+
 # v0.1.0
 
 * simple list of all loaded plugin names

data/README.md

@@ -3,20 +3,23 @@ vagrant-plugins
 
 A vagrant plugin to list active vagrant plugins.
 
+Since *vagrant 1.1* (which is not yet released) you need to specify which plugins you want to load. You may either use the global `.vagrant.rc` file or the projects `Vagrantfile`.
+This can get a bit confusing when having a lot of different configurations or projects. 
 
+This plugin aims to help you keeping track of which plugins are loaded in your project.
 
 ## Installation
 
 If you use the gem version of Vagrant, use:
 
 ```bash
-$ gem install vagrant-dns
+$ gem install vagrant-plugins
 ```
 
 otherwise, use:
 
 ```bash
-$ vagrant gem install vagrant-dns
+$ vagrant gem install vagrant-plugins
 ```
 
 And add this line to your `.vagrantrc` or `Vagrantfile`:
@@ -28,9 +31,11 @@ Vagrant.require_plugin 'vagrant-plugins'
 ## Usage
 
 ```bash
-$ vagrant plugins
+$ vagrant plugins [-a|--all]
 ```
 
+* `-a|--all` : Display *vagrant's* builtin plugins as well.
+
 ## Contributing
 
 1. Fork it

data/lib/vagrant-plugins/command.rb

@@ -12,6 +12,14 @@ module VagrantPlugininspection
         opts.on("-a", "--all", "List builtin vagrant plugins as well.") do
           options[:all] = true
         end
+
+        opts.on("-H", "--no-head", "Do not print descriptive headings") do 
+          options[:no_heads] = true
+        end
+
+        opts.on("-v", "--verbose", "Be verbose and display plugin features") do
+          options[:verbose] = true
+        end
       end
 
       argv = parse_options(opts)
@@ -29,14 +37,52 @@ module VagrantPlugininspection
         
         plugins = Vagrant.plugin("1").registered.map { |plugin|
           if options[:all] || !builtins.include?(plugin)
-            {
+            info = {
               :name => plugin.name, 
               :description => plugin.description
             }
+
+            info.merge!({
+              :hosts        => !!plugin.data[:hosts],
+              :guests       => !!plugin.data[:guests],
+              :provisioners => !!plugin.data[:provisioners],
+              :commands     => !!plugin.data[:command],
+              :action_hooks => !!plugin.data[:action_hooks],
+              :configs      => !!plugin.data[:config],
+            }) if options[:verbose]
+
+            # return the plugins info Hash
+            info
           end
         }.compact
 
-        ui.print_columns plugins, :column_order => [:name, :description]
+        if options[:verbose] && !options[:no_heads]
+          head = <<-EOS
++- hosts
+|+- guests
+||+- provisioners
+|||+- commands
+||||+- action_hooks
+|||||+- configs
+EOS
+          ui.info head, :prefix => false
+        end
+
+        ui.print_columns(plugins, :heads => !options[:no_heads]) do 
+          if options[:verbose]
+            column :hosts, :name => '|' 
+            column :guests, :name => '|'
+            column :provisioners, :name => '|'
+            column :commands, :name => '|'
+            column :action_hooks, :name => '|'
+            column :configs, :name => '|'
+            seperator "\t"
+          end
+          column :name
+          seperator "\t"
+          column :description
+        end
+
       end
     end
 

data/lib/vagrant-plugins/ui.rb

@@ -2,29 +2,9 @@ module VagrantPlugininspection
   module UI
     class Columnized < Vagrant::UI::Colored
 
-      def say(type, message, opts=nil)
-        defaults = { :new_line => true, :prefix => true }
-        opts     = defaults.merge(opts || {})
-        super
-      end
-
-      def print_columns(data, opts=nil)
-        defaults = { :prefix => false }
-        opts     = defaults.merge(opts ||= {})
-
-        columns = opts.delete(:column_order)
-
-        data = clean(data, opts)
-        size = sizes(data)
+      class LayoutError < StandardError; end
 
-        table_head = columnize_row(columns.zip(columns), size, columns) + "\n" 
-        table_head << (table_head.gsub(/[^\t]/, '-')) + "\n"
-        table_body = data.map { |line| columnize_row(line, size, columns) }.join("\n")
-        
-        say :info, table_head << table_body, opts
-      end
-
-      protected 
+      class Layout
 
         BOOL_MAP = {
           true => '*',
@@ -32,32 +12,139 @@ module VagrantPlugininspection
           nil => ''
         }
 
-        def clean(data, opts=nil)
-          data.map{|line|
-            Hash[line.map{ |col| 
-              col[1] = BOOL_MAP[col[1]] || col[1].to_s.strip.gsub(/^\s+|\s+$/, '').gsub(/\n|\r/,' ')
-              col
-            }]
-          }
+        # @param [Array] _optional_ Array with column names for a simple layout. Columns will be seperated by tab.
+        def initialize(simple=nil)
+          simple.each { |column|
+            self.column(column)
+            self.seperator("\t")
+          } if simple
+
+          @heads   = Hash.new
+          @columns = Hash.new
+          @stack   = Array.new
         end
-        
-        def sizes(data)
-          s = {}
-          data.each { |line| 
-            line.each_pair { |key, value|
-              s[key] = [key.length, value.length, (s[key] || 0)].max
+
+        # Adds a column definition to the current position
+        def column(key, opts=nil)
+          defaults = { :name => key.to_s }
+          opts     = defaults.merge(opts || {})
+
+          @heads[key] = opts[:name]
+          @columns[key] = opts
+          @stack << key
+        end
+
+        # Adds a seperator to the current position
+        def seperator(str)
+          @stack << str.to_s
+        end
+
+        # Returns an Array of columns formatted lines. 
+        # Also includes column headers and horizonal header line.
+        # @return [Array] Returns an Array of formatted lines
+        def rows(data, opts=nil)
+          defaults = { :heads => true }
+          opts     = defaults.merge(opts || {})
+
+          data = clean(data)
+          size = sizes(data)
+
+          rendered = Array.new
+          if opts.delete(:heads)
+            rendered << columnize_row(@heads, size)
+            rendered << horizontal_line(size)
+          end
+          rendered << data.map { |line| columnize_row(line, size) }
+
+          # return a flat Array with lines
+          rendered.flatten
+        end
+
+        protected
+
+          def column_name(key)
+            col = @heads[key]
+            (col || key).to_s
+          end
+
+          # translate boolean values using BOOL_MAP
+          # strips whitespace and newline
+          def clean(data)
+            data.map{|line|
+              Hash[line.map{ |col| 
+                col[1] = BOOL_MAP[col[1]] || col[1].to_s.strip.gsub(/^\s+|\s+$/, '').gsub(/\n|\r/,' ')
+                col
+              }]
+            }
+          end
+          
+          # determinate the size of each column
+          def sizes(data)
+            s = {}
+            data.each { |line| 
+              line.each_pair { |key, value|
+                s[key] = [column_name(key).length, value.length, (s[key] || 0)].max
+              }
             }
-          }
-          s
+            s
+          end
+
+          def columnize_row(row, sizes)
+            @stack.map { |piece| 
+              if piece.is_a? String
+                piece
+              else
+                sprintf "%-#{sizes[piece]}s", row[piece]
+              end
+            }.join
+          end
+
+          def horizontal_line(sizes)
+            @stack.map { |piece|
+              if piece.is_a? String
+                piece
+              else
+                '-' * sizes[piece]
+              end
+            }.join
+          end
+
+      end # Layout
+
+      def print_columns(data, opts=nil, &block)
+        defaults = {}
+        opts     = defaults.merge(opts ||= {})
+        layout   = opts.delete(:layout)
+        columns  = opts.delete(:columns)
+        
+        layout ||= if block_given?
+          self.layout(&block)
+        elsif columns && !columns.empty?
+          Layout.new(columns)
+        else
+          raise LayoutError, "You need to pass a layout information, either as a block or array."
         end
 
-        def columnize_row(row, size, columns=nil)
-          data = Hash[row.map { |key, value|
-            [key, "%-#{size[key]}s" % [value]]
-          }]
+        rendered = layout.rows(data, opts).map { |line| 
+          format_message(:info, line, opts) 
+        }.join("\n")
+
+        # force the prefix off, we'd allready handled that
+        opts[:prefix] = false
+
+        say :info, rendered, opts
+      end
+
+      protected 
 
-          (columns ? columns.map { |col| data[col] } : data.values).join("\t")
+        # helper to create us a Layout instance and prime using a given block
+        def layout(&block)
+          layout = Layout.new
+          layout.instance_eval(&block)
+          # return the layout descriptor
+          layout
         end
-    end
+    
+    end # Columnized
   end
 end

data/lib/vagrant-plugins/version.rb

@@ -1,3 +1,3 @@
 module VagrantPlugininspection
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-plugins
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-15 00:00:00.000000000 Z
+date: 2012-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: vagrant