google_data_source 0.7.6

data/lib/google_data_source/sql/parser.rb

@@ -0,0 +1,239 @@
+module GoogleDataSource
+  module DataSource
+    module Sql
+      class ::Method; include RParsec::FunctorMixin; end
+      class ::Proc; include RParsec::FunctorMixin; end
+
+      module Parser
+        include RParsec
+        include Functors
+        include Parsers
+
+        extend Parsers
+        # TODO drop keywords
+        MyKeywords = Keywords.case_insensitive(%w{
+          select from where group by having order desc asc
+          inner left right full outer inner join on cross
+          union all distinct as exists in between limit offset
+          case when else end and or not true false
+        })
+        MyOperators = Operators.new(%w{+ - * / % = > < >= <= <> != : ( ) . ,})
+        def self.operators(*ops)
+          result = []
+          ops.each do |op|
+            result << (MyOperators[op] >> op.to_sym)
+          end
+          sum(*result)
+        end
+        Comparators = operators(*%w{= > < >= <= <> !=})
+        quote_mapper = Proc.new do |raw|
+          # is this really different to raw.gsub! ???
+          raw.replace(raw.gsub(/\\'/, "'").gsub(/\\\\/, "\\"))
+        end
+
+        StringLiteral = char(?') >> ((str("\\\\")|str("\\'")|not_char(?')).many_.fragment).map(&quote_mapper) << char(?')
+        QuotedName    = char(?`) >> not_char(?`).many_.fragment << char(?`)
+        Variable = char(?$) >> word
+        MyLexer = number.token(:number) | StringLiteral.token(:string) | Variable.token(:var) |
+          QuotedName.token(:word) | MyKeywords.lexer | MyOperators.lexer
+        MyLexeme = MyLexer.lexeme(whitespaces | comment_line('#')) << eof
+        
+        
+        ######################################### utilities #########################################
+        def keyword
+          MyKeywords
+        end
+
+        def operator
+          MyOperators
+        end
+
+        def comma
+          operator[',']
+        end
+
+        def list expr
+          paren(expr.delimited(comma))
+        end
+
+        def word(&block)
+          if block.nil?
+            token(:word, &Id)
+          else
+            token(:word, &block)
+          end
+        end 
+
+        def paren parser
+          operator['('] >> parser << operator[')']
+        end
+
+        def ctor cls
+          cls.method :new
+        end
+
+        def rctor cls, arity=2
+          ctor(cls).reverse_curry arity
+        end
+
+        ################################### predicate parser #############################
+        def logical_operator op
+          proc{|a,b|CompoundPredicate.new(a,op,b)}
+        end
+
+        def make_predicate expr, rel
+          expr_list = list expr
+          comparison = make_comparison_predicate expr, rel
+          group_comparison = sequence(expr_list, Comparators, expr_list, &ctor(GroupComparisonPredicate))
+          bool = nil
+          lazy_bool = lazy{bool}
+          bool_term = keyword[:true] >> true | keyword[:false] >> false |
+            comparison | group_comparison | paren(lazy_bool) |
+            make_exists(rel) | make_not_exists(rel)
+          bool_table = OperatorTable.new.
+            infixl(keyword[:or] >> logical_operator(:or), 20).
+            infixl(keyword[:and] >> logical_operator(:and), 30).
+            prefix(keyword[:not] >> ctor(NotPredicate), 40)
+          bool = Expressions.build(bool_term, bool_table)
+        end
+
+        def make_exists rel
+          keyword[:exists] >> rel.map(&ctor(ExistsPredicate))
+        end
+
+        def make_not_exists rel
+          keyword[:not] >> keyword[:exists] >> rel.map(&ctor(NotExistsPredicate))
+        end
+
+        def make_in expr
+          keyword[:in] >> list(expr) >> map(&rctor(InPredicate))
+        end
+
+        def make_not_in expr
+          keyword[:not] >> keyword[:in] >> list(expr) >> map(&rctor(NotInPredicate))
+        end
+
+        def make_in_relation rel
+          keyword[:in] >> rel.map(&rctor(InRelationPredicate))
+        end
+
+        def make_not_in_relation rel
+          keyword[:not] >> keyword[:in] >> rel.map(&rctor(NotInRelationPredicate))
+        end
+
+        def make_between expr
+          make_between_clause(expr, &ctor(BetweenPredicate))
+        end
+
+        def make_not_between expr
+          keyword[:not] >> make_between_clause(expr, &ctor(NotBetweenPredicate))
+        end
+
+        def make_comparison_predicate expr, rel
+          comparison = sequence(Comparators, expr) do |op,e2|
+            proc{|e1|ComparePredicate.new(e1, op, e2)}
+          end
+          in_clause = make_in expr
+          not_in_clause = make_not_in expr
+          in_relation = make_in_relation rel
+          not_in_relation = make_not_in_relation rel
+          between = make_between expr
+          not_between = make_not_between expr
+          compare_with = comparison | in_clause | not_in_clause |
+              in_relation | not_in_relation | between | not_between
+          sequence(expr, compare_with, &Feed)
+        end
+
+        def make_between_clause expr, &maker
+          factory = proc do |a,_,b|
+            proc {|v|maker.call(v,a,b)}
+          end
+          variant1 = keyword[:between] >> paren(sequence(expr, comma, expr, &factory))
+          variant2 = keyword[:between] >> sequence(expr, keyword[:and], expr, &factory)
+          variant1 | variant2
+        end
+        
+        ################################ expression parser ###############################
+        def calculate_simple_cases(val, cases, default)
+          SimpleCaseExpr.new(val, cases, default)
+        end
+
+        def calculate_full_cases(cases, default)
+          CaseExpr.new(cases, default)
+        end
+
+        def make_expression predicate, rel
+          expr = nil
+          lazy_expr = lazy{expr}
+
+          wildcard = operator[:*] >> WildcardExpr::Instance
+          lit = token(:number, :string, &ctor(LiteralExpr)) | token(:var, &ctor(VarExpr))
+          atom = lit | wildcard | word(&ctor(WordExpr))
+          term = atom | (operator['('] >> lazy_expr << operator[')'])
+
+          table = OperatorTable.new.
+            infixl(operator['+'] >> Plus, 20).
+            infixl(operator['-'] >> Minus, 20).
+            infixl(operator['*'] >> Mul, 30).
+            infixl(operator['/'] >> Div, 30).
+            infixl(operator['%'] >> Mod, 30).
+            prefix(operator['-'] >> Neg, 50)
+          expr = Expressions.build(term, table)
+        end
+        
+        ################################ relation parser ###############################
+        def make_relation expr, pred
+          where_clause = keyword[:where] >> pred
+          order_element = sequence(expr, (keyword[:asc] >> true | keyword[:desc] >> false).optional(true),
+            &ctor(OrderElement))
+          order_elements = order_element.separated1(comma)
+          exprs = expr.separated1(comma)
+
+          # setup clauses
+          select_clause = keyword[:select] >> exprs
+          order_by_clause = keyword[:order] >> keyword[:by] >> order_elements
+          group_by = keyword[:group] >> keyword[:by] >> exprs
+          group_by_clause = sequence(group_by, (keyword[:having] >> pred).optional, &ctor(GroupByClause))
+          limit_clause = keyword[:limit] >> token(:number, &To_i)
+          offset_clause = keyword[:offset] >> token(:number, &To_i)
+
+          # build relation
+          relation = sequence(
+            select_clause.optional([WildcardExpr.new]),
+            where_clause.optional, group_by_clause.optional, order_by_clause.optional,
+            limit_clause.optional, offset_clause.optional
+          ) do |select, where, groupby, orderby, limit, offset|
+            SelectRelation.new(select, where, groupby, orderby, limit, offset)
+          end
+        end
+        
+        ########################## put together ###############################
+        def expression
+          assemble[0]
+        end
+
+        def relation
+          assemble[2]
+        end
+        def predicate
+          assemble[1]
+        end
+        
+        def assemble
+          pred = nil
+          rel = nil
+          lazy_predicate = lazy{pred}
+          lazy_rel = lazy{rel}
+          expr = make_expression lazy_predicate, lazy_rel
+          pred = make_predicate expr, lazy_rel
+          rel = make_relation expr, pred
+          return expr, pred, rel
+        end
+        
+        def make parser
+          MyLexeme.nested(parser << eof)
+        end
+      end
+    end
+  end
+end

data/lib/google_data_source/sql_parser.rb

@@ -0,0 +1,82 @@
+module GoogleDataSource
+  module DataSource
+    class SimpleSqlException < Exception; end
+
+    class SqlParser
+      include Sql::Parser
+
+      class << self
+        # Parses a simple SQL query and return the result
+        # The where statement may only contain equality comparisons that are connected with 'and'
+        # Only a single ordering parameter is accepted
+        # Throws a +SimpleSqlException+ if these conditions are not satisfied
+        def simple_parse(query)
+          result = parse(query)
+          OpenStruct.new({
+            :select => result.select.collect(&:to_s),
+            :conditions => simple_where_parser(result.where),
+            :orderby => simple_orderby_parser(result.orderby),
+            :groupby => simple_groupby_parser(result.groupby),
+            :limit => result.limit,
+            :offset => result.offset
+          })
+        end
+
+        # Parses a SQL query and returns the result
+        def parse(query)
+          parser.parse(query)
+        end
+
+        protected
+          # Helper to the +simple_parse+ method
+          def simple_where_parser(predicate, result = Hash.new)
+            case predicate.class.name.split('::').last
+            when 'CompoundPredicate'
+              raise SimpleSqlException.new("Operator forbidden (use only 'and')") unless predicate.op == :and
+              simple_where_parser(predicate.left,  result)
+              simple_where_parser(predicate.right, result)
+            when 'ComparePredicate'
+              case predicate.op
+              when :"="
+                result[predicate.left.to_s] = predicate.right.to_s
+              when :"<", :">", :">=", :"<=", :"<>", :"!="
+                result[predicate.left.to_s] ||= Array.new
+                raise SimpleSqlException.new("Condition clach") unless result[predicate.left.to_s].is_a?(Array)
+                result[predicate.left.to_s] << OpenStruct.new(:op => predicate.op.to_s, :value => predicate.right.to_s)
+              else
+                raise SimpleSqlException.new("Comparator forbidden (use only '=,<,>')") unless predicate.op == :"="
+              end
+            when 'InPredicate'
+              result[predicate.expr.to_s] ||= Array.new
+              raise SimpleSqlException.new("Condition clach") unless result[predicate.expr.to_s].is_a?(Array)
+              result[predicate.expr.to_s] << OpenStruct.new(:op => 'in', :value => predicate.vals.map(&:to_s))
+            when 'NilClass'
+              # do nothing
+            else
+              raise SimpleSqlException.new("Unknown syntax error")
+            end
+            result
+          end
+
+          # Helper to the +simple_parse+ method
+          def simple_orderby_parser(orderby)
+            return nil if orderby.nil?
+            raise SimpleSqlException.new("Too many ordering arguments (1 allowed)") if orderby.size > 1
+            [orderby.first.expr.to_s, orderby.first.asc ? :asc : :desc]
+          end
+
+          # Helper to the +simple_parse+ method
+          def simple_groupby_parser(groupby)
+            return [] if groupby.nil?
+            groupby.exprs.collect(&:to_s)
+          end
+
+          # Returns the parser
+          def parser
+            sql = self.new
+            sql.make(sql.relation)
+          end
+      end
+    end
+  end
+end

data/lib/google_data_source/template_handler.rb

@@ -0,0 +1,31 @@
+module GoogleDataSource
+  module DataSource
+    # A simple template handler for a data source
+    # Provides a GoogleDataSource::Base object datasource in the template so the template
+    # can fill it with data
+    class TemplateHandler
+
+      def self.call(template)
+        <<-EOT
+        datasource = GoogleDataSource::DataSource::Base.from_params(params)
+        #{template.source.dup}
+        if !datasource.reporting.nil? && datasource.reporting.has_form?
+          datasource.callback = "$('\\\#\#{datasource.reporting.form_id}').html(\#{render(:partial => datasource.reporting.partial).to_json});"
+        end
+
+        if datasource.format == 'csv'
+          headers['Content-Type']        = 'text/csv; charset=utf-8'
+          headers['Content-Disposition'] = "attachment; filename=\\"\#{datasource.export_filename}.csv\\""
+        end
+
+        if datasource.format == 'xml'
+          headers['Content-Type'] = 'application/xml; charset=utf-8'
+          headers['Content-Disposition'] = "attachment; filename=\\"\#{datasource.export_filename}.xml\\""
+        end
+
+        datasource.response
+        EOT
+      end
+    end
+  end
+end

data/lib/google_data_source/test_helper.rb

@@ -0,0 +1,26 @@
+module GoogleDataSource
+  # Some usefull helpers for testing datasources
+  module TestHelper
+
+    # Returns the parsed JSON argument of the datasource response
+    def datasource_response
+      first_cmd = @response.body.match(/([^;"]*|"(\\"|[^"])*;?(\\"|[^"])*")*;/)[0]
+      response = OpenStruct.new(JSON.parse(first_cmd.match(/^[^(]*\((.*)\);$/)[1]))
+      response.table = OpenStruct.new(response.table)
+      response
+    end
+
+    # Returns the columns array of the JSON response
+    def datasource_column(column)
+      response = datasource_response
+      column_no = response.table.cols.collect { |c| c['id'] }.index(column.to_s)
+      response.table.rows.collect { |r| r['c'][column_no] }
+    end
+
+    # Returns the column ids of the JSON response
+    def datasource_column_ids
+      datasource_response.table.cols.collect { |c| c['id'] }
+    end
+
+  end
+end

data/lib/google_data_source/version.rb

@@ -0,0 +1,3 @@
+module GoogleDataSource
+  VERSION = '0.7.6'
+end

data/lib/google_data_source/xml_data.rb

@@ -0,0 +1,25 @@
+require 'nokogiri'
+
+module GoogleDataSource
+  module DataSource
+    class XmlData < Base
+      #include ActionView::Helpers::NumberHelper
+      def response
+        cols = columns.map { |col| col.id || col.type }
+        builder = ::Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+          xml.send(xml_class.pluralize, :type => 'array') do
+            data.each do |datarow|
+              xml.send(xml_class) do
+                datarow.zip(cols).each do |val, key|
+                  xml.send("#{key}", val.is_a?(Hash) ? val[:v] : val)
+                end
+              end
+            end
+          end
+        end
+       
+        builder.to_xml
+      end
+    end
+  end
+end

data/lib/locale/de.yml

@@ -0,0 +1,5 @@
+de:
+  google_data_source:
+    export_links:
+      export_as: 'Exportieren als:'
+      csv: CSV

data/lib/reporting/action_controller_extension.rb

@@ -0,0 +1,19 @@
+module GoogleDataSource
+  module Reporting
+    module ActionControllerExtension
+      # Add the option +:reporting+ to the +render+ method.
+      # Takes a +Reporting+ object and renders the data-source response
+      # including the form validation results
+      def render_with_reporting(*args)
+        if !args.first.nil? && args.first.is_a?(Hash) && args.first.has_key?(:reporting)
+          reporting = args.first[:reporting]
+          datasource = GoogleDataSource::DataSource::Base.from_params(params)
+          datasource.set(reporting)
+          render_for_text datasource.response
+        else
+          render_without_reporting(*args)
+        end
+      end
+    end
+  end
+end

data/lib/reporting/grouped_set.rb

@@ -0,0 +1,58 @@
+# Represents an array of Objects which can be grouped according to grouping keys
+# or a grouping block, which returns the hash used for grouping
+#
+# The objects must support the '+' operation which is used to implode sets of objects
+# with the same grouping hash.
+class GroupedSet < Array
+  #attr_reader :data
+
+  # Standard constructor
+  # +data+ is an Array of Objects implementing a '+' operation
+  #def initialize(data)
+  #  @data = data
+  #end
+
+  # Bang method for the regrouping of the data
+  # The method takes either a set of keys or a block as grouping criterion
+  #
+  # If keys are set the grouping hash is built by calling +object.send(key).to_s+
+  # and concatening for all keys. (e.g. if +Object+ supports the method +date+ the
+  # grouping by +date+ is calculated by calling +regroup!(:date)+
+  #
+  # If a block is passed, it is called for every entry and it's result is taken as 
+  # grouping hash. (e.g. +regroup! { |entry| entry.date }+ for grouping by date
+  #
+  # Objects with identical grouping hash are collapsed by calling the '+' operator
+  # on them.
+  #
+  # ATTENTION:
+  # This method won't recognize senseless grouping (e.g. calling
+  # +regroup! { |entry| entry.date.month }+ followed by
+  # +regroup! { |entry| entry.date }+ )
+  def regroup(*keys, &block)
+    # handle block
+    return regroup_by_proc(block) if block_given?
+
+    # handle keys
+    block = Proc.new do |entry|
+      keys.inject([]) { |memo, column| memo.push entry.send(column.to_sym).to_s }.join('-')
+    end
+    regroup_by_proc(block)
+  end
+
+  # Collapse the collection to a single entry
+  def collapse
+    regroup.first
+  end
+
+  protected
+    # Helper method for regroup with groups the data using a proc as grouping hash generator
+    def regroup_by_proc(grouping_proc)
+      data = self.group_by { |entry| grouping_proc.call(entry) }.values
+      result = data.collect do |entries|
+        # Uses the class of the first element to build the composite element
+        entries.first.class.composite(entries)
+      end
+      self.class.new(result)
+    end
+end