rubiks 0.0.6 → 0.1.0

data/lib/rubiks/mondrian/cell_set.rb

@@ -0,0 +1,148 @@
+require 'rubiks/mondrian/member'
+
+module ::Rubiks
+  module Mondrian
+
+    class CellSet
+      def initialize(raw_cell_set)
+        @raw_cell_set = raw_cell_set
+      end
+
+      def to_s
+        "#<#{self.class}>"
+      end
+
+      def inspect
+        axes_strings  = []
+        axes_strings << "column_axis=#{axis_string(column_axis)}"
+        axes_strings << "row_axis=#{axis_string(row_axis)}" if row_axis
+        axes_strings << "filter_axis=#{axis_string(filter_axis)}" if filter_axis
+
+        "#<#{self.class} cube=#{cube_name} #{axes_strings.join(' ')}>"
+      end
+
+      def to_hash
+        {
+          :cube_name => cube_name,
+          :cells => cells,
+          :axes => result_axes,
+          :filter_axis => filter_axis
+        }.delete_if{ |k,v| v.blank? }
+      end
+
+      def cells
+        raw_cells.flatten
+      end
+
+      def cube_name
+        @raw_cell_set.meta_data.cube.name
+      end
+
+      def filter_axis
+        generate_axis(@raw_cell_set.filter_axis)
+      end
+
+      def column_axis
+        result_axes.first
+      end
+
+      def row_axis
+        result_axes[1]
+      end
+
+      def axes
+        @axes ||= @raw_cell_set.getAxes
+      end
+
+      def result_axes
+        axes.map{ |raw_axis| generate_axis(raw_axis) }
+      end
+
+      def axis_string(axis)
+        axis[:tuples].map do |tuple|
+          members = tuple[:members].map{ |member| member[:path] }.join(',')
+        end.join('|')
+      end
+
+      def generate_axis(axis)
+        tuples = axis.getPositions.map do |position|
+
+          members = position.getMembers.map do |raw_member|
+            member = ::Rubiks::Mondrian::Member.new(raw_member)
+
+            names = [raw_member.level.name]
+            names << raw_member.level.hierarchy.name.split('.').last
+            names << raw_member.level.hierarchy.dimension.name
+
+            level_unique_name = names.reverse.flatten.map{ |str| "[#{str}]" }.join('.')
+            member_unique_name = "#{level_unique_name}.[#{raw_member.name}]"
+
+            path_name = '/' + raw_member.unique_name.gsub(/\]\.\[/, '/')[1...-1]
+
+            {
+              :name => raw_member.name,
+              :unique_name => generate_unique_name(member_unique_name),
+              :level_name => generate_unique_name(level_unique_name),
+              :path => path_name,
+              :level_depth => raw_member.depth,
+              :child_count => member.children.length,
+              :is_all_member => member.all_member?,
+              :is_drillable => member.drillable?
+            }
+          end
+
+          members.compact!
+
+          if members.present?
+            {:members => members}
+          end
+        end
+
+        tuples.compact!
+
+        if tuples.present?
+          {
+            :name => axis.axis_ordinal.name,
+            :tuples => tuples
+          }
+        else
+          nil
+        end
+      end
+
+      # [Date.YQMD] - Mondrian's hierarchy
+      # [Logins].[Date].[YQMD] - needed output
+      def generate_unique_name(string)
+        cube_name = @raw_cell_set.meta_data.cube.name
+        dimension_hierarchy_regexp = /\[([^\]]+)\.([^\]]+)\]/
+        formatted_string = string.
+                            gsub(dimension_hierarchy_regexp, '[\1].[\2]').
+                            gsub(/\[Measures\]\.\[Measures\]/, '[Measures]').
+                            gsub(/\.\[MeasuresLevel\]/, '')
+
+        "[#{cube_name}].#{formatted_string}"
+      end
+
+      def raw_cells
+        axes_sequence = (0...axes.size).to_a.reverse
+        recursive_values(axes_sequence, 0)
+      end
+
+      def recursive_values(axes_sequence, current_index, cell_params=[])
+        if axis_number = axes_sequence[current_index]
+          (0...axes[axis_number].getPositions.size).map do |i|
+            cell_params[axis_number] = Java::JavaLang::Integer.new(i)
+            recursive_values(axes_sequence, current_index + 1, cell_params)
+          end
+        else
+          cell = @raw_cell_set.getCell(cell_params)
+          {
+            :value => cell.value,
+            :formatted_value => cell.formatted_value
+          }
+        end
+      end
+    end
+
+  end
+end

data/lib/rubiks/mondrian/connection.rb

@@ -0,0 +1,131 @@
+# Taken from mondrian-olap: https://github.com/rsim/mondrian-olap/blob/master/lib/mondrian/olap/connection.rb
+require 'rubiks/mondrian/cell_set'
+require 'rubiks/mondrian/errors'
+
+module ::Rubiks
+  module Mondrian
+
+    class Connection
+      def self.create(params)
+        connection = new(params)
+        connection.connect
+        connection
+      end
+
+      attr_reader :raw_connection, :raw_catalog, :raw_schema
+
+      def initialize(params={})
+        @params = params
+        @driver = params[:driver]
+        @connected = false
+        @raw_connection = nil
+      end
+
+      def connect
+        ::Rubiks::MondrianError.wrap_native_exception do
+          # hack to call private constructor of MondrianOlap4jDriver
+          # to avoid using DriverManager which fails to load JDBC drivers
+          # because of not seeing JRuby required jar files
+          cons = Java::MondrianOlap4j::MondrianOlap4jDriver.java_class.declared_constructor
+          cons.accessible = true
+          driver = cons.new_instance.to_java
+
+          props = java.util.Properties.new
+          props.setProperty('JdbcUser', @params[:username]) if @params[:username]
+          props.setProperty('JdbcPassword', @params[:password]) if @params[:password]
+
+          conn_string = connection_string
+          @raw_jdbc_connection = driver.connect(conn_string, props)
+
+          @raw_connection = @raw_jdbc_connection.unwrap(Java::OrgOlap4j::OlapConnection.java_class)
+          @raw_catalog = @raw_connection.getOlapCatalog
+          # currently it is assumed that there is just one schema per connection catalog
+          @raw_schema = @raw_catalog.getSchemas.first
+          @connected = true
+          true
+
+          # latest Mondrian version added ClassResolver which uses current thread class loader to load some classes
+          # therefore need to set it to JRuby class loader to ensure that Mondrian classes are found
+          # (e.g. when running mondrian-olap inside OSGi container)
+          current_thread = Java::JavaLang::Thread.currentThread
+          class_loader = current_thread.getContextClassLoader
+          begin
+            current_thread.setContextClassLoader JRuby.runtime.jruby_class_loader
+            @raw_jdbc_connection = driver.connect(conn_string, props)
+          ensure
+            current_thread.setContextClassLoader(class_loader)
+          end
+
+          @raw_connection = @raw_jdbc_connection.unwrap(Java::OrgOlap4j::OlapConnection.java_class)
+          @raw_catalog = @raw_connection.getOlapCatalog
+          # currently it is assumed that there is just one schema per connection catalog
+          @raw_schema = @raw_catalog.getSchemas.first
+          @connected = true
+          true
+        end
+      end
+
+      def connected?
+        @connected
+      end
+
+      def close
+        @raw_connection.close
+        @connected = false
+        @raw_connection = @raw_jdbc_connection = nil
+        true
+      end
+
+      def execute(query_string)
+        ::Rubiks::MondrianError.wrap_native_exception do
+          statement = @raw_connection.prepareOlapStatement(query_string)
+          ::Rubiks::Mondrian::CellSet.new(statement.executeQuery())
+        end
+      end
+
+      private
+
+      def connection_string
+        string = "jdbc:mondrian:Jdbc=#{quote_string(jdbc_uri)};JdbcDrivers=#{jdbc_driver};"
+        # by default use content checksum to reload schema when catalog has changed
+        string << "UseContentChecksum=true;" unless @params[:use_content_checksum] == false
+        if role = @params[:role] || @params[:roles]
+          roles = Array(role).map{|r| r && r.to_s.gsub(',', ',,')}.compact
+          string << "Role=#{quote_string(roles.join(','))};" unless roles.empty?
+        end
+        string << (@params[:catalog] ? "Catalog=#{catalog_uri}" : "CatalogContent=#{quote_string(catalog_content)}")
+      end
+
+      def jdbc_uri
+        "jdbc:#{@driver}://#{@params[:host]}#{@params[:port] && ":#{@params[:port]}"}/#{@params[:database]}"
+      end
+
+      def jdbc_driver
+        'org.postgresql.Driver'
+      end
+
+      def catalog_uri
+        if @params[:catalog]
+          "file://#{File.expand_path(@params[:catalog])}"
+        else
+          raise ArgumentError, 'missing catalog source'
+        end
+      end
+
+      def catalog_content
+        if @params[:catalog_content]
+          @params[:catalog_content]
+        elsif @params[:schema]
+          @params[:schema].to_xml(:driver => @driver)
+        else
+          raise ArgumentError, "Specify catalog with :catalog, :catalog_content or :schema option"
+        end
+      end
+
+      def quote_string(string)
+        "'#{string.gsub("'","''")}'"
+      end
+    end
+
+  end
+end

data/lib/rubiks/mondrian/errors.rb

@@ -0,0 +1,56 @@
+# Taken from mondrian-olap: https://github.com/rsim/mondrian-olap/blob/master/lib/mondrian/olap/error.rb
+module ::Rubiks
+
+  class MondrianError < StandardError
+    NATIVE_MONDRIAN_ERROR_REGEXP = /^(org\.olap4j\.|mondrian\.|java\.lang\.reflect\.UndeclaredThrowableException\: Mondrian Error\:)/
+
+    # 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
+
+    def initialize(native_error)
+      @native_error = native_error
+      get_root_cause
+      super(native_error.message)
+      add_root_cause_to_backtrace
+    end
+
+    def self.wrap_native_exception
+      yield
+    rescue NativeException => e
+      if e.message =~ NATIVE_MONDRIAN_ERROR_REGEXP
+        raise ::Rubiks::MondrianError.new(e)
+      else
+        raise
+      end
+    end
+
+    private
+
+    def get_root_cause
+      @root_cause = nil
+      e = @native_error
+      while e.respond_to?(:cause) && (cause = e.cause)
+        @root_cause = e = cause
+      end
+      message = e.message
+      if message =~ /\AMondrian Error:(.*)\Z/m
+        message = $1
+      end
+      @root_cause_message = message
+    end
+
+    def add_root_cause_to_backtrace
+      bt = @native_error.backtrace
+      if @root_cause
+        root_cause_bt = Array(@root_cause.backtrace)
+        root_cause_bt[0,5].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}"
+      end
+      set_backtrace bt
+    end
+  end
+
+end

data/lib/rubiks/mondrian/member.rb

@@ -0,0 +1,107 @@
+# Taken from mondrian-olap: https://github.com/rsim/mondrian-olap/blob/master/lib/mondrian/olap/cube.rb
+# require 'rubiks/mondrian/cell_set'
+# require 'rubiks/mondrian/errors'
+
+module ::Rubiks
+  module Mondrian
+
+    class Member
+      def initialize(raw_member)
+        @raw_member = raw_member
+      end
+
+      attr_reader :raw_member
+
+      def name
+        @raw_member.getName
+      end
+
+      def full_name
+        @raw_member.getUniqueName
+      end
+
+      def caption
+        @raw_member.getCaption
+      end
+
+      def calculated?
+        @raw_member.isCalculated
+      end
+
+      def calculated_in_query?
+        @raw_member.isCalculatedInQuery
+      end
+
+      def visible?
+        @raw_member.isVisible
+      end
+
+      def all_member?
+        @raw_member.isAll
+      end
+
+      def drillable?
+        return false if calculated?
+        # @raw_member.getChildMemberCount > 0
+        # This hopefully is faster than counting actual child members
+        raw_level = @raw_member.getLevel
+        raw_levels = raw_level.getHierarchy.getLevels
+        raw_levels.indexOf(raw_level) < raw_levels.size - 1
+      end
+
+      def depth
+        @raw_member.getDepth
+      end
+
+      def dimension_type
+        case @raw_member.getDimension.getDimensionType
+        when Java::OrgOlap4jMetadata::Dimension::Type::TIME
+          :time
+        when Java::OrgOlap4jMetadata::Dimension::Type::MEASURE
+          :measures
+        else
+          :standard
+        end
+      end
+
+      def children
+        ::Rubiks::MondrianError.wrap_native_exception do
+          @raw_member.getChildMembers.map{|m| ::Rubiks::Mondrian::Member.new(m)}
+        end
+      end
+
+      def descendants_at_level(level)
+        ::Rubiks::MondrianError.wrap_native_exception do
+          raw_level = @raw_member.getLevel
+          raw_levels = raw_level.getHierarchy.getLevels
+          current_level_index = raw_levels.indexOf(raw_level)
+          descendants_level_index = raw_levels.indexOfName(level)
+
+          return nil unless descendants_level_index > current_level_index
+
+          members = [self]
+          (descendants_level_index - current_level_index).times do
+            members = members.map do |member|
+              member.children
+            end.flatten
+          end
+          members
+        end
+      end
+
+      def property_value(name)
+        if property = @raw_member.getProperties.get(name)
+          @raw_member.getPropertyValue(property)
+        end
+      end
+
+      def property_formatted_value(name)
+        if property = @raw_member.getProperties.get(name)
+          @raw_member.getPropertyFormattedValue(property)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/rubiks/mondrian.rb

@@ -0,0 +1,44 @@
+require 'java'
+require 'rubiks/mondrian/connection'
+require 'rubiks/mondrian/errors'
+
+Dir[File.expand_path('../mondrian/jars/*.jar', __FILE__)].each{ |jar| require jar }
+
+# register Mondrian olap4j driver
+Java::mondrian.olap4j.MondrianOlap4jDriver
+
+module ::Rubiks
+  def self.connection
+    @connection ||= ::Rubiks::Mondrian.connection
+  end
+
+  module Mondrian
+    def self.connection
+      @connection ||= ::Rubiks::Mondrian::Connection.create(
+        config.merge(:catalog_content => ::Rubiks.schema.to_xml)
+      )
+    end
+
+    def self.config=(new_config)
+      @config = new_config
+    end
+
+    def self.config
+      @config ||= begin
+        if defined?(ActiveRecord)
+          ar_config = ActiveRecord::Base.connection.config
+
+          {
+            :driver           => ar_config[:adapter],
+            :host             => ar_config[:host],
+            :database         => ar_config[:database],
+            :username         => ar_config[:username],
+            :password         => ar_config[:password]
+          }
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/rubiks/named_object.rb

@@ -0,0 +1,121 @@
+module ::Rubiks
+
+  class NamedObject
+    def self.define(new_name=nil, options={}, &block)
+      instance = new(new_name, options)
+      instance.instance_eval(&block) if block_given?
+      instances[instance.name.to_sym] = instance
+      instance
+    end
+
+    def self.instances
+      @instances ||= Hash.new
+    end
+
+    def self.find_or_create(instance_name, options={}, &block)
+      return instances[instance_name.to_sym] if instances.has_key?(instance_name.to_sym)
+
+      new_instance = new(instance_name.to_s, options)
+      new_instance.instance_eval(&block) if block_given?
+      new_instance
+    end
+
+    def self.clear!
+      @instances = nil
+    end
+
+    def self.default
+      if instances.has_key?('default')
+        instances['default']
+      elsif instances.present?
+        instances.first[1]
+      end
+    end
+
+    def self.[](instance_name)
+      instances[instance_name.to_sym]
+    end
+
+    def initialize(new_name = nil, options = {})
+      @name = new_name.to_s if new_name.present?
+      @options = options.symbolize_keys
+    end
+
+    def name(new_value=nil)
+      @name = new_value.to_s if new_value.present?
+      @name ||= @options[:name] || 'default'
+    end
+
+    def icon_type(new_value=nil)
+      @icon_type = new_value.to_s if new_value.present?
+      @icon_type ||= @options[:icon_type]
+    end
+
+    def description(new_value=nil)
+      @description = new_value.to_s if new_value.present?
+      @description ||= @options[:description]
+    end
+
+    def visible(new_value=nil)
+      @visible = new_value.to_s unless new_value.nil?
+      @visible ||= @options.key?(:visible) ? @options[:visible].to_s : nil
+    end
+
+    def column(new_value=nil)
+      @column = new_value.to_s if new_value.present?
+      @column ||= @options[:column] || name
+    end
+
+    def caption(new_value=nil)
+      @caption = new_value if new_value.present?
+      @caption ||= @options[:caption] || name.titleize
+    end
+
+    def table(new_value=nil)
+      @table = new_value if new_value.present?
+      @table ||= @options[:table] || "view_#{name.tableize}"
+    end
+
+    def to_json(options={})
+      MultiJson.encode(json_hash, options)
+    end
+
+    def default_json_attributes
+      json_attrs = {
+        :name => name,
+        :caption => caption,
+        :description => description,
+        :icon_type => icon_type
+      }
+      json_attrs[:visible] = visible if visible.present? && visible == 'false'
+      json_attrs.delete_if { |key,value| value.nil? }
+      json_attrs.stringify_keys!
+    end
+    alias_method :json_hash, :default_json_attributes
+
+    def default_xml_attributes
+      xml_attrs = {
+        :name => caption,
+        :description => description
+      }
+      xml_attrs[:visible] = visible if visible.present? && visible == 'false'
+      xml_attrs.delete_if { |key,value| value.nil? }
+    end
+    alias_method :xml_hash, :default_xml_attributes
+
+    def to_xml(builder = nil)
+      return if name.blank?
+
+      builder = builder || new_builder
+
+      builder.__send__(name)
+    end
+
+    private
+
+    def new_builder
+      builder = Builder::XmlMarkup.new(:indent => 2) if builder.nil?
+    end
+  end
+
+end

data/lib/rubiks/schema.rb

@@ -0,0 +1,28 @@
+module ::Rubiks
+
+  class Schema < NamedObject
+    def cubes
+      @cubes ||= []
+    end
+
+    def cube(cube_name, options={}, &block)
+      cubes.push ::Rubiks::Cube.find_or_create(cube_name, options, &block)
+    end
+
+    def json_hash
+      hash = default_json_attributes
+      hash[:cubes] = cubes.map{ |c| c.json_hash } if cubes.present?
+      hash.stringify_keys!
+    end
+
+    def to_xml(builder = nil)
+      builder = builder || new_builder
+      builder.instruct!
+
+      builder.schema(:name => caption) do
+        cubes.each{ |cube| cube.to_xml(builder) }
+      end
+    end
+  end
+
+end

data/lib/rubiks/version.rb

@@ -1,3 +1,3 @@
 module ::Rubiks
-  VERSION = '0.0.6'
+  VERSION = '0.1.0'
 end