cell_set 0.1.0

data/README

@@ -0,0 +1,5 @@
+cell_set is a ruby implementation of the CellSet and related models from mondrian.olap4j.
+
+The cell_set gem automatically mixes in a to_ruby method on Mondrian::OLAP::CellSet that can be called from the instance variable @raw_cell_set in an instance of Mondrian::OLAP::Result.
+
+Normally the to_ruby method is automatically called in the to_cell_set method in an instance of Mondrian::OLAP::Result.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/cell_set/attributes.rb

@@ -0,0 +1,62 @@
+# Use this module to add necessary attributes methods that ActiveModel::AttributeMethods doesn't add
+# An ATTRIBUTES constant must be on the model before including this module
+# Attributes specified in ATTRIBUTES will be serialized if any ActiveModel::Serializers are used
+# Any attributes that shouldn't be serialized can still be set with another attr_accessor, but won't show up in
+#
+
+module CellSet
+  module Attributes
+    extend ActiveSupport::Concern
+    extend ActiveModel::Naming
+    include ActiveModel::AttributeMethods
+
+    included do
+      self.send(:attr_accessor, *self::ATTRIBUTES)
+
+      if self.private_methods.include?(:define_attribute_method)
+        self.send(:define_attribute_method, self::ATTRIBUTES)
+      end
+    end
+
+    module ClassMethods
+      def human_attribute_name(attr, options = {})
+        attr
+      end
+
+      def lookup_ancestors
+        [self]
+      end
+    end
+
+    def initialize(attrs = {})
+      @errors = ActiveModel::Errors.new(self)
+      attrs.each do |name, value|
+        send("#{name}=", value) if value
+      end
+      super(attrs)
+    end
+
+    def attributes
+      self.class::ATTRIBUTES.inject(ActiveSupport::HashWithIndifferentAccess.new) do |result, key|
+        result[key] = read_attribute_for_validation(key)
+        result
+      end
+    end
+
+    def attributes=(attrs)
+       attrs.each_pair {|k, v| send("#{k}=", v)}
+    end
+
+    def clear_attribute(attr)
+      send("#{attr}=", nil)
+    end
+
+    def has_attribute?(attr)
+      self.class::ATTRIBUTES.include?(attr)
+    end
+
+    def read_attribute_for_validation(key)
+      send(key)
+    end
+  end
+end

data/lib/cell_set/cell.rb

@@ -0,0 +1,24 @@
+module CellSet
+  class Cell
+    ATTRIBUTES = [:formatted_value, :ordinal, :value]
+
+    include Attributes
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    self.include_root_in_json = false
+
+    def from_json(*)
+      super.tap{|obj| obj.freeze}
+    end
+
+    def ordinal=(ordinal)
+      @ordinal = if ordinal.is_a?(Fixnum)
+       ordinal
+      elsif ordinal.is_a?(String)
+       Integer(ordinal)
+      else
+       throw ArgumentError
+      end
+    end
+  end
+end

data/lib/cell_set/cell_set.rb

@@ -0,0 +1,152 @@
+require 'cell_set/cell_set_axis'
+require 'cell_set/cell'
+
+module CellSet
+  class CellSet
+    ATTRIBUTES = [:axes]
+
+    include Attributes
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+
+    def as_json(options = nil)
+      # Strangely couldn't use options = {} in JRuby
+      options = {} if options.nil?
+      json = super(options)
+      unless (options.has_key?(:only) && !options[:only].include?("cells")) ||
+          (options.has_key?(:except) && options[:except].include?("cells"))
+        json.first[1]["cells"] = @cellHash
+      end
+      json
+    end
+
+    def axes=(axes)
+      if axes.is_a?(Array)
+        @axes = axes.map do |axis|
+          if axis.is_a?(CellSetAxis)
+            axis.cell_set = self
+            axis
+          elsif axis.is_a?(Hash)
+            CellSetAxis.new(:cell_set => self).from_json(axis.to_json)
+          else
+            throw ArgumentError
+          end
+        end
+      else
+        throw ArgumentError
+      end
+    end
+
+    def bounds
+      @axes.map{|axis| axis.positionCount}
+    end
+
+    def cell(*args)
+      if args[0].is_a?(NilClass)
+        throw(ArgumentError)
+      elsif args[0].is_a?(Fixnum) && args.length == 1
+        getCellInternal(args[0])
+      elsif args[0].is_a?(Array) && args.length == 1
+        getCellInternal(coordinatesToOrdinal(args[0]))
+      elsif args.select{|arg| arg.is_a?(Position)}.length == args.length
+        unless args.length == axes.length
+          throw ArgumentError, "cell coordinates should have dimension #{axis.length}"
+        end
+        cell(args.map{|position| position.getOrdinal})
+      else
+        throw(ArgumentError)
+      end
+    end
+
+    def cells=(cells)
+      if cells.is_a?(Array)
+        cells.each do |cell|
+          if cell.is_a?(Cell)
+            @cellHash[cell.ordinal.to_s] = {
+              "formatted_value" => cell.formatted_value,
+              "value" => cell.value
+            }
+          else
+            throw ArgumentError
+          end
+        end
+      elsif cells.is_a?(Hash)
+        @cellHash = cells
+      else
+        throw ArgumentError
+      end
+    end
+
+    def coordinatesToOrdinal(coordinates)
+      unless coordinates.length == @axes.length
+        throw ArgumentError, "Coordinates have different dimension #{coordinates.length} than axes #{@axes.length}"
+      end
+
+      modulo = 1
+      ordinal = 0
+      k = 0
+      @axes.each do |axis|
+        coordinate = coordinates[k]
+        if coordinate < 0 || coordinate >= axis.positionCount
+          throw IndexError, "Coordinate #{coordinate} of axis #{k} is out of range (#{bounds.join(", ")})"
+        end
+        ordinal += coordinate * modulo
+        modulo *= axis.positionCount
+      end
+      ordinal
+    end
+
+    def from_json(*)
+      super.tap{|obj| obj.freeze}
+    end
+
+    def getFilterAxis
+      throw NotImplementedError
+    end
+
+    def initialize(*)
+      @cellHash = {}
+      super
+    end
+
+    def maxOrdinal
+      modulo = 1
+      @axes.each do |axis|
+        modulo *= axis.positionCount
+      end
+      modulo
+    end
+
+    def ordinalToCoordinates(ordinal)
+      modulo = 1
+
+      list = @axes.map do |axis|
+        prevModulo = modulo
+        modulo *= axis.positionCount
+        (ordinal % modulo) / prevModulo
+      end
+
+      if ordinal < 0 || ordinal >= modulo
+        throw IndexError, "Cell ordinal #{ordinal} lies outside CellSet bounds (#{bounds.join(", ")})"
+      end
+
+      list
+    end
+
+    private
+    attr_accessor :cellHash
+
+    def getCellInternal(pos)
+      cell = @cellHash[pos.to_s]
+      if cell.nil?
+        if (pos < 0 || pos >= maxOrdinal)
+          throw IndexError
+        else
+          Cell.new(:formatted_value => "", :ordinal => pos)
+        end
+      else
+        Cell.new(:formatted_value => cell["formatted_value"], :ordinal => pos, :value => cell["value"])
+      end
+    end
+  end
+end

data/lib/cell_set/cell_set_axis.rb

@@ -0,0 +1,79 @@
+require 'cell_set/position'
+
+module CellSet
+  class CellSetAxis
+    ATTRIBUTES = [:axis_ordinal, :cell_set, :positions]
+
+    include Attributes
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Comparable
+    self.include_root_in_json = false
+
+    def <=>(other)
+      if other.is_a?(self.class)
+        @axis_ordinal <=> other.axis_ordinal
+      else
+        raise(ArgumentError, "Must compare #{self.class.to_s} to another #{self.class.to_s}")
+      end
+    end
+
+    def axis_ordinal=(ordinal)
+      @axis_ordinal = if ordinal.is_a?(Fixnum)
+        ordinal
+      elsif ordinal.is_a?(String)
+        Integer(ordinal)
+      else
+        throw ArgumentError
+      end
+    end
+
+    def between?(min, max)
+      @axis_ordinal <= min || @axis_ordinal >= max
+    end
+
+    def cell_set=(cell_set)
+      @cell_set = if cell_set.is_a?(CellSet)
+        cell_set
+      elsif cell_set.is_a?(Hash)
+        CellSet.new.from_json(cell_set.to_json)
+      else
+        throw ArgumentError
+      end
+    end
+
+    def from_json(*)
+      super.tap{|obj| obj.freeze}
+    end
+
+    def positionCount
+      @positions.length
+    end
+
+    def positions=(positions)
+      if positions.is_a?(Array)
+        @positions = positions.map do |position|
+          if position.is_a?(Position)
+            position
+          elsif position.is_a?(Hash)
+            Position.new.from_json(position.to_json)
+          else
+            throw ArgumentError
+          end
+        end
+      else
+        throw ArgumentError
+      end
+    end
+
+    def as_json(options = nil)
+      # Strangely couldn't use options = {} in JRuby
+      options = {} if options.nil?
+      unless (options.has_key?(:only) && options[:only].include?("cell_set")) ||
+             (options.has_key?(:except) && options[:except].include?("cell_set"))
+        options[:except] = (options[:except] || []).push("cell_set")
+      end
+      super(options)
+    end
+  end
+end

data/lib/cell_set/member.rb

@@ -0,0 +1,75 @@
+module CellSet
+  class Member
+    ATTRIBUTES = [:caption, :childMembers, :depth, :description, :dimension, :expression, :hierarchy, :level, :memberType, \
+                  :name, :ordinal, :parentMember, :uniqueName]
+
+    include Attributes
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Comparable
+    self.include_root_in_json = false
+
+    def <=>(other)
+      if other.is_a?(self.class)
+        @ordinal <=> other.ordinal
+      else
+        nil
+      end
+    end
+
+    def ancestorMembers
+      throw NotImplementedError
+    end
+
+    def between?(min, max)
+      @ordinal <= min || @ordinal >= max
+    end
+
+    def childMemberCount
+      throw NotImplementedError
+    end
+
+    def all?
+      throw NotImplementedError
+    end
+
+    def calculated?
+      throw NotImplementedError
+    end
+
+    def calculatedInQuery?
+      throw NotImplementedError
+    end
+
+    def childOrEqualTo?(member)
+      throw NotImplementedError
+    end
+
+    def from_json(*)
+      super.tap{|obj| obj.freeze}
+    end
+
+    def hidden?
+      throw NotImplementedError
+    end
+
+    def initialize(*)
+      @childMembers = []
+      super
+    end
+
+    def ordinal=(ordinal)
+      @ordinal = if ordinal.is_a?(Fixnum)
+        ordinal
+      elsif ordinal.is_a?(String)
+        Integer(ordinal)
+      else
+        throw ArgumentError
+      end
+  end
+
+    def visible?
+      throw NotImplementedError
+    end
+  end
+end

data/lib/cell_set/model.rb

@@ -0,0 +1,5 @@
+module CellSet::Model
+  extend ActiveSupport::Concern
+
+  ActiveSupport.run_load_hooks(:cell_set_model, self)
+end

data/lib/cell_set/position.rb

@@ -0,0 +1,60 @@
+require 'cell_set/member'
+
+module CellSet
+  class Position
+    ATTRIBUTES = [:members, :ordinal]
+
+    include Attributes
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Comparable
+    self.include_root_in_json = false
+
+    def <=>(other)
+      if other.is_a?(self.class)
+        @ordinal <=> other.ordinal
+      else
+        nil
+      end
+    end
+
+    def between?(min, max)
+      @ordinal <= min || @ordinal >= max
+    end
+
+    def from_json(*)
+      super.tap{|obj| obj.freeze}
+    end
+
+    def initialize(*)
+      @members = []
+      super
+    end
+
+    def members=(members)
+      if members.is_a?(Array)
+        @members = members.map do |member|
+          if member.is_a?(Member)
+            member
+          elsif member.is_a?(Hash)
+            Member.new.from_json(member.to_json)
+          else
+            throw ArgumentError
+          end
+        end
+      else
+        throw ArgumentError
+      end
+    end
+
+    def ordinal=(ordinal)
+      @ordinal = if ordinal.is_a?(Fixnum)
+        ordinal
+      elsif ordinal.is_a?(String)
+        Integer(ordinal)
+      else
+        throw ArgumentError
+      end
+    end
+  end
+end

data/lib/cell_set/result.rb

@@ -0,0 +1,9 @@
+module CellSet
+  module Result
+    extend ActiveSupport::Concern
+
+    def to_cell_set
+      @raw_cell_set.to_ruby
+    end
+  end
+end

data/lib/cell_set/version.rb

@@ -0,0 +1,3 @@
+module Version
+  VERSION = "0.1.0"
+end

data/lib/cell_set.rb

@@ -0,0 +1,25 @@
+require 'active_support/concern'
+require 'active_support/hash_with_indifferent_access'
+require 'active_model/attribute_methods'
+require 'active_model/naming'
+require 'active_model/serialization'
+require 'active_model/serializers/json'
+require 'active_model/serializers/xml'
+if RUBY_PLATFORM == "java"
+  require 'mondrian-olap'
+end
+
+%w(version attributes result cell member position cell_set_axis cell_set model).each do |file|
+  require "cell_set/#{file}"
+end
+
+%w(ruby).each do |file|
+  require "mondrian/olap/cell_set/#{file}"
+end
+
+if RUBY_PLATFORM == "java"
+  ActiveSupport.on_load(:cell_set_model) do
+    Java::Mondrian::olap4j::MondrianOlap4jCellSet.send(:include, Mondrian::OLAP::CellSet::Ruby)
+    Mondrian::OLAP::Result.send(:include, ::CellSet::Result)
+  end
+end

data/lib/mondrian/olap/cell_set/ruby.rb

@@ -0,0 +1,61 @@
+module Mondrian
+  module OLAP
+    module CellSet
+      module Ruby
+        extend ActiveSupport::Concern
+
+        def to_ruby
+          cell_set = ::CellSet::CellSet.new
+          axes = getAxes.map do |axis|
+            ::CellSet::CellSetAxis.new(:axis_ordinal => axis.getAxisOrdinal.axisOrdinal, :cell_set => cell_set, :positions => buildPositions(axis))
+          end
+          cell_set.axes = axes
+          cell_set.send("cellHash=", getCellHash)
+          cell_set.freeze
+          cell_set
+        end
+
+        private
+        def buildPositions(axis)
+          axis.positions.map do |position|
+            members = position.getMembers.map do |member|
+              ::CellSet::Member.new(
+                :caption => member.getCaption,
+                :depth => member.getDepth,
+                :description => member.getDescription,
+                :memberType => member.getMemberType.to_s,
+                :name => member.getName,
+                :ordinal => member.getOrdinal,
+                :uniqueName => member.getUniqueName
+              )
+            end
+            ::CellSet::Position.new(:members => members, :ordinal => position.getOrdinal)
+          end
+        end
+
+        def getCellHash
+          cells = {}
+          maxOrdinal.times do |i|
+            formatted_value, value = *getCell(i).try{|cell| [cell.getFormattedValue, cell.getValue]}
+            unless formatted_value.blank? && value.nil?
+              # Build key as string
+              cells[i.to_s] = {
+                "formatted_value" => formatted_value,
+                "value" => value
+              }
+            end
+          end
+          cells
+        end
+
+        def maxOrdinal
+          modulo = 1
+          getAxes.each do |axis|
+            modulo *= axis.getPositionCount
+          end
+          modulo
+        end
+      end
+    end
+  end
+end

data/spec/factories/cell_set_axis_factory.rb

@@ -0,0 +1,4 @@
+Factory.define :cell_set_axis, :class => CellSet::CellSetAxis do |f|
+  f.axis_ordinal 0
+  f.positions []
+end

data/spec/factories/cell_set_factory.rb

@@ -0,0 +1,3 @@
+Factory.define :cell_set, :class => CellSet::CellSet do |f|
+  f.axes []
+end

data/spec/factories/member_factory.rb

@@ -0,0 +1,5 @@
+Factory.define :member, :class => CellSet::Member do |f|
+  f.ordinal 0
+  f.name { Factory.next(:name) }
+  f.uniqueName { "[All].[#{name}]" }
+end

data/spec/factories/position_factory.rb

@@ -0,0 +1,4 @@
+Factory.define :position, :class => CellSet::Position do |f|
+  f.ordinal 0
+  f.members []
+end

data/spec/factories/sequences.rb

@@ -0,0 +1,7 @@
+Factory.sequence :id do |n|
+  n
+end
+
+Factory.sequence :name do |n|
+  "String#{n}Name"
+end