wayneeseguin-dynamic_reports 0.0.2

data/lib/dynamic_reports/reports.rb

@@ -0,0 +1,268 @@
+# DynamicReports
+#
+# Dynamic Reporting Engine for Ruby / Rails
+module DynamicReports
+
+  # DynamicReports::Report
+  # 
+  class Report
+    @@default_engine = "erb"
+
+    attr_accessor :name, :title, :sub_title, :columns, :charts, :records, :template, :class_name, :styles
+
+    # views accessor, array of view paths.
+    def views
+      @views
+    end
+
+    # options accessor, all report options and configuration is stored in this.
+    def options
+      @options
+    end
+
+    class << self
+      # Views setter and accessor.
+      def views(*array)
+        @views ||= ["#{File::dirname(File::expand_path(__FILE__))}/views/"]
+        unless array.empty?
+          @views.unshift(array)
+          @views.flatten!
+          @views.uniq!
+        else
+          @views
+        end
+      end
+     
+      # class level options accessor
+      def options
+        @options ||= {}
+      end
+
+      # class level name accessor & setter
+      # 
+      # Set the name of the report, for example: 
+      #
+      #   name "Orders Report"
+      #
+      def name(value = nil)
+        if value 
+          options[:name] = value
+        else 
+          # TODO: snake_case_the_name
+          options[:name] || self.class.name
+        end
+      end
+      
+      # Accessor used to set the title:
+      #
+      #   title "All orders for the account"
+      #
+      # Or to access the already set title:
+      #
+      #   OrdersReport.title
+      # 
+      #   #=> "All orders for the account"
+      #
+      def title(value = nil)
+        value ? options[:title] = value : options[:title]
+      end
+      
+      # Accessor used to set the sub title:
+      #
+      #   sub_title "All orders for the account"
+      #
+      # Or to access the already set sub title:
+      #
+      #   OrdersReport.sub_title
+      # 
+      #   #=> "All orders for the account"
+      #
+      def sub_title(value = nil)
+        value ? options[:sub_title] = value : options[:sub_title]
+      end
+
+      def styles
+        options[:styles] ||= false
+      end
+
+      def class_name(value = nil)
+        if value
+          options[:class_name] = value
+        elsif options[:class_name].empty?
+          options[:class_name] = self.to_s
+        else
+          options[:class_name]
+        end
+      end
+      
+      # Accessor for the template to use for the report.
+      #
+      # Example:
+      #
+      #   template :orders # => renders orders.html.erb (erb is the default engine)
+      #
+      # Used without argument returns the template set for the report.
+      #
+      #   OrdersReport.template # => :orders
+      #
+      def template(value = nil)
+        if value
+          @template = value
+          options[:template] = @template
+        end
+        @template ||= nil
+      end
+
+      # Accessor for columns
+      #
+      # Pass an array of symbols to define columns on the report
+      #
+      # Example:
+      #
+      #   columns :total, :created_at
+      #
+      # Calling the class method with no arguments will return an array with the defined columns.
+      #
+      # Example:
+      #
+      #   OrdersReport.columns
+      #
+      #   # => [:total, :created_at]
+      #
+      def columns(*array)
+        unless array.empty?
+          if (array.class == Array)
+            options[:columns] = array
+          else
+            raise "Report columns must be specified."
+          end
+        else
+          options[:columns]
+        end
+      end
+
+      # Return the chart with the specified name, if it exists. nil otherwise.
+      def chart_with_name(name)
+        options[:charts].to_a.detect{ |c| c.name == name.to_sym }
+      end
+
+      # Return an array of charts defined for the report.
+      def charts(object=nil)
+        options[:charts] ||= [] 
+        options[:charts] << object if object
+        options[:charts]
+      end
+
+      # Define a chart for the report
+      #
+      # Example:
+      #   chart :PV_Visits, {:grxl => 'xxxxx'} do
+      #     title "Pageviews and Visits"
+      #     columns [:pageviews, :visits]
+      #     no_labels false
+      #     label_column "recorded_at"
+      #     width "400"
+      #     height "350"
+      #     type "line"
+      #   end
+      # 
+      def chart(name, *chart_options, &block)
+        chart_options = chart_options.shift || {}
+        charts(Chart.configure(name, chart_options, &block))
+      end
+
+      # Method for instanciating a report instance on a set of given records.
+      #
+      # Example:
+      #
+      # OrdersReport.on(@records)
+      #
+      # Where @records is an array of
+      #
+      # * Objects that respond to methods for all columns defined on the report
+      # * Hashes that have keys corresponding to all columns defined on the report
+      #
+      # This will return an instance of the OrdersReport bound to @records
+      #
+      def on(records)
+        new(records, @options)
+      end
+
+      #--
+      # Methods for definining a sub report
+      #def link_column
+      #end
+      #def link_rows
+      #end
+
+    end
+
+    # Instantiate the report on a set of records.
+    #
+    # Example:
+    #
+    # OrdersReport.new(@records)
+    #
+    # options is a set of optional overrides for 
+    #
+    # * views - Used to override the class defined views.
+    # * template - Used to override the class defined template.
+    #
+    def initialize(records, *new_options)
+      new_options  = new_options.shift || {}
+      @records = records
+
+      @views = self.class.views
+      @views.unshift(new_options.delete(:views)) if new_options[:views]
+      @views.flatten!
+      @views.uniq!
+
+      @template = self.class.template
+      @template = new_options.delete(:template) if new_options[:template]
+
+      @options = self.class.options.merge!(new_options)
+      @options.each_pair do |key,value|
+        if key == "chart"
+          # TODO: erh?
+          self.chart(value[:name],{},value)
+        else
+          instance_variable_set("@#{key}".to_sym, value)
+        end
+      end
+    end
+
+    # Convert an instance of a report bound to a records set to an html view
+    #
+    # Example
+    #
+    # OrdersReport.on(@records).to_html
+    #
+    # [options]
+    #   :engine - one of  :erb, :haml, :csv, :pdf
+    #
+    # Note: CSV & PDF forthcoming.
+    #
+    def to_html(*options)
+      view    = View.new(self)
+      # todo: this is not clean...
+      options = (options.shift || {}).merge!(@options || {})
+      # todo: if rails is loaded set the default engine: dynamicreports::report.default_engine
+      engine  = options.delete(:engine) || @@default_engine
+      options[:template] = self.class.template
+      view.__send__("#{engine}", options)
+    end
+
+    # Not Implemented Yet
+    def to_csv
+      # TODO: Write csv hook
+    end
+
+    # Not Implemented Yet
+    def to_pdf
+      # TODO: Write pdf hook
+    end
+
+  end
+
+end
+

data/lib/dynamic_reports/templates.rb

@@ -0,0 +1,178 @@
+module DynamicReports
+  # Options are:
+  #   :layout       If set to false, no layout is rendered, otherwise
+  #                 the specified layout is used
+  #   :locals       A hash with local variables that should be available
+  #                 in the template
+  module Templates
+    def csv(options={}, locals={})
+      template = options.delete(:template)
+      render :csv, template, options.merge!(:content_type => "csv"), locals
+    end
+
+    def erb(options={}, locals={})
+      require "erb"
+      template = options.delete(:template)
+      render :erb, template, options, locals
+    end
+
+    def haml(options={}, locals={})
+      require_warn("Haml") unless defined?(::Haml::Engine)
+      template = options.delete(:template)
+      render :haml, template, options, locals
+    end
+
+    def builder(options={}, locals={}, &block)
+      require_warn("Builder") unless defined?(::Builder)
+      template = options.delete(:template)
+      options, template = template, nil if template.is_a?(Hash)
+      template = lambda { block } if template.nil?
+      render :builder, template, options, locals
+    end
+
+    # TODO: Add Report Helpers for injection
+    def titleize(object)
+      object.to_s.split('_').each{ |word| word.capitalize! }.join(' ') 
+    end
+
+    def commify(object)
+      if object.is_a?(Numeric)
+        object.to_s.gsub(/(\d)(?=(\d{3})+$)/,'\1,')
+      else
+        object
+      end
+    end
+
+    def chart_url(chart,report)
+      columns = chart.columns ? chart.columns : report.columns
+      chart_type = chart.type.nil? ?  :line : chart.type.to_sym 
+      case chart_type
+      when :line
+        Charts.line_chart(chart,columns,report)
+      when :pie
+        Charts.pie_chart(chart,columns,report)
+      when :bar
+        Charts.bar_column_chart(chart,columns,report,:vertical)
+      when :column
+        Charts.bar_column_chart(chart,columns,report,:horizontal)
+      else
+        raise StandardError => "Unknown chart type '#{chart.type}'."
+      end
+
+    end
+
+    private
+    
+    def render(engine, template, options={}, locals={})
+      # merge app-level options
+      options = self.class.send(engine).merge(options) if self.class.respond_to?(engine)
+
+      # extract generic options
+      layout = options.delete(:layout)
+      layout = :default_layout if (layout.nil? || layout == true)
+      views  = options.delete(:views) || self.views
+      content_type = options.delete(:content_type)
+      locals = options.delete(:locals) || locals || {}
+      locals.merge!(:report => @report, :options => options || {})
+      
+      # render template
+      data, options[:filename], options[:line] = lookup_template(engine, template, views, content_type)
+      output = __send__("render_#{engine}", template, data, options, locals)
+      # render layout
+      # TODO: Fix Layout Rendering & Specify Layout
+      if layout
+        data, options[:filename], options[:line] = lookup_layout(engine, layout, views, content_type)
+        if data
+          output = __send__("render_#{engine}", layout, data, options, {}) { output }
+        end
+      end
+      output
+    end
+
+    def lookup_template(engine, template, views, content_type = nil, filename = nil, line = nil)
+      content_type = "html" if content_type.nil? or content_type.blank?
+      if (template.nil? || template == '')
+        template = :default_template
+        #views = DefaultReport.default_view_paths
+      end
+      case template
+      when Symbol
+        if cached = self.class.cached_templates[template]
+          lookup_template(engine, cached[:template], views, content_type, cached[:filename], cached[:line])
+        else
+          filename = "#{template}.#{content_type}.#{engine}"
+          dir = views.to_a.detect do |view| 
+            ::File.exists?(::File.join(view, filename))
+          end
+          if dir
+            path = ::File.join(dir, filename)
+          else
+            path = ::File.join(::File::dirname(::File::expand_path(__FILE__)), "views","default_report.#{content_type}.#{engine}")
+          end
+          [ ::File.read(path), path, 1 ]
+        end
+      when Proc
+        filename, line = self.class.caller_locations.first if filename.nil?
+        [ template.call, filename, line.to_i ]
+      when String
+        filename, line = self.class.caller_locations.first if filename.nil?
+        [ template, filename, line.to_i ]
+      else
+        raise ArgumentError, "Template was not specified properly: '#{template}'."
+      end
+    end
+
+    def lookup_layout(engine, template, views, content_type)
+      lookup_template(engine, template, views, content_type)
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def render_csv(template, data, options, locals, &block)
+      # TODO: Implement this.
+    end
+
+    def render_erb(template, data, options, locals, &block)
+      original_out_buf = defined?(@_out_buf) && @_out_buf
+      data = data.call if data.kind_of? Proc
+
+      instance = ::ERB.new(data, nil, nil, "@_out_buf")
+      locals_assigns = locals.to_a.collect { |k,v| "#{k} = locals[:#{k}]" }
+
+      filename = options.delete(:filename) || "(__ERB__)"
+      line = options.delete(:line) || 1
+      line -= 1 if instance.src =~ /^#coding:/
+
+      render_binding = binding
+      eval locals_assigns.join("\n"), render_binding
+      eval instance.src, render_binding, filename, line
+      @_out_buf, result = original_out_buf, @_out_buf
+      result
+    end
+
+    def render_haml(template, data, options, locals, &block)
+      ::Haml::Engine.new(data, options).render(self, locals, &block)
+    end
+
+    def render_builder(template, data, options, locals, &block)
+      options = { :indent => 2 }.merge(options)
+      filename = options.delete(:filename) || "<BUILDER>"
+      line = options.delete(:line) || 1
+      xml = ::Builder::XmlMarkup.new(options)
+      if data.respond_to?(:to_str)
+        eval data.to_str, binding, filename, line
+      elsif data.kind_of?(Proc)
+        data.call(xml)
+      end
+      xml.target!
+    end
+
+    def require_warn(engine)
+      warn "Auto-require of #{engine} is deprecated; add require \"#{engine}\" to your app."
+      require engine.downcase
+    end
+
+ 
+    
+  end
+end

data/lib/dynamic_reports/vendor/google_chart/bar_chart.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/base'
+module GoogleChart
+  # Generates a Bar Chart. You can specify the alignment(horizontal or vertical) and whether you want the bars to be grouped or stacked
+  # ==== Examples
+  #     bc = GoogleChart::BarChart.new('800x200', "Bar Chart", :vertical, false)
+  #     bc.data "Trend 1", [5,4,3,1,3,5], '0000ff'     
+  class BarChart < Base
+    
+    attr_accessor :alignment, :stacked
+    
+    # Specify the 
+    # * +chart_size+ in WIDTHxHEIGHT format
+    # * +chart_title+ as a string
+    # * +alignment+ as either <tt>:vertical</tt> or <tt>:horizontal</tt>
+    # * +stacked+ should be +true+ if you want the bars to be stacked, false otherwise
+    def initialize(chart_size='300x200', chart_title=nil, alignment=:vertical, stacked=false) # :yield: self
+      super(chart_size, chart_title)
+      @alignment = alignment
+      @stacked = stacked
+      set_chart_type
+      self.show_legend = true
+      yield self if block_given?
+    end
+    
+    # Set the alignment to either <tt>:vertical</tt> or <tt>:horizontal</tt>
+    def alignment=(value)
+      @alignment = value
+      set_chart_type
+    end
+    
+    # If you want the bar chart to be stacked, set the value to <tt>true</tt>, otherwise set the value to <tt>false</tt> to group it.
+    def stacked=(value)
+      @stacked = value
+      set_chart_type
+    end
+
+    # Defines options for bar width, spacing between bars and between groups of bars. Applicable for bar charts.
+    # [+options+] : Options for the style, specifying things like line thickness and lengths of the line segment and blank portions
+    #
+    # ==== Options
+    # * <tt>:bar_width</tt>, Bar width in pixels
+    # * <tt>:bar_spacing</tt> (optional), space between bars in a group
+    # * <tt>:group_spacing</tt> (optional), space between groups
+    def width_spacing_options(options={})
+      options_str = "#{options[:bar_width]}"
+      options_str += ",#{options[:bar_spacing]}" if options[:bar_spacing]
+      options_str += ",#{options[:group_spacing]}" if options[:bar_spacing] and options[:group_spacing]
+      @bar_width_spacing_options = options_str
+    end
+
+    def process_data
+      if @stacked # Special handling of max value for stacked
+        unless @max_data # Unless max_data is explicitly set
+          @max_data = @data.inject([]) do |sum_arr, series| 
+            series.each_with_index do |v,i| 
+              if sum_arr[i] == nil
+                sum_arr[i] = v
+              else
+                sum_arr[i] += v
+              end
+            end
+            sum_arr
+          end.max
+        end
+      end
+
+      if @data.size > 1              
+        join_encoded_data(@data.collect { |series|
+                            encode_data(series, max_data_value)
+                          })
+      else
+        encode_data(@data.flatten,max_data_value)
+      end
+    end
+    
+    private
+    def set_chart_type
+      # Set chart type
+      if alignment == :vertical and stacked == false
+        self.chart_type = :bvg
+      elsif alignment == :vertical and stacked == true
+        self.chart_type = :bvs
+      elsif alignment == :horizontal and stacked == false
+        self.chart_type = :bhg
+      elsif alignment == :horizontal and stacked == true
+        self.chart_type = :bhs
+      end          
+    end
+  end
+end