Module: Hirb::View

Defined in:
lib/hirb/view.rb

Overview

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.

Constant Summary collapse

DEFAULT_WIDTH = 
120
DEFAULT_HEIGHT = 
40

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.config ⇒ Object (readonly)

Returns the value of attribute config.



67
68
69
 
# File 'lib/hirb/view.rb', line 67

def config
  @config
end

.render_method ⇒ Object

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.



143
144
145
 
# File 'lib/hirb/view.rb', line 143

def render_method
  @render_method
end

Class Method Details

.add(klass, view_config) ⇒ Object

Adds a view when View is enabled. See Formatter.add_view for more details.



168
169
170
171
172
173
174
 
# File 'lib/hirb/view.rb', line 168

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

.capture_and_render(&block) ⇒ Object

Captures STDOUT and renders it using render_method(). The main use case is to conditionally page captured stdout.



136
137
138
 
# File 'lib/hirb/view.rb', line 136

def capture_and_render(&block)
  render_method.call Util.capture_stdout(&block)
end

.config_loaded? ⇒ Boolean

Returns:

  • (Boolean) 


254
 
# File 'lib/hirb/view.rb', line 254

def config_loaded?; !!@config; end

.default_config ⇒ Object 



264
265
266
 
# File 'lib/hirb/view.rb', line 264

def default_config
  Util.recursive_hash_merge({:pager=>true, :formatter=>true}, Hirb.config || {})
end

.default_render_method ⇒ Object 



260
261
262
 
# File 'lib/hirb/view.rb', line 260

def default_render_method
  lambda {|output| page_output(output) || puts(output) }
end

.determine_terminal_size(width, height) ⇒ Object 



212
213
214
215
 
# File 'lib/hirb/view.rb', line 212

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

.disable ⇒ Object

Disable’s Hirb’s output and revert’s irb’s output method if irb exists.



95
96
97
98
99
 
# File 'lib/hirb/view.rb', line 95

def disable
  @enabled = false
  disable_output_method if @output_method
  false
end

.disable_output_method ⇒ Object 



192
193
194
195
196
197
 
# File 'lib/hirb/view.rb', line 192

def disable_output_method
  if defined?(IRB::Irb) && !defined? Ripl
    ::IRB::Irb.send :alias_method, :output_value, :non_hirb_view_output
  end
  @output_method = nil
end

.enable(options = {}, &block) ⇒ Object

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

Examples:

Hirb.enable
Hirb.enable :formatter=>false



78
79
80
81
82
83
84
85
86
87
 
# File 'lib/hirb/view.rb', line 78

def enable(options={}, &block)
  Array(options.delete(:config_file)).each {|e|
    @new_config_file = true
    Hirb.config_files << e
  }
  enable_output_method unless @output_method
  merge_or_load_config options
  resize(config[:width], config[:height])
  @enabled = true
end

.enable_output_method ⇒ Object

:stopdoc:



177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/hirb/view.rb', line 177

def enable_output_method
  if defined?(Ripl) && Ripl.respond_to?(:started?) && Ripl.started?
    @output_method = true
    require 'ripl/hirb' unless defined? Ripl::Hirb
  elsif defined? IRB::Irb
    @output_method = true
    ::IRB::Irb.class_eval do
      alias_method :non_hirb_view_output, :output_value
      def output_value #:nodoc:
        Hirb::View.view_or_page_output(@context.last_value) || non_hirb_view_output
      end
    end
  end
end

.enabled? ⇒ Boolean

Indicates if Hirb::View is enabled.

Returns:

  • (Boolean) 


90
91
92
 
# File 'lib/hirb/view.rb', line 90

def enabled?
  @enabled || false
end

.formatter(reload = false) ⇒ Object 



232
233
234
 
# File 'lib/hirb/view.rb', line 232

def formatter(reload=false)
  @formatter = reload || @formatter.nil? ? Formatter.new(config[:output]) : @formatter
end

.formatter=(value) ⇒ Object 



236
 
# File 'lib/hirb/view.rb', line 236

def formatter=(value); @formatter = value; end

.formatter_config ⇒ Object

Current formatter config, storing a hash of all static views



163
164
165
 
# File 'lib/hirb/view.rb', line 163

def formatter_config
  formatter.config
end

.height ⇒ Object

Current console height



158
159
160
 
# File 'lib/hirb/view.rb', line 158

def height
  config && config[:height] ? config[:height] : DEFAULT_HEIGHT
end

.load_config(additional_config = {}) ⇒ Object 



248
249
250
251
252
 
# File 'lib/hirb/view.rb', line 248

def load_config(additional_config={})
  @config = Util.recursive_hash_merge default_config, additional_config
  formatter(true)
  true
end

.merge_or_load_config(additional_config = {}) ⇒ Object 



238
239
240
241
242
243
244
245
246
 
# File 'lib/hirb/view.rb', line 238

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

.page_output(output, inspect_mode = false) ⇒ Object 



217
218
219
220
221
222
223
224
 
# File 'lib/hirb/view.rb', line 217

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

.pager ⇒ Object 



226
227
228
 
# File 'lib/hirb/view.rb', line 226

def pager
  @pager ||= Pager.new(config[:width], config[:height], :pager_command=>config[:pager_command])
end

.pager=(value) ⇒ Object 



230
 
# File 'lib/hirb/view.rb', line 230

def pager=(value); @pager = value; end

.render_output(output, options = {}) ⇒ Object 



203
204
205
206
207
208
209
210
 
# File 'lib/hirb/view.rb', line 203

def render_output(output, options={})
  if (formatted_output = formatter.format_output(output, options))
    render_method.call(formatted_output)
    true
  else
    false
  end
end

.reset_render_method ⇒ Object

Resets render_method back to its default.



148
149
150
 
# File 'lib/hirb/view.rb', line 148

def reset_render_method
  @render_method = default_render_method
end

.resize(width = nil, height = nil) ⇒ Object

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 “an” * height to find height.



114
115
116
117
 
# File 'lib/hirb/view.rb', line 114

def resize(width=nil, height=nil)
  config[:width], config[:height] = determine_terminal_size(width, height)
  pager.resize(config[:width], config[:height])
end

.toggle_formatter ⇒ Object

Toggles formatter on or off.



107
108
109
 
# File 'lib/hirb/view.rb', line 107

def toggle_formatter
  config[:formatter] = !config[:formatter]
end

.toggle_pager ⇒ Object

Toggles pager on or off. The pager only works while Hirb::View is enabled.



102
103
104
 
# File 'lib/hirb/view.rb', line 102

def toggle_pager
  config[:pager] = !config[:pager]
end

.view_or_page_output(str) ⇒ Object 



199
200
201
 
# File 'lib/hirb/view.rb', line 199

def view_or_page_output(str)
  view_output(str) || page_output(str.inspect, true)
end

.view_output(output, options = {}) ⇒ Object

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.



122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/hirb/view.rb', line 122

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

.width ⇒ Object

Current console width



153
154
155
 
# File 'lib/hirb/view.rb', line 153

def width
  config && config[:width] ? config[:width] : DEFAULT_WIDTH
end