google_data_source 0.7.6

data/lib/google_data_source/column.rb

@@ -0,0 +1,31 @@
+module GoogleDataSource
+  module DataSource
+    class Column
+      attr_accessor :type, :id, :label, :pattern
+
+      COLTYPES = %w(boolean number string date datetime timeofday)
+      #COLKEYS  = [:type, :id, :label, :pattern]
+      
+      def initialize(params)
+        @type = (params[:type] || :string).to_s
+        @id = params[:id].to_sym
+        @label = params[:label]
+        @pattern = params[:pattern]
+      end
+
+      def valid?
+        COLTYPES.include?(type)
+      end
+
+      def to_h
+        {
+          :id => id,
+          :type => type,
+          :label => label,
+          :pattern => pattern
+        }
+      end
+      
+    end
+  end
+end

data/lib/google_data_source/csv_data.rb

@@ -0,0 +1,23 @@
+require 'csv'
+#require 'action_pack'
+
+module GoogleDataSource
+  module DataSource
+    class CsvData < Base
+      #include ActionView::Helpers::NumberHelper
+      def response
+        result = CSV.generate(:col_sep => ';') do |csv|
+          csv << columns.map { |col| col.label || col.id || col.type }
+          data.each do |datarow|
+            csv << datarow.map do |c|
+              c.is_a?(Hash) ? c[:v] : c
+              # TODO
+              #value.is_a?(Float) ? number_with_delimiter(value) : value
+            end
+          end
+        end
+        result.force_encoding 'UTF-8'
+      end
+    end
+  end
+end

data/lib/google_data_source/data_date.rb

@@ -0,0 +1,17 @@
+module GoogleDataSource
+  module DataSource
+    class DataDate
+      def initialize(date)
+        @date = date
+      end
+    
+      def as_json(options=nil)
+        if @date
+          "Date(#{@date.year}, #{@date.month-1}, #{@date.day})"
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/google_data_source/data_date_time.rb

@@ -0,0 +1,17 @@
+module GoogleDataSource
+  module DataSource
+    class DataDateTime
+      def initialize(datetime)
+        @datetime = datetime
+      end
+    
+      def as_json(options=nil)
+        if @datetime
+          "Date(#{@datetime.year}, #{@datetime.month-1}, #{@datetime.day}, #{@datetime.hour}, #{@datetime.min}, #{@datetime.sec})"
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/google_data_source/helper.rb

@@ -0,0 +1,69 @@
+module GoogleDataSource
+  module DataSource
+    module Helper
+      # Includes the JavaScript files neccessary for data source visualization
+      # The helper should be called the header of the layout
+      def google_data_source_includes(ssl = false)
+        html = "<script src='http#{"s" if ssl}://www.google.com/jsapi' type='text/javascript'></script>"
+        html.html_safe
+      end
+
+      # Shows a Google visualization.
+      # Available +types+ include:
+      # * Table
+      # * TimeLine
+      # +url+ defines the URL to the data source and defaults to +url_for(:format => 'datasource').
+      # The options are generally passed to the visualization JS objects after camlizing the keys
+      # Options that are not passed include:
+      # * +:container_id+ : The Dom id of the container element
+      def google_visualization(type, url = nil, options = {})
+        # extract options that are not meant for the javascript part
+        container_id = options.delete(:container_id) || "google_#{type.underscore}"
+
+        # camelize option keys
+        js_options = options.to_a.inject({}) { |memo, opt| memo[opt.first.to_s.camelize(:lower)] = opt.last; memo }
+        
+        url ||= url_for(:format => 'datasource')
+        html = content_tag(:div, :id => container_id) { }
+        html << javascript_tag("DataSource.Visualization.create('#{type.camelize}', '#{url}', '#{container_id}', #{js_options.to_json});")
+
+        html << reporting_controls(container_id, options)
+        html
+      end
+
+      def reporting_controls(container_id, options)
+        html = tag(:div, {:id => "#{container_id}_controls", :class => "data_source_controls"}, true)
+
+        # Add Export links
+        unless options[:exportable_as].nil? || options[:exportable_as].empty?
+          html << tag(:div, {:id => "#{container_id}_export_as"}, true)
+          html << t('google_data_source.export_links.export_as')
+          html << ' '
+          options[:exportable_as].each do |format|
+            html << google_datasource_export_link(format)
+          end
+          html << ActiveSupport::SafeBuffer.new("</div>")
+        end
+
+        html << ActiveSupport::SafeBuffer.new("</div>") # ugly, any ideas?
+        html
+      end
+
+      # Returns a export link for the given format
+      def google_datasource_export_link(format)
+        label = t("google_data_source.export_links.#{format}")
+        link_to(label, '#', :class => "export_as_#{format}")
+      end
+
+      # Shows a Google data table
+      def google_datatable(url = nil, options = {})
+        google_visualization('Table', url, options)
+      end
+
+      # Shows a Google annotated timeline
+      def google_timeline(url = nil, options = {})
+        google_visualization('TimeLine', url, options)
+      end
+    end
+  end
+end

data/lib/google_data_source/html_data.rb

@@ -0,0 +1,6 @@
+module GoogleDataSource
+  module DataSource
+    class HtmlData < Base
+    end
+  end
+end

data/lib/google_data_source/invalid_data.rb

@@ -0,0 +1,14 @@
+module GoogleDataSource
+  module DataSource
+    class InvalidData < Base
+      def initialize(gviz_params)
+        super(gviz_params)
+      end
+
+      def validate
+        super
+        add_error(:out, "Invalid output format: #{@params[:out]}. Valid ones are json,csv,html")
+      end
+    end
+  end
+end

data/lib/google_data_source/json_data.rb

@@ -0,0 +1,78 @@
+module GoogleDataSource
+  module DataSource
+    class JsonData < Base
+
+      def initialize(gdata_params)
+        super(gdata_params)
+        @responseHandler = "google.visualization.Query.setResponse"
+      end
+    
+      # Returns the datasource in JSON format. It supports the +responseHandler+
+      # parameter. All the errors are returned with the +invalid_request+ key.
+      # Warnings are unsupported (yet).
+      def response
+        rsp = {}
+        rsp[:version] = @version
+        rsp[:reqId] = @params[:reqId] if @params.key?(:reqId)
+        if valid?
+          rsp[:status] = "ok"
+          rsp[:table] = datatable unless data.nil?      
+        else
+          rsp[:status] = "error"
+          rsp[:errors] = @errors.values.collect do |error|
+            { :reason => "invalid_request" , :message => error }
+          end
+        end
+        "#{@params[:responseHandler] || @responseHandler}(#{rsp.to_json});#{callback}"
+      end
+    
+      # Renders the part of the JSON response that contains the dataset.
+      def datatable
+        dt = {}
+        dt[:cols] = columns.collect(&:to_h)
+        dt[:rows] = []
+        data.each do |datarow|
+          row = []
+          datarow.each_with_index do |datacell, colnum|
+            if datacell.is_a?(Hash)
+              row << {
+                :v => convert_cell(datacell[:v], columns[colnum].type),
+                :f => datacell[:f]
+              }
+            else
+              row << { :v => convert_cell(datacell, columns[colnum].type)  }
+            end
+          end
+        
+          dt[:rows] << { :c => row }
+        end
+        return dt
+      end
+      protected :datatable
+    
+      # Converts a value in the dataset into a format suitable for the 
+      # column it belongs to. 
+      #
+      # Datasets are expected to play nice, and try to adhere to the columns they
+      # intend to export as much as possible. This method doesn't do anything more
+      # than the very minimum to ensure a formally valid gviz export.
+      def convert_cell(value, coltype)
+        case coltype
+        when "boolean"
+          !!value
+        when "number"
+          value # TODO to_i ???
+        when "string"
+          value
+        when "date"
+          DataDate.new(value.is_a?(String) ? Date.parse(value) : value) rescue nil
+        when "datetime"
+          DataDateTime.new(value.is_a?(String) ? DateTime.parse(value) : value) rescue nil
+        when "timeofday"
+          [ value.hour, value.min, value.sec, value.usec / 1000 ]
+        end
+      end
+      protected :convert_cell
+    end
+  end
+end

data/lib/google_data_source/railtie.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+# all rails specific extensions
+require 'reporting/action_controller_extension'
+require 'reporting/helper'
+require 'google_data_source/helper'
+require 'google_data_source/test_helper'
+
+module GoogleDataSource
+  class Railtie < Rails::Railtie
+    initializer 'google_data_source.initialize', :after => :after_initialize do
+      # register helper
+      ActionView::Base.send :include, GoogleDataSource::DataSource::Helper
+      ActionView::Base.send :include, GoogleDataSource::Reporting::Helper
+
+      # Register controller extension
+      #ActionController::Base.class_eval do
+      #  include GoogleDataSource::Reporting::ActionControllerExtension
+      #  alias_method_chain :render, :reporting
+      #end
+
+      # I18n
+      I18n.load_path.unshift *Dir[File.join(File.dirname(__FILE__), '..', 'locale', '*.{rb,yml}')]
+
+      # Register TemplateHandler
+      # TODO set mime type to CSV / HTML according to the output format
+      Mime::Type.register "application/json", :datasource
+
+      ActionView::Template.register_template_handler(:datasource, 
+        GoogleDataSource::DataSource::TemplateHandler
+      )
+
+      
+    end
+  end
+end

data/lib/google_data_source/sql/models.rb

@@ -0,0 +1,266 @@
+module GoogleDataSource
+  module DataSource
+    module Sql
+      class WithHelpers
+        class << self
+          include RParsec::DefHelper
+        end
+      end
+
+      class Expr < WithHelpers
+        def self.binary(*ops)
+          ops.each do |op|
+            define_method(op) do |other|
+              BinaryExpr.new(self, op, other)
+            end
+          end
+        end
+        binary :+,:-,:*,:/,:%
+        def -@
+          PrefixExpr.new(:-, self)
+        end
+        def self.compare(*ops)
+          ops.each do |op|
+            define_method(op) do |other|
+              ComparePredicate.new(self, op, other)
+            end
+          end
+        end
+        compare :'==', :'>', :'<', :'>=', :'<='
+      end
+
+      class LiteralExpr < Expr
+        def_readable :lit
+        def to_s
+          lit
+        end
+      end
+
+      class VarExpr < Expr
+        def_readable :name
+        def to_s
+          "$#{name}"
+        end
+      end
+
+      class WordExpr < Expr
+        def_readable :name
+        def to_s
+          name
+        end
+      end
+
+      class QualifiedColumnExpr < Expr
+        def_readable :owner, :col
+        def to_s
+          "#{owner}.#{col}"
+        end
+      end
+
+      class WildcardExpr < Expr
+        Instance = WildcardExpr.new
+        def to_s
+          '*'
+        end
+      end
+
+      class BinaryExpr < Expr
+        def_readable :left, :op, :right
+        def to_s
+          "(#{left} #{op} #{right})"
+        end
+      end
+
+      class PostfixExpr < Expr
+        def_readable :expr, :op
+        def to_s
+          "(#{expr} #{op})"
+        end
+      end
+
+      class PrefixExpr < Expr
+        def_readable :op, :expr
+        def to_s
+          "(#{op} #{expr})"
+        end
+      end
+
+      def cases_string cases, default, result
+          cases.each do |cond, val|
+            result << " when #{cond}: #{val}"
+          end
+          unless default.nil?
+            result << " else #{default}"
+          end
+          result << " end"
+          result
+      end
+
+      class SimpleCaseExpr < Expr
+        def_readable :expr, :cases, :default
+        def to_s
+          cases_string cases, default, "case #{expr}"
+        end
+      end
+
+      class CaseExpr < Expr
+        def_readable :cases, :default
+        def to_s
+          cases_string cases, default, 'case'
+        end
+      end
+
+
+      ############Predicate########################
+      class Predicate < WithHelpers
+        include RParsec::DefHelper
+      end
+
+      class ComparePredicate < Predicate
+        def_readable :left, :op, :right
+
+        def to_s
+          "#{left} #{op_name} #{right}"
+        end
+
+        def op_name
+          case op when :"!=" then "<>" else op.to_s end
+        end
+      end
+
+      class CompoundPredicate < Predicate
+        def_readable :left, :op, :right
+        def to_s
+          "(#{left} #{op} #{right})"
+        end
+      end
+
+      class NotPredicate < Predicate
+        def_readable :predicate
+        def to_s
+          "(not #{predicate})"
+        end
+      end
+
+      class ExistsPredicate < Predicate
+        def_readable :relation
+        def to_s
+          "exists(#{relation})"
+        end
+      end
+
+      class NotExistsPredicate < Predicate
+        def_readable :relation
+        def to_s
+          "not exists(#{relation})"
+        end
+      end
+
+      class InRelationPredicate < Predicate
+        def_readable :expr, :relation
+        def to_s
+          "#{expr} in (#{relation})"
+        end
+      end
+
+      class NotInRelationPredicate < Predicate
+        def_readable :expr, :relation
+        def to_s
+          "#{expr} not in (#{relation})"
+        end
+      end
+
+      class InPredicate < Predicate
+        def_readable :expr, :vals
+        def to_s
+          "#{expr} in (#{vals.join(', ')})"
+        end
+      end
+
+      class NotInPredicate < Predicate
+        def_readable :expr, :vals
+        def to_s
+          "#{expr} not in (#{vals.join(', ')})"
+        end
+      end
+
+      class BetweenPredicate < Predicate
+        def_readable :expr, :from, :to
+        def to_s
+          "#{expr} between #{from} and #{to}"
+        end
+      end
+
+      class NotBetweenPredicate < Predicate
+        def_readable :expr, :from, :to
+        def to_s
+          "#{expr} not between #{from} and #{to}"
+        end
+      end
+
+      class GroupComparisonPredicate < Predicate
+        def_readable :group1, :op, :group2
+        def to_s
+          "#{list_exprs group1} #{op} #{list_exprs group2}"
+        end
+        def list_exprs exprs
+          "(#{exprs.join(', ')})"
+        end
+      end
+      #############Relations######################
+
+      class OrderElement < WithHelpers
+        def_readable :expr, :asc
+        def to_s
+          result = "#{expr}"
+          unless asc
+            result << ' desc'
+          end
+          result
+        end
+      end
+
+      class GroupByClause < WithHelpers
+        def_readable :exprs, :having
+        def to_s
+          result = exprs.join(', ')
+          unless having.nil?
+            result << " having #{having}"
+          end
+          result
+        end
+      end
+
+      class Relation < WithHelpers
+        def as_inner
+          to_s
+        end
+      end
+
+      class SelectRelation < Relation
+        def_readable :select, :where, :groupby, :orderby, :limit, :offset
+
+        def to_s
+          result = "select"
+          result << " #{select.join(', ')}"
+          unless where.nil?
+            result << " where #{where}"
+          end
+          unless groupby.nil?
+            result << " group by #{groupby}"
+          end
+          unless orderby.nil?
+            result << " order by #{orderby.join(', ')}"
+          end
+          unless limit.nil?
+            result << " limit #{limit}"
+          end
+          unless offset.nil?
+            result << " offset #{offset}"
+          end
+          result
+        end
+      end
+    end
+  end
+end