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 "a\n" * 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