bbcloud 0.6.2 → 0.7

data/lib/bbcloud/vendor/hirb/lib/hirb/view.rb

@@ -1,284 +0,0 @@
-module Hirb
-  # This class is responsible for managing all view-related functionality.
-  #
-  # == Create a View
-  # Let's create a simple view for Hash objects:
-  #   $ irb -rubygems
-  #   >> require 'hirb'
-  #   =>true
-  #   >> Hirb.enable
-  #   =>nil
-  #   >> require 'yaml'
-  #   =>true
-  #
-  #   # A view method is the smallest view
-  #   >> def yaml(output); output.to_yaml; end
-  #   => nil
-  #   # Add the view
-  #   >> Hirb.add_view Hash, :method=>:yaml
-  #   => true
-  #
-  #   # Hashes now appear as yaml
-  #   >> {:a=>1, :b=>{:c=>3}}
-  #   ---
-  #   :a : 1
-  #   :b : 
-  #     :c : 3
-  #   => true
-  #
-  # Another way of creating a view is a Helper class:
-  #
-  #   # Create yaml view class
-  #   >> class Hirb::Helpers::Yaml; def self.render(output, options={}); output.to_yaml; end ;end
-  #   =>nil
-  #   # Add the view
-  #   >> Hirb.add_view Hash, :class=>Hirb::Helpers::Yaml
-  #   =>true
-  #
-  #   # Hashes appear as yaml like above ...
-  #
-  # == Configure a View
-  # To configure the above Helper class as a view, either pass Hirb.enable a hash:
-  #   # In .irbrc
-  #   require 'hirb'
-  #   # View class needs to come before enable()
-  #   class Hirb::Helpers::Yaml; def self.render(output, options={}); output.to_yaml; end ;end
-  #   Hirb.enable :output=>{"Hash"=>{:class=>"Hirb::Helpers::Yaml"}}
-  #
-  # Or create a config file at config/hirb.yml or ~/.hirb.yml:
-  #   # The config file for the yaml example would look like:
-  #   # ---
-  #   # :output :
-  #   #   Hash :
-  #   #    :class : Hirb::Helpers::Yaml
-  #
-  #   # In .irbrc
-  #   require 'hirb'
-  #   # View class needs to come before enable()
-  #   class Hirb::Helpers::Yaml; def self.render(output, options={}); output.to_yaml; end ;end
-  #   Hirb.enable
-  #
-  # For more about configuring Hirb, see the Config Files section in Hirb.
-  module View
-    DEFAULT_WIDTH = 120
-    DEFAULT_HEIGHT = 40
-    class<<self
-      attr_accessor :render_method
-      attr_reader :config
-
-      # This activates view functionality i.e. the formatter, pager and size detection. If irb exists, it overrides irb's output
-      # method with Hirb::View.view_output. When called multiple times, new configs are merged into the existing config.
-      # If using Wirble, you should call this after it. The view configuration can be specified in a hash via a config file,
-      # or as options to this method. In addition to the config keys mentioned in Hirb, options also take the following keys:
-      # ==== Options:
-      # * config_file: Name of config file(s) that are merged into existing config
-      # * output_method: Specify an object's class and instance method (separated by a period) to be realiased with
-      #   hirb's view system. The instance method should take a string to be output. Default is IRB::Irb.output_value
-      #   if using irb.
-      # Examples:
-      #   Hirb.enable
-      #   Hirb.enable :formatter=>false, :output_method=>"Mini.output"
-      def enable(options={}, &block)
-        Array(options.delete(:config_file)).each {|e|
-          @new_config_file = true
-          Hirb.config_files << e
-        }
-        enable_output_method(options.delete(:output_method))
-        merge_or_load_config options
-        resize(config[:width], config[:height])
-        @enabled = true
-      end
-
-      # Indicates if Hirb::View is enabled.
-      def enabled?
-        @enabled || false
-      end
-
-      # Disable's Hirb's output and revert's irb's output method if irb exists.
-      def disable
-        @enabled = false
-        unalias_output_method(@output_method) if @output_method
-        false
-      end
-
-      # Toggles pager on or off. The pager only works while Hirb::View is enabled.
-      def toggle_pager
-        config[:pager] = !config[:pager]
-      end
-
-      # Toggles formatter on or off.
-      def toggle_formatter
-        config[:formatter] = !config[:formatter]
-      end
-
-      # Resizes the console width and height for use with the table and pager i.e. after having resized the console window. *nix users
-      # should only have to call this method. Non-*nix users should call this method with explicit width and height. If you don't know
-      # your width and height, in irb play with "a"* width to find width and puts "a\n" * height to find height.
-      def resize(width=nil, height=nil)
-        config[:width], config[:height] = determine_terminal_size(width, height)
-        pager.resize(config[:width], config[:height])
-      end
-      
-      # This is the main method of this class. When view is enabled, this method searches for a formatter it can use for the output and if
-      # successful renders it using render_method(). The options this method takes are helper config hashes as described in 
-      # Hirb::Formatter.format_output(). Returns true if successful and false if no formatting is done or if not enabled.
-      def view_output(output, options={})
-        enabled? && config[:formatter] && render_output(output, options)
-      rescue Exception=>e
-        if config[:ignore_errors]
-          $stderr.puts "Hirb Error: #{e.message}"
-          false
-        else
-          index = (obj = e.backtrace.find {|f| f =~ /^\(eval\)/}) ? e.backtrace.index(obj) : e.backtrace.length
-          $stderr.puts "Hirb Error: #{e.message}", e.backtrace.slice(0,index).map {|e| "    " + e }
-          true
-        end
-      end
-
-      # Captures STDOUT and renders it using render_method(). The main use case is to conditionally page captured stdout.
-      def capture_and_render(&block)
-        render_method.call Util.capture_stdout(&block)
-      end
-
-      # A lambda or proc which handles the final formatted object.
-      # Although this pages/puts the object by default, it could be set to do other things
-      # i.e. write the formatted object to a file.
-      def render_method
-        @render_method ||= default_render_method
-      end
-
-      # Resets render_method back to its default.
-      def reset_render_method
-        @render_method = default_render_method
-      end
-      
-      # Current console width
-      def width
-        config && config[:width] ? config[:width] : DEFAULT_WIDTH
-      end
-
-      # Current console height
-      def height
-        config && config[:height] ? config[:height] : DEFAULT_HEIGHT
-      end
-
-      # Current formatter config, storing a hash of all static views
-      def formatter_config
-        formatter.config
-      end
-
-      # Adds a view when View is enabled. See Formatter.add_view for more details.
-      def add(klass, view_config)
-        if enabled?
-          formatter.add_view(klass, view_config)
-        else
-          puts "View must be enabled to add a view"
-        end
-      end
-
-      #:stopdoc:
-      def enable_output_method(meth)
-        if (meth ||= Object.const_defined?(:IRB) ? "IRB::Irb.output_value" : false) && !@output_method
-          @output_method = meth
-          alias_output_method(@output_method)
-        end
-      end
-
-      def unalias_output_method(output_method)
-        klass, klass_method = output_method.split(".")
-        eval %[
-          ::#{klass}.class_eval do
-            alias_method :#{klass_method}, :non_hirb_view_output
-          end
-        ]
-        @output_method = nil
-      end
-
-      def alias_output_method(output_method)
-        klass, klass_method = output_method.split(".")
-        eval %[
-          ::#{klass}.class_eval do
-            alias_method :non_hirb_view_output, :#{klass_method}
-            if '#{klass}' == "IRB::Irb"
-              def #{klass_method} #:nodoc:
-                Hirb::View.view_output(@context.last_value) || Hirb::View.page_output(@context.last_value.inspect, true) ||
-                  non_hirb_view_output
-              end
-            else
-              def #{klass_method}(output_string) #:nodoc:
-                Hirb::View.view_output(output_string) || Hirb::View.page_output(output_string.inspect, true) ||
-                  non_hirb_view_output(output_string)
-              end
-            end
-          end
-        ]
-      end
-
-      def render_output(output, options={})
-        if (formatted_output = formatter.format_output(output, options))
-          render_method.call(formatted_output)
-          true
-        else
-          false
-        end
-      end
-
-      def determine_terminal_size(width, height)
-        detected  = (width.nil? || height.nil?) ? Util.detect_terminal_size || [] : []
-        [width || detected[0] || DEFAULT_WIDTH , height || detected[1] || DEFAULT_HEIGHT]
-      end
-
-      def page_output(output, inspect_mode=false)
-        if enabled? && config[:pager] && pager.activated_by?(output, inspect_mode)
-          pager.page(output, inspect_mode)
-          true
-        else
-          false
-        end
-      end
-
-      def pager
-        @pager ||= Pager.new(config[:width], config[:height], :pager_command=>config[:pager_command])
-      end
-
-      def pager=(value); @pager = value; end
-
-      def formatter(reload=false)
-        @formatter = reload || @formatter.nil? ? Formatter.new(config[:output]) : @formatter
-      end
-
-      def formatter=(value); @formatter = value; end
-
-      def merge_or_load_config(additional_config={})
-        if @config && (@new_config_file || !additional_config.empty?)
-          Hirb.config = nil
-          load_config Util.recursive_hash_merge(@config, additional_config)
-          @new_config_file = false
-        elsif !@enabled
-          load_config(additional_config)
-        end
-      end
-
-      def load_config(additional_config={})
-        @config = Util.recursive_hash_merge default_config, additional_config
-        formatter(true)
-        true
-      end
-
-      def config_loaded?; !!@config; end
-
-      def config
-        @config
-      end
-      
-      def default_render_method
-        lambda {|output| page_output(output) || puts(output) }
-      end
-
-      def default_config
-        Util.recursive_hash_merge({:pager=>true, :formatter=>true}, Hirb.config || {})
-      end
-      #:startdoc:
-    end
-  end
-end

data/lib/bbcloud/vendor/hirb/lib/hirb/views/couch_db.rb

@@ -1,11 +0,0 @@
-module Hirb::Views::CouchDb #:nodoc:
-  def default_couch(obj)
-    {:fields=>([:_id] + obj.class.properties.map {|e| e.name }) }
-  end
-
-  alias_method :couch_rest__extended_document_view, :default_couch
-  alias_method :couch_foo__base_view, :default_couch
-  alias_method :couch_potato__persistence_view, :default_couch
-end
-
-Hirb::DynamicView.add Hirb::Views::CouchDb, :helper=>:auto_table

data/lib/bbcloud/vendor/hirb/lib/hirb/views/misc_db.rb

@@ -1,15 +0,0 @@
-module Hirb::Views::MiscDb #:nodoc:
-  def friendly__document_view(obj)
-    {:fields=>obj.class.attributes.keys - [:id]}
-  end
-
-  def ripple__document_view(obj)
-    {:fields=>obj.class.properties.keys}
-  end
-
-  def d_b_i__row_view(obj)
-    {:fields=>obj.column_names, :table_class=>Hirb::Helpers::Table}
-  end
-end
-
-Hirb::DynamicView.add Hirb::Views::MiscDb, :helper=>:auto_table

data/lib/bbcloud/vendor/hirb/lib/hirb/views/mongo_db.rb

@@ -1,14 +0,0 @@
-module Hirb::Views::MongoDb #:nodoc:
-  def mongoid__document_view(obj)
-    {:fields=>['_id'] + obj.class.fields.keys}
-  end
-
-  def mongo_mapper__document_view(obj)
-    fields = obj.class.column_names
-    fields.delete('_id') && fields.unshift('_id')
-    {:fields=>fields}
-  end
-  alias_method :mongo_mapper__embedded_document_view, :mongo_mapper__document_view
-end
-
-Hirb::DynamicView.add Hirb::Views::MongoDb, :helper=>:auto_table

data/lib/bbcloud/vendor/hirb/lib/hirb/views/orm.rb

@@ -1,11 +0,0 @@
-module Hirb::Views::ORM #:nodoc:
-  def data_mapper__resource_view(obj)
-    {:fields=>obj.class.properties.map {|e| e.name }}
-  end
-
-  def sequel__model_view(obj)
-    {:fields=>obj.class.columns}
-  end
-end
-
-Hirb::DynamicView.add Hirb::Views::ORM, :helper=>:auto_table

data/lib/bbcloud/vendor/hirb/lib/hirb/views/rails.rb

@@ -1,19 +0,0 @@
-module Hirb::Views::Rails #:nodoc:
-  def active_record__base_view(obj)
-    {:fields=>get_active_record_fields(obj)}
-  end
-
-  def get_active_record_fields(obj)
-    fields = obj.class.column_names.map {|e| e.to_sym }
-    # if query used select
-    if obj.attributes.keys.sort != obj.class.column_names.sort
-      selected_columns = obj.attributes.keys
-      sorted_columns = obj.class.column_names.dup.delete_if {|e| !selected_columns.include?(e) }
-      sorted_columns += (selected_columns - sorted_columns)
-      fields = sorted_columns.map {|e| e.to_sym}
-    end
-    fields
-  end
-end
-
-Hirb::DynamicView.add Hirb::Views::Rails, :helper=>:auto_table

data/lib/bbcloud/vendor/hirb/lib/hirb/views.rb

@@ -1,8 +0,0 @@
-module Hirb
-  # Namespace for Helpers defining multiple views in a module i.e. via DynamicView.
-  module Views
-    module Single #:nodoc:
-    end
-  end
-end
-%w{rails orm mongo_db couch_db misc_db}.each {|e| require "hirb/views/#{e}" }

data/lib/bbcloud/vendor/hirb/lib/hirb.rb

@@ -1,81 +0,0 @@
-# Needed by Hirb::String to handle multibyte characters
-$KCODE = 'u' if RUBY_VERSION < '1.9'
-
-require 'hirb/util'
-require 'hirb/string'
-require 'hirb/formatter' # must come before helpers/auto_table
-require 'hirb/dynamic_view'
-require 'hirb/helpers'
-require 'hirb/views'
-require 'hirb/view'
-require 'hirb/console'
-require 'hirb/pager'
-require 'hirb/menu'
-require 'hirb/version'
-
-# Most of Hirb's functionality is in Hirb::View.
-# For a tutorial  on configuring and creating views see Hirb::View. For a tutorial on dynamic views see Hirb::DynamicView.
-#
-# == Config Files
-# Hirb can have multiple config files defined by config_files(). These config files
-# have the following top level keys:
-# [*:output*] This hash is used by the formatter object. See Hirb::Formatter.config for its format.
-# [*:width*]  Width of the terminal/console. Defaults to Hirb::View::DEFAULT_WIDTH or possibly autodetected when Hirb is enabled.
-# [*:height*]  Height of the terminal/console. Defaults to Hirb::View::DEFAULT_HEIGHT or possibly autodetected when Hirb is enabled.
-# [*:formatter*] Boolean which determines if the formatter is enabled. Defaults to true.
-# [*:pager*] Boolean which determines if the pager is enabled. Defaults to true.
-# [*:pager_command*] Command to be used for paging. Command can have options after it i.e. 'less -r'.
-#                    Defaults to common pagers i.e. less and more if detected.
-# [*:ignore_errors*] Boolean which ignores internal view errors and continues with original view
-#                    (i.e. #inspect for irb). Defaults to false.
-module Hirb
-  class <<self
-    attr_accessor :config_files, :config
-
-    # Enables view functionality. See Hirb::View.enable for details.
-    def enable(options={}, &block)
-      View.enable(options, &block)
-    end
-
-    # Disables view functionality. See Hirb::View.disable for details.
-    def disable
-      View.disable
-    end
-
-    # Adds views. See Hirb::View.add for details.
-    def add_view(view, options, &block)
-      View.add(view, options, &block)
-    end
-
-    # Adds views. See Hirb::DynamicView.add for details.
-    def add_dynamic_view(view, options, &block)
-      DynamicView.add(view, options, &block)
-    end
-
-    # Array of config files which are merged sequentially to produce config.
-    # Defaults to config/hirb.yml and ~/.hirb_yml
-    def config_files
-      @config_files ||= default_config_files
-    end
-
-    #:stopdoc:
-    def default_config_files
-      [File.join(Util.find_home, ".hirb.yml")] +
-        (File.exists?('config/hirb.yml') ? ['config/hirb.yml'] : [])
-    end
-
-    def read_config_file(file=config_file)
-      File.exists?(file) ? YAML::load_file(file) : {}
-    end
-
-    def config(reload=false)
-      if (@config.nil? || reload)
-        @config = config_files.inject({}) {|acc,e|
-          Util.recursive_hash_merge(acc,read_config_file(e))
-        }
-      end
-      @config
-    end
-    #:startdoc:
-  end
-end

data/lib/bbcloud/vendor/hirb/test/auto_table_test.rb

@@ -1,30 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "auto table" do
-  it "converts nonarrays to arrays and renders" do
-    require 'set'
-    expected_table = <<-TABLE.unindent
-    +-------+
-    | value |
-    +-------+
-    | 1     |
-    | 2     |
-    | 3     |
-    +-------+
-    3 rows in set
-    TABLE
-    Helpers::AutoTable.render(::Set.new([1,2,3])).should == expected_table
-  end
-
-  it "renders hash" do
-    expected_table = <<-TABLE.unindent
-    +---+-------+
-    | 0 | 1     |
-    +---+-------+
-    | a | 12345 |
-    +---+-------+
-    1 row in set
-    TABLE
-    Helpers::AutoTable.render({:a=>12345}).should == expected_table
-  end
-end

data/lib/bbcloud/vendor/hirb/test/console_test.rb

@@ -1,27 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "Console" do
-  it "#table is called without Hirb enabled" do
-    extend Hirb::Console
-    reset_config
-    expected_table = <<-TABLE.unindent
-    +-------+
-    | value |
-    +-------+
-    | 5     |
-    | 3     |
-    +-------+
-    2 rows in set
-    TABLE
-    capture_stdout {
-      table([5,3], :fields=>[:to_s])
-    }.should == expected_table +"\n"
-  end
-
-  it ".render_output sets config if it wasn't before" do
-    reset_config
-    View.expects(:render_output)
-    Console.render_output('blah')
-    View.config.is_a?(Hash).should == true
-  end
-end

data/lib/bbcloud/vendor/hirb/test/deps.rip

@@ -1,4 +0,0 @@
-bacon >=1.1.0
-mocha >=0
-mocha-on-bacon >=0
-bacon-bits >=0

data/lib/bbcloud/vendor/hirb/test/dynamic_view_test.rb

@@ -1,94 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "DynamicView" do
-  def output_expects(output, expects)
-    Helpers::ObjectTable.expects(:render).with(output, expects)
-    Helpers::AutoTable.render(output)
-  end
-
-  describe "add" do
-    before_all { View.load_config }
-
-    it "raises error if no :helper option" do
-      lambda { Hirb.add_dynamic_view 'Blah', {} }.should.raise(ArgumentError).
-        message.should =~ /:helper.*required/
-    end
-
-    it "raises error if :helper option not a dynamic_view module" do
-      lambda { Hirb.add_dynamic_view('Blah', :helper=>:table) {|obj| } }.
-        should.raise(ArgumentError).message.should =~ /:helper.*must/
-    end
-
-    it "raises error if views module not a module" do
-      lambda { Hirb.add_dynamic_view 'Blah', :helper=>:auto_table }.should.raise(ArgumentError).
-        message.should =~ /must be a module/
-    end
-
-    it "adds a view with block" do
-      Hirb.add_dynamic_view('Date', :helper=>:auto_table) do |obj|
-        {:fields=>obj.class::DAYNAMES}
-      end
-      output_expects [Date.new], :fields=>Date::DAYNAMES
-    end
-
-    it "when adding views with a block, second view for same class overrides first one" do
-      Hirb.add_dynamic_view('Date', :helper=>:auto_table) do |obj|
-        {:fields=>obj.class::DAYNAMES}
-      end
-      Hirb.add_dynamic_view('Date', :helper=>:auto_table) do |obj|
-        {:fields=>[:blah]}
-      end
-      output_expects [Date.new], :fields=>[:blah]
-    end
-  end
-
-  it "class_to_method and method_to_class convert to each other" do
-    ["DBI::Row", "Hirb::View"].each do |e|
-      Helpers::AutoTable.method_to_class(DynamicView.class_to_method(e).downcase).should == e
-    end
-  end
-
-  it "class_to_method converts correctly" do
-    DynamicView.class_to_method("DBI::Row").should == 'd_b_i__row_view'
-  end
-
-  describe "dynamic_view" do
-    def define_view(mod_name= :Blah, &block)
-      mod = Views.const_set(mod_name, Module.new)
-      mod_block = block_given? ? block : lambda {|obj| {:fields=>obj.class::DAYNAMES}}
-      mod.send(:define_method, :date_view, mod_block)
-      Hirb.add_dynamic_view mod, :helper=>:auto_table
-    end
-
-    before_all { View.load_config }
-    before { Formatter.dynamic_config = {} }
-    after { Views.send(:remove_const, :Blah) }
-
-    it "sets a view's options" do
-      define_view
-      output_expects [Date.new], :fields=>Date::DAYNAMES
-    end
-
-    it "does override existing formatter dynamic_config" do
-      Formatter.dynamic_config["Date"] = {:class=>Helpers::Table}
-      define_view
-      Formatter.dynamic_config["Date"].should == {:class=>Hirb::Helpers::AutoTable, :ancestor=>true}
-    end
-
-    it "raises a readable error when error occurs in a view" do
-      define_view {|obj| raise 'blah' }
-      lambda { Helpers::AutoTable.render([Date.new]) }.should.raise(RuntimeError).
-        message.should =~ /'Date'.*date_view.*\nblah/
-    end
-
-    it "another view can reuse an old view's options" do
-      define_view
-      define_view(:Blah2) do |obj|
-        {:fields=>obj.class::DAYNAMES + ['blah']}
-      end
-      output_expects [Date.new], :fields=>(Date::DAYNAMES + ['blah'])
-    end
-    after_all { reset_config }
-  end
-  after_all { Formatter.dynamic_config = {} }
-end