Class: Graphene::ResultSet

Inherits:
Object
  • Object
show all
Includes:
OneDGraphs, Tablize, LazyEnumerable
Defined in:
lib/graphene/result_set.rb

Overview

A generic class for Graphene stat result sets, which implements Enumerable and LazyEnumerable. Calculations are performed lazily, so ResultSet objects are *cheap to create, but not necessarily cheap to use*.

Direct Known Subclasses

Percentages, Subtotals

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from OneDGraphs

#bar_chart, #pie_chart, #side_bar_chart, #side_stacked_bar_chart, #spider_chart, #stacked_bar_chart

Methods included from Tablize

#tablize

Methods included from LazyEnumerable

#==, #===, #each, included

Constructor Details

#initialize(resources, *args) ⇒ ResultSet

Accepts an array of objects, and an unlimited number of method symbols (which sould be methods in the objects). Optionally accepts an options hash as a last argument.

Implements Enumerable, so the results can be accessed by any of those methods, including each and to_a.



20
21
22
23
24
25
 
# File 'lib/graphene/result_set.rb', line 20

def initialize(resources, *args)
  @options = args.last.is_a?(Hash) ? args.pop : {}
  @attributes = args
  @resources = resources
  @results = []
end

Instance Attribute Details

#attributes ⇒ Object (readonly)

The attribute(s) that are being statted, passed in the constructor



12
13
14
 
# File 'lib/graphene/result_set.rb', line 12

def attributes
  @attributes
end

#options ⇒ Object (readonly)

The options Hash passed in the constructor



10
11
12
 
# File 'lib/graphene/result_set.rb', line 10

def options
  @options
end

#resources ⇒ Object (readonly)

The original array of objects from which the stats were generated



14
15
16
 
# File 'lib/graphene/result_set.rb', line 14

def resources
  @resources
end

Instance Method Details

#max_result ⇒ Object

Returns the maximum result



52
53
54
55
 
# File 'lib/graphene/result_set.rb', line 52

def max_result
  x = attributes.size
  sort_by { |result| result[x] }.last[x]
end

#over(over_x, filler = nil, &filler_block) ⇒ Object

Calculates the resources, gropuing them by “over_x”, which can be a method symbol or lambda

Example by date

Graphene.percentages(logs, :browser).over(:date)
=> {#<Date: 2012-07-22> => [["Firefox", 45], ["Chrome", 40], ["Internet Explorer", 15]],
    #<Date: 2012-07-23> => [["Firefox", 41], ["Chrome", 40], ["Internet Explorer", 19]],
    #<Date: 2012-07-24> => [["Chrome", 50], ["Firefox", 40], ["Internet Explorer", 10]]}

If your X objects can be put into a range, Graphene will attempt to fill in any gaps along the X axis. But if they can’t be ranged (e.g. formatted strings), you have several options to fill them in yourself:

Graphene.percentages(logs, :browser).over(->(l) { l.date.strftime('%B %Y') }, [an array of all month/year in the logs])
Graphene.percentages(logs, :browser).over(->(l) { l.date.strftime('%B %Y') }) { |str| somehow parse the month/year and return the next one }



42
43
44
 
# File 'lib/graphene/result_set.rb', line 42

def over(over_x, filler=nil, &filler_block)
  OverX.new(self, over_x, filler, &filler_block)
end

#to_s ⇒ Object

Returns a string representation of the results



47
48
49
 
# File 'lib/graphene/result_set.rb', line 47

def to_s
  to_a.to_s
end