mondrian-olap 0.5.0 → 1.2.0

data/lib/mondrian/olap/cube.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module Mondrian
   module OLAP
     module Annotated
@@ -16,6 +18,8 @@ module Mondrian
     end
 
     class Cube
+      extend Forwardable
+
       def self.get(connection, name)
         if raw_cube = connection.raw_schema.getCubes.get(name)
           Cube.new(connection, raw_cube)
@@ -25,6 +29,7 @@ module Mondrian
       def initialize(connection, raw_cube)
         @connection = connection
         @raw_cube = raw_cube
+        @cache_control = CacheControl.new(@connection, self)
       end
 
       attr_reader :raw_cube
@@ -46,6 +51,10 @@ module Mondrian
         annotations_for(@raw_cube)
       end
 
+      def visible?
+        @raw_cube.isVisible
+      end
+
       def dimensions
         @dimenstions ||= @raw_cube.getDimensions.map{|d| Dimension.new(self, d)}
       end
@@ -73,6 +82,9 @@ module Mondrian
         raw_member = @raw_cube.lookupMember(segment_list)
         raw_member && Member.new(raw_member)
       end
+
+      def_delegators :@cache_control, :flush_region_cache_with_segments, :flush_region_cache_with_segments
+      def_delegators :@cache_control, :flush_region_cache_with_full_names, :flush_region_cache_with_full_names
     end
 
     class Dimension
@@ -132,6 +144,10 @@ module Mondrian
         annotations_for(@raw_dimension)
       end
 
+      def visible?
+        @raw_dimension.isVisible
+      end
+
     end
 
     class Hierarchy
@@ -207,6 +223,10 @@ module Mondrian
         annotations_for(@raw_hierarchy)
       end
 
+      def visible?
+        @raw_hierarchy.isVisible
+      end
+
     end
 
     class Level
@@ -260,6 +280,10 @@ module Mondrian
         annotations_for(@raw_level)
       end
 
+      def visible?
+        @raw_level.isVisible
+      end
+
     end
 
     class Member
@@ -358,6 +382,10 @@ module Mondrian
         end
       end
 
+      def mondrian_member
+        @raw_member.unwrap(Java::MondrianOlap::Member.java_class)
+      end
+
       include Annotated
       def annotations
         annotations_for(@raw_member)
@@ -374,17 +402,50 @@ module Mondrian
       end
 
       def cell_formatter_name
+        if cf = cell_formatter
+          cf.class.name.split('::').last.gsub(/Udf\z/, '')
+        end
+      end
+
+      def cell_formatter
         if dimension_type == :measures
           cube_measure = raw_member.unwrap(Java::MondrianOlap::Member.java_class)
           if value_formatter = cube_measure.getFormatter
             f = value_formatter.java_class.declared_field('cf')
             f.accessible = true
-            cf = f.value(value_formatter)
-            cf.class.name.split('::').last.gsub(/Udf\z/, '')
+            f.value(value_formatter)
           end
         end
       end
+    end
+
+    class CacheControl
+      def initialize(connection, cube)
+        @connection = connection
+        @cube = cube
+        @mondrian_cube = @cube.raw_cube.unwrap(Java::MondrianOlap::Cube.java_class)
+        @cache_control = @connection.raw_cache_control
+      end
 
+      def flush_region_cache_with_segments(*segment_names)
+        members = segment_names.map { |name| @cube.member_by_segments(*name).mondrian_member }
+        flush(members)
+      end
+
+      def flush_region_cache_with_full_names(*full_names)
+        members = full_names.map { |name| @cube.member(*name).mondrian_member }
+        flush(members)
+      end
+
+      private
+
+      def flush(members)
+        regions = members.map do |member|
+          @cache_control.create_member_region(member, true)
+        end
+        regions << @cache_control.create_measures_region(@mondrian_cube)
+        @cache_control.flush(@cache_control.create_crossjoin_region(*regions))
+      end
     end
   end
 end

data/lib/mondrian/olap/error.rb

@@ -6,25 +6,43 @@ module Mondrian
     class Error < StandardError
       # root_cause will be nil if there is no cause for wrapped native error
       # root_cause_message will have either root_cause message or wrapped native error message
-      attr_reader :native_error, :root_cause_message, :root_cause
+      attr_reader :native_error, :root_cause_message, :root_cause, :profiling_handler
 
-      def initialize(native_error)
+      def initialize(native_error, options = {})
         @native_error = native_error
         get_root_cause
-        super(native_error.message)
+        super(native_error.toString)
         add_root_cause_to_backtrace
+        get_profiling(options)
       end
 
-      def self.wrap_native_exception
+      def self.wrap_native_exception(options = {})
         yield
-      rescue NativeException => e
-        if e.message =~ NATIVE_ERROR_REGEXP
-          raise Mondrian::OLAP::Error.new(e)
+      # TokenMgrError for some unknown reason extends java.lang.Error which normally should not be rescued
+      rescue Java::JavaLang::Exception, Java::MondrianParser::TokenMgrError => e
+        if e.toString =~ NATIVE_ERROR_REGEXP
+          raise Mondrian::OLAP::Error.new(e, options)
         else
           raise
         end
       end
 
+      def profiling_plan
+        if profiling_handler && (plan = profiling_handler.plan)
+          plan.gsub("\r\n", "\n")
+        end
+      end
+
+      def profiling_timing
+        profiling_handler.timing if profiling_handler
+      end
+
+      def profiling_timing_string
+        if profiling_timing && (timing_string = profiling_timing.toString)
+          timing_string.gsub("\r\n", "\n")
+        end
+      end
+
       private
 
       def get_root_cause
@@ -44,7 +62,7 @@ module Mondrian
         bt = @native_error.backtrace
         if @root_cause
           root_cause_bt = Array(@root_cause.backtrace)
-          root_cause_bt[0,5].reverse.each do |bt_line|
+          root_cause_bt[0, 10].reverse.each do |bt_line|
             bt.unshift "root cause:   #{bt_line}"
           end
           bt.unshift "root cause: #{@root_cause.java_class.name}: #{@root_cause.message.chomp}"
@@ -52,6 +70,17 @@ module Mondrian
         set_backtrace bt
       end
 
+      def get_profiling(options)
+        if statement = options[:profiling_statement]
+          f = Java::mondrian.olap4j.MondrianOlap4jStatement.java_class.declared_field("openCellSet")
+          f.accessible = true
+          if cell_set = f.value(statement)
+            cell_set.close
+            @profiling_handler = statement.getProfileHandler
+          end
+        end
+      end
+
     end
   end
 end

data/lib/mondrian/olap/query.rb

@@ -34,7 +34,7 @@ module Mondrian
         end
       end
 
-      AXIS_ALIASES = %w(columns rows pages sections chapters)
+      AXIS_ALIASES = %w(columns rows pages chapters sections)
       AXIS_ALIASES.each_with_index do |axis, i|
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{axis}(*axis_members)
@@ -47,7 +47,7 @@ module Mondrian
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{method}(*axis_members)
             raise ArgumentError, "cannot use #{method} method before axis or with_set method" unless @current_set
-            raise ArgumentError, "specify list of members for #{method} method" if axis_members.empty?
+            raise ArgumentError, "specify set of members for #{method} method" if axis_members.empty?
             members = axis_members.length == 1 && axis_members[0].is_a?(Array) ? axis_members[0] : axis_members
             @current_set.replace [:#{method}, @current_set.clone, members]
             self
@@ -57,7 +57,7 @@ module Mondrian
 
       def except(*axis_members)
         raise ArgumentError, "cannot use except method before axis or with_set method" unless @current_set
-        raise ArgumentError, "specify list of members for except method" if axis_members.empty?
+        raise ArgumentError, "specify set of members for except method" if axis_members.empty?
         members = axis_members.length == 1 && axis_members[0].is_a?(Array) ? axis_members[0] : axis_members
         if [:crossjoin, :nonempty_crossjoin].include? @current_set[0]
           @current_set[2] = [:except, @current_set[2], members]
@@ -73,7 +73,13 @@ module Mondrian
         self
       end
 
-      def filter(condition, options={})
+      def distinct
+        raise ArgumentError, "cannot use distinct method before axis method" unless @current_set
+        @current_set.replace [:distinct, @current_set.clone]
+        self
+      end
+
+      def filter(condition, options = {})
         raise ArgumentError, "cannot use filter method before axis or with_set method" unless @current_set
         @current_set.replace [:filter, @current_set.clone, condition]
         @current_set << options[:as] if options[:as]
@@ -87,6 +93,19 @@ module Mondrian
         self
       end
 
+      def generate(*axis_members)
+        raise ArgumentError, "cannot use generate method before axis or with_set method" unless @current_set
+        all = if axis_members.last == :all
+          axis_members.pop
+          'ALL'
+        end
+        raise ArgumentError, "specify set of members for generate method" if axis_members.empty?
+        members = axis_members.length == 1 && axis_members[0].is_a?(Array) ? axis_members[0] : axis_members
+        @current_set.replace [:generate, @current_set.clone, members]
+        @current_set << all if all
+        self
+      end
+
       VALID_ORDERS = ['ASC', 'BASC', 'DESC', 'BDESC']
 
       def order(expression, direction)
@@ -119,7 +138,7 @@ module Mondrian
         end
       end
 
-      def hierarchize(order=nil, all=nil)
+      def hierarchize(order = nil, all = nil)
         raise ArgumentError, "cannot use hierarchize method before axis or with_set method" unless @current_set
         order = order && order.to_s.upcase
         raise ArgumentError, "invalid hierarchize order #{order.inspect}" unless order.nil? || order == 'POST'
@@ -133,7 +152,7 @@ module Mondrian
         self
       end
 
-      def hierarchize_all(order=nil)
+      def hierarchize_all(order = nil)
         hierarchize(order, :all)
       end
 
@@ -216,20 +235,16 @@ module Mondrian
         mdx
       end
 
-      def execute
-        Error.wrap_native_exception do
-          @connection.execute to_mdx
-        end
+      def execute(parameters = {})
+        @connection.execute to_mdx, parameters
       end
 
       def execute_drill_through(options = {})
-        Error.wrap_native_exception do
-          drill_through_mdx = "DRILLTHROUGH "
-          drill_through_mdx << "MAXROWS #{options[:max_rows]} " if options[:max_rows]
-          drill_through_mdx << to_mdx
-          drill_through_mdx << " RETURN #{Array(options[:return]).join(',')}" if options[:return]
-          @connection.execute_drill_through drill_through_mdx
-        end
+        drill_through_mdx = "DRILLTHROUGH "
+        drill_through_mdx << "MAXROWS #{options[:max_rows]} " if options[:max_rows]
+        drill_through_mdx << to_mdx
+        drill_through_mdx << " RETURN #{Array(options[:return]).join(',')}" if options[:return]
+        @connection.execute_drill_through drill_through_mdx
       end
 
       private
@@ -281,10 +296,10 @@ module Mondrian
       }
 
       def members_to_mdx(members)
-        # if only one member which does not end with ]
+        # if only one member which does not end with ] or .Item(...)
         # then assume it is expression which returns set
         # TODO: maybe always include also single expressions in {...} to avoid some edge cases?
-        if members.length == 1 && members[0][-1,1] != ']'
+        if members.length == 1 && members[0] !~ /(\]|\.Item\(\d+\))\z/i
           members[0]
         elsif members[0].is_a?(Symbol)
           case members[0]
@@ -296,9 +311,13 @@ module Mondrian
             "EXCEPT(#{members_to_mdx(members[1])}, #{members_to_mdx(members[2])})"
           when :nonempty
             "NON EMPTY #{members_to_mdx(members[1])}"
+          when :distinct
+            "DISTINCT(#{members_to_mdx(members[1])})"
           when :filter
             as_alias = members[3] ? " AS #{members[3]}" : nil
             "FILTER(#{members_to_mdx(members[1])}#{as_alias}, #{members[2]})"
+          when :generate
+            "GENERATE(#{members_to_mdx(members[1])}, #{members_to_mdx(members[2])}#{members[3] && ", #{members[3]}"})"
           when :order
             "ORDER(#{members_to_mdx(members[1])}, #{expression_to_mdx(members[2])}, #{members[3]})"
           when :top_count, :bottom_count
@@ -357,8 +376,9 @@ module Mondrian
       end
 
       def extract_dimension_name(full_name)
-        if full_name =~ /\A[^\[]*\[([^\]]+)\]/
-          $1
+        # "[Foo [Bar]]].[Baz]" =>  "Foo [Bar]"
+        if full_name
+          full_name.gsub(/\A\[|\]\z/, '').split('].[').first.try(:gsub, ']]', ']')
         end
       end
     end

data/lib/mondrian/olap/result.rb

@@ -3,11 +3,15 @@ require 'bigdecimal'
 module Mondrian
   module OLAP
     class Result
-      def initialize(connection, raw_cell_set)
+      def initialize(connection, raw_cell_set, options = {})
         @connection = connection
         @raw_cell_set = raw_cell_set
+        @profiling_handler = options[:profiling_handler]
+        @total_duration = options[:total_duration]
       end
 
+      attr_reader :raw_cell_set, :profiling_handler, :total_duration
+
       def axes_count
         axes.length
       end
@@ -103,6 +107,32 @@ module Mondrian
         end
       end
 
+      def profiling_plan
+        if profiling_handler
+          @raw_cell_set.close
+          if plan = profiling_handler.plan
+            plan.gsub("\r\n", "\n")
+          end
+        end
+      end
+
+      def profiling_timing
+        if profiling_handler
+          @raw_cell_set.close
+          profiling_handler.timing
+        end
+      end
+
+      def profiling_mark_full(name, duration)
+        profiling_timing && profiling_timing.markFull(name, duration)
+      end
+
+      def profiling_timing_string
+        if profiling_timing && (timing_string = profiling_timing.toString)
+          timing_string.gsub("\r\n", "\n")
+        end
+      end
+
       # Specify drill through cell position, for example, as
       #   :row => 0, :cell => 1
       # Specify max returned rows with :max_rows parameter
@@ -175,7 +205,7 @@ module Mondrian
           if @raw_result_set.next
             row_values = []
             column_types.each_with_index do |column_type, i|
-              row_values << Result.java_to_ruby_value(@raw_result_set.getObject(i+1), column_type)
+              row_values << Result.java_to_ruby_value(@raw_result_set.getObject(i + 1), column_type)
             end
             row_values
           else
@@ -240,25 +270,34 @@ module Mondrian
         end
 
         def self.generate_drill_through_sql(rolap_cell, result, params)
-          return_field_names, return_expressions, nonempty_columns = parse_return_fields(result, params)
+          nonempty_columns, return_fields = parse_return_fields(result, params)
+          return_expressions = return_fields.map{|field| field[:member]}
 
           sql_non_extended = rolap_cell.getDrillThroughSQL(return_expressions, false)
           sql_extended = rolap_cell.getDrillThroughSQL(return_expressions, true)
 
-          if sql_non_extended =~ /\Aselect (.*) from (.*) where (.*) order by (.*)\Z/
+          if sql_non_extended =~ /\Aselect (.*) from (.*) where (.*) order by (.*)\Z/m
+            non_extended_from = $2
+            non_extended_where = $3
+          # the latest Mondrian version sometimes returns sql_non_extended without order by
+          elsif sql_non_extended =~ /\Aselect (.*) from (.*) where (.*)\Z/m
             non_extended_from = $2
             non_extended_where = $3
+          # if drill through total measure with just all members selection
+          elsif sql_non_extended =~ /\Aselect (.*) from (.*)\Z/m
+            non_extended_from = $2
+            non_extended_where = "1 = 1" # dummy true condition
           else
             raise ArgumentError, "cannot parse drill through SQL: #{sql_non_extended}"
           end
 
-          if sql_extended =~ /\Aselect (.*) from (.*) where (.*) order by (.*)\Z/
+          if sql_extended =~ /\Aselect (.*) from (.*) where (.*) order by (.*)\Z/m
             extended_select = $1
             extended_from = $2
             extended_where = $3
             extended_order_by = $4
           # if only measures are selected then there will be no order by
-          elsif sql_extended =~ /\Aselect (.*) from (.*) where (.*)\Z/
+          elsif sql_extended =~ /\Aselect (.*) from (.*) where (.*)\Z/m
             extended_select = $1
             extended_from = $2
             extended_where = $3
@@ -267,25 +306,31 @@ module Mondrian
             raise ArgumentError, "cannot parse drill through SQL: #{sql_extended}"
           end
 
-          return_column_positions = {}
-
-          if return_field_names && !return_field_names.empty?
-            new_select = extended_select.split(/,\s*/).map do |part|
-              column_name, column_alias = part.split(' as ')
-              field_name = column_alias[1..-2].gsub(' (Key)', '')
-              position = return_field_names.index(field_name) || 9999
-              return_column_positions[column_name] = position
-              [part, position]
-            end.sort_by(&:last).map(&:first).join(', ')
-
-            new_order_by = extended_order_by.split(/,\s*/).map do |part|
-              column_name, asc_desc = part.split(/\s+/)
-              position = return_column_positions[column_name] || 9999
-              [part, position]
-            end.sort_by(&:last).map(&:first).join(', ')
+          if return_fields.present?
+            new_select_columns = []
+            new_order_by_columns = []
+            new_group_by_columns = []
+            group_by = params[:group_by]
+
+            return_fields.size.times do |i|
+              column_alias = return_fields[i][:column_alias]
+              new_select_columns <<
+                if column_expression = return_fields[i][:column_expression]
+                  new_order_by_columns << column_expression
+                  new_group_by_columns << column_expression if group_by && return_fields[i][:type] != :measure
+                  "#{column_expression} AS #{column_alias}"
+                else
+                  "'' AS #{column_alias}"
+                end
+            end
+
+            new_select = new_select_columns.join(', ')
+            new_order_by = new_order_by_columns.join(', ')
+            new_group_by = new_group_by_columns.join(', ')
           else
             new_select = extended_select
             new_order_by = extended_order_by
+            new_group_by = ''
           end
 
           new_from_parts = non_extended_from.split(/,\s*/)
@@ -321,40 +366,96 @@ module Mondrian
           end
 
           sql = "select #{new_select} from #{new_from} where #{new_where}"
+          sql << " group by #{new_group_by}" unless new_group_by.empty?
           sql << " order by #{new_order_by}" unless new_order_by.empty?
           sql
         end
 
         def self.parse_return_fields(result, params)
-          return_field_names = []
-          return_expressions = nil
           nonempty_columns = []
+          return_fields = []
 
           if params[:return] || params[:nonempty]
             rolap_cube = result.getCube
             schema_reader = rolap_cube.getSchemaReader
+            dialect = result.getCube.getSchema.getDialect
+            sql_query = Java::mondrian.rolap.sql.SqlQuery.new(dialect)
+
+            if fields = params[:return]
+              fields = fields.split(/,\s*/) if fields.is_a? String
+              fields.each do |field|
+                return_fields << case field
+                  when /\AName\((.*)\)\z/i then
+                    { member_full_name: $1, type: :name }
+                  when /\AProperty\((.*)\s*,\s*'(.*)'\)\z/i then
+                    { member_full_name: $1, type: :property, name: $2 }
+                  else
+                    { member_full_name: field }
+                  end
+              end
 
-            if return_fields = params[:return]
-              return_fields = return_fields.split(/,\s*/) if return_fields.is_a?(String)
-              return_expressions = return_fields.map do |return_field|
+              # Old versions of Oracle had a limit of 30 character identifiers.
+              # Do not limit it for other databases (as e.g. in MySQL aliases can be longer than column names)
+              max_alias_length = dialect.getMaxColumnNameLength
+              max_alias_length = nil if max_alias_length && max_alias_length > 30
+
+              return_fields.size.times do |i|
+                member_full_name = return_fields[i][:member_full_name]
                 begin
-                  segment_list = Java::MondrianOlap::Util.parseIdentifier(return_field)
-                  return_field_names << segment_list.to_a.last.name
+                  segment_list = Java::MondrianOlap::Util.parseIdentifier(member_full_name)
                 rescue Java::JavaLang::IllegalArgumentException
-                  raise ArgumentError, "invalid return field #{return_field}"
+                  raise ArgumentError, "invalid return field #{member_full_name}"
                 end
 
+                # if this is property field then the name is initialized already
+                return_fields[i][:name] ||= segment_list.to_a.last.name
                 level_or_member = schema_reader.lookupCompound rolap_cube, segment_list, false, 0
+                return_fields[i][:member] = level_or_member
+
+                if level_or_member.is_a? Java::MondrianOlap::Member
+                  raise ArgumentError, "cannot use calculated member #{member_full_name} as return field" if level_or_member.isCalculated
+                elsif !level_or_member.is_a? Java::MondrianOlap::Level
+                  raise ArgumentError, "return field #{member_full_name} should be level or measure"
+                end
+
+                return_fields[i][:column_expression] = case return_fields[i][:type]
+                when :name
+                  if level_or_member.respond_to? :getNameExp
+                    level_or_member.getNameExp.getExpression sql_query
+                  end
+                when :property
+                  if property = level_or_member.getProperties.to_a.detect{|p| p.getName == return_fields[i][:name]}
+                    # property.getExp is a protected method therefore
+                    # use a workaround to get the value from the field
+                    f = property.java_class.declared_field("exp")
+                    f.accessible = true
+                    if column = f.value(property)
+                      column.getExpression sql_query
+                    end
+                  end
+                else
+                  if level_or_member.respond_to? :getKeyExp
+                    return_fields[i][:type] = :key
+                    level_or_member.getKeyExp.getExpression sql_query
+                  else
+                    return_fields[i][:type] = :measure
+                    column_expression = level_or_member.getMondrianDefExpression.getExpression sql_query
+                    if params[:group_by]
+                      level_or_member.getAggregator.getExpression column_expression
+                    else
+                      column_expression
+                    end
+                  end
+                end
 
-                case level_or_member
-                when Java::MondrianOlap::Level
-                  Java::MondrianMdx::LevelExpr.new level_or_member
-                when Java::MondrianOlap::Member
-                  raise ArgumentError, "cannot use calculated member #{return_field} as return field" if level_or_member.isCalculated
-                  Java::mondrian.mdx.MemberExpr.new level_or_member
+                column_alias = if return_fields[i][:type] == :key
+                  "#{return_fields[i][:name]} (Key)"
                 else
-                  raise ArgumentError, "return field #{return_field} should be level or measure"
+                  return_fields[i][:name]
                 end
+                return_fields[i][:column_alias] = dialect.quoteIdentifier(
+                  max_alias_length ? column_alias[0, max_alias_length] : column_alias
+                )
               end
             end
 
@@ -364,23 +465,22 @@ module Mondrian
                 begin
                   segment_list = Java::MondrianOlap::Util.parseIdentifier(nonempty_field)
                 rescue Java::JavaLang::IllegalArgumentException
-                  raise ArgumentError, "invalid return field #{return_field}"
+                  raise ArgumentError, "invalid return field #{nonempty_field}"
                 end
                 member = schema_reader.lookupCompound rolap_cube, segment_list, false, 0
                 if member.is_a? Java::MondrianOlap::Member
-                  raise ArgumentError, "cannot use calculated member #{return_field} as nonempty field" if member.isCalculated
+                  raise ArgumentError, "cannot use calculated member #{nonempty_field} as nonempty field" if member.isCalculated
                   sql_query = member.getStarMeasure.getSqlQuery
                   member.getStarMeasure.generateExprString(sql_query)
                 else
-                  raise ArgumentError, "nonempty field #{return_field} should be measure"
+                  raise ArgumentError, "nonempty field #{nonempty_field} should be measure"
                 end
               end
             end
           end
 
-          [return_field_names, return_expressions, nonempty_columns]
+          [nonempty_columns, return_fields]
         end
-
       end
 
       def self.java_to_ruby_value(value, column_type = nil)
@@ -389,6 +489,8 @@ module Mondrian
           value
         when Java::JavaMath::BigDecimal
           BigDecimal(value.to_s)
+        when Java::JavaSql::Clob
+          clob_to_string(value)
         else
           value
         end
@@ -396,11 +498,28 @@ module Mondrian
 
       private
 
+      def self.clob_to_string(value)
+        if reader = value.getCharacterStream
+          buffered_reader = Java::JavaIo::BufferedReader.new(reader)
+          result = []
+          while str = buffered_reader.readLine
+            result << str
+          end
+          result.join("\n")
+        end
+      ensure
+        if buffered_reader
+          buffered_reader.close
+        elsif reader
+          reader.close
+        end
+      end
+
       def axes
         @axes ||= @raw_cell_set.getAxes
       end
 
-      def axis_positions(map_method, join_with=false)
+      def axis_positions(map_method, join_with = false)
         axes.map do |axis|
           axis.getPositions.map do |position|
             names = position.getMembers.map do |member|
@@ -429,7 +548,7 @@ module Mondrian
         :chapters => 4
       }.freeze
 
-      def recursive_values(value_method, axes_sequence, current_index, cell_params=[])
+      def recursive_values(value_method, axes_sequence, current_index, cell_params = [])
         if axis_number = axes_sequence[current_index]
           axis_number = AXIS_SYMBOL_TO_NUMBER[axis_number] if axis_number.is_a?(Symbol)
           positions_size = axes[axis_number].getPositions.size