mondrian-olap 0.3.0 → 0.5.0

data/lib/mondrian/olap/schema_element.rb

@@ -1,9 +1,7 @@
-require 'nokogiri'
-
 module Mondrian
   module OLAP
     class SchemaElement
-      def initialize(name = nil, attributes = {}, &block)
+      def initialize(name = nil, attributes = {}, parent = nil, &block)
         # if just attributes hash provided
         if name.is_a?(Hash) && attributes == {}
           attributes = name
@@ -12,7 +10,14 @@ module Mondrian
         @attributes = {}
         if name
           if self.class.content
-            @content = name
+            if attributes.is_a?(Hash)
+              @content = name
+            else
+              # used for Annotation element where both name and content is given as arguments
+              @attributes[:name] = name
+              @content = attributes
+              attributes = {}
+            end
           else
             @attributes[:name] = name
           end
@@ -21,8 +26,12 @@ module Mondrian
         self.class.elements.each do |element|
           instance_variable_set("@#{pluralize(element)}", [])
         end
+        # extract annotations from options
+        if @attributes[:annotations] && self.class.elements.include?(:annotations)
+          annotations @attributes.delete(:annotations)
+        end
         @xml_fragments = []
-        instance_eval &block if block
+        instance_eval(&block) if block
       end
 
       def self.attributes(*names)
@@ -54,10 +63,11 @@ module Mondrian
         @elements.concat(names)
 
         names.each do |name|
+          next if name == :xml
           attr_reader pluralize(name).to_sym
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{name}(name=nil, attributes = {}, &block)
-              @#{pluralize(name)} << Schema::#{camel_case(name)}.new(name, attributes, &block)
+              @#{pluralize(name)} << Schema::#{camel_case(name)}.new(name, attributes, self, &block)
             end
           RUBY
         end
@@ -78,7 +88,7 @@ module Mondrian
 
       def to_xml(options={})
         options[:upcase_data_dictionary] = @upcase_data_dictionary unless @upcase_data_dictionary.nil?
-        Nokogiri::XML::Builder.new do |xml|
+        Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
           add_to_xml(xml, options)
         end.to_xml
       end
@@ -90,16 +100,26 @@ module Mondrian
           xml.send(tag_name(self.class.name), @content, xmlized_attributes(options))
         else
           xml.send(tag_name(self.class.name), xmlized_attributes(options)) do
+            xml_fragments_added = false
             self.class.elements.each do |element|
-              instance_variable_get("@#{pluralize(element)}").each {|item| item.add_to_xml(xml, options)}
-            end
-            @xml_fragments.each do |xml_fragment|
-              xml.send(:insert, Nokogiri::XML::DocumentFragment.parse(xml_fragment))
+              if element == :xml
+                add_xml_fragments(xml)
+                xml_fragments_added = true
+              else
+                instance_variable_get("@#{pluralize(element)}").each {|item| item.add_to_xml(xml, options)}
+              end
             end
+            add_xml_fragments(xml) unless xml_fragments_added
           end
         end
       end
 
+      def add_xml_fragments(xml)
+        @xml_fragments.each do |xml_fragment|
+          xml.send(:insert, Nokogiri::XML::DocumentFragment.parse(xml_fragment))
+        end
+      end
+
       private
 
       def xmlized_attributes(options)

data/lib/mondrian/olap/schema_udf.rb

@@ -0,0 +1,331 @@
+require 'jruby/core_ext'
+
+module Mondrian
+  module OLAP
+    class Schema < SchemaElement
+
+      def user_defined_cell_formatter(name, &block)
+        CellFormatter.new(name, &block)
+      end
+
+      module ScriptElements
+        def javascript(text)
+          script text, :language => 'JavaScript'
+        end
+
+        private
+
+        def coffeescript_function(arguments_string, text)
+          # construct function to ensure that last expression is returned
+          coffee_text = "#{arguments_string} ->\n" << text.gsub(/^/,'  ')
+          javascript_text = CoffeeScript.compile(coffee_text, :bare => true)
+          # remove function definition first and last lines
+          javascript_text = javascript_text.strip.lines.to_a[1..-2].join
+          javascript javascript_text
+        end
+
+        def ruby(*options, &block)
+          udf_class_name = if options.include?(:shared)
+            "#{name.capitalize}Udf"
+          end
+          if udf_class_name && self.class.const_defined?(udf_class_name)
+            udf_class = self.class.const_get(udf_class_name)
+          else
+            udf_class = Class.new(RubyUdfBase)
+            self.class.const_set(udf_class_name, udf_class) if udf_class_name
+          end
+          udf_class.function_name = name
+          udf_class.class_eval(&block)
+          udf_java_class = udf_class.become_java!(false)
+
+          class_name udf_java_class.getName
+        end
+
+        def ruby_formatter(options, interface_class, method, signature, &block)
+          formatter_class_name = if options.include?(:shared) && @attributes[:name]
+            ruby_formatter_name_to_class_name(@attributes[:name])
+          end
+          if formatter_class_name && self.class.const_defined?(formatter_class_name)
+            formatter_class = self.class.const_get(formatter_class_name)
+          else
+            formatter_class = Class.new
+            self.class.const_set(formatter_class_name, formatter_class) if formatter_class_name
+          end
+
+          formatter_class.class_eval do
+            include interface_class
+            define_method method, &block
+            add_method_signature(method, signature)
+          end
+          formatter_java_class = formatter_class.become_java!(false)
+          class_name formatter_java_class.getName
+        end
+
+        def ruby_formatter_name_to_class_name(name)
+          # upcase just first character
+          "#{name.sub(/\A./){|m| m.upcase}}Udf"
+        end
+
+        def ruby_formatter_java_class_name(name)
+          "rubyobj.#{self.class.name.gsub('::','.')}.#{ruby_formatter_name_to_class_name(name)}"
+        end
+
+      end
+
+      class UserDefinedFunction < SchemaElement
+        include ScriptElements
+        attributes :name, # Name with which the user-defined function will be referenced in MDX expressions.
+          # Name of the class which implemenets this user-defined function.
+          # Must implement the mondrian.spi.UserDefinedFunction  interface.
+          :class_name
+        elements :script
+
+        def coffeescript(text)
+          coffee_text = "__udf__ = {\n" << text << "}\n"
+          javascript_text = CoffeeScript.compile(coffee_text, :bare => true)
+          javascript_text << <<-JS
+
+__udf__.parameters || (__udf__.parameters = []);
+__udf__.returns || (__udf__.returns = "Scalar");
+var __scalarTypes__ = {"Numeric":true,"String":true,"Boolean":true,"DateTime":true,"Decimal":true,"Scalar":true};
+function __getType__(type) {
+  if (__scalarTypes__[type]) {
+    return new mondrian.olap.type[type+"Type"];
+  } else if (type === "Member") {
+    return mondrian.olap.type.MemberType.Unknown;
+  } else {
+    return null;
+  }
+}
+function getParameterTypes() {
+  var parameters = __udf__.parameters || [],
+      types = [];
+  for (var i = 0, len = parameters.length; i < len; i++) {
+    types.push(__getType__(parameters[i]))
+  }
+  return types;
+}
+function getReturnType(parameterTypes) {
+  var returns = __udf__.returns || "Scalar";
+  return __getType__(returns);
+}
+if (__udf__.syntax) {
+  function getSyntax() {
+    return mondrian.olap.Syntax[__udf__.syntax];
+  }
+}
+function execute(evaluator, args) {
+  var parameters = __udf__.parameters || [],
+      values = [],
+      value;
+  for (var i = 0, len = parameters.length; i < len; i++) {
+    if (__scalarTypes__[parameters[i]]) {
+      value = args[i].evaluateScalar(evaluator);
+    } else {
+      value = args[i].evaluate(evaluator);
+    }
+    values.push(value);
+  }
+  return __udf__.execute.apply(__udf__, values);
+}
+JS
+          javascript javascript_text
+        end
+
+        class RubyUdfBase
+          include Java::mondrian.spi.UserDefinedFunction
+          def self.function_name=(name); @function_name = name; end
+          def self.function_name; @function_name; end
+
+          def getName
+            self.class.function_name
+          end
+          add_method_signature("getName", [java.lang.String])
+
+          def getDescription
+            getName
+          end
+          add_method_signature("getDescription", [java.lang.String])
+
+          def self.parameters(*types)
+            if types.empty?
+              @parameters || []
+            else
+              @parameters = types.map{|type| stringified_type(type)}
+            end
+          end
+
+          def self.returns(type = nil)
+            if type
+              @returns = stringified_type(type)
+            else
+              @returns || 'Scalar'
+            end
+          end
+
+          VALID_SYNTAX_TYPES = %w(Function Property Method)
+          def self.syntax(type = nil)
+            if type
+              type = stringify(type)
+              raise ArgumentError, "invalid user defined function type #{type.inspect}" unless VALID_SYNTAX_TYPES.include? type
+              @syntax = type
+            else
+              @syntax || 'Function'
+            end
+          end
+
+          def getSyntax
+            Java::mondrian.olap.Syntax.const_get self.class.syntax
+          end
+          add_method_signature("getSyntax", [Java::mondrian.olap.Syntax])
+
+          UDF_SCALAR_TYPES = {
+            "Numeric" => Java::mondrian.olap.type.NumericType,
+            "String" => Java::mondrian.olap.type.StringType,
+            "Boolean" => Java::mondrian.olap.type.BooleanType,
+            "DateTime" => Java::mondrian.olap.type.DateTimeType,
+            "Decimal" => Java::mondrian.olap.type.DecimalType,
+            "Scalar" => Java::mondrian.olap.type.ScalarType
+          }
+          UDF_OTHER_TYPES = {
+            "Member" => Java::mondrian.olap.type.MemberType::Unknown,
+            "Set" => Java::mondrian.olap.type.SetType.new(Java::mondrian.olap.type.MemberType::Unknown),
+            "Hierarchy" => Java::mondrian.olap.type.HierarchyType.new(nil, nil),
+            "Level" => Java::mondrian.olap.type.LevelType::Unknown
+          }
+
+          def getParameterTypes
+            @parameterTypes ||= self.class.parameters.map{|p| get_java_type(p)}
+          end
+          class_loader = JRuby.runtime.jruby_class_loader
+          type_array_class = java.lang.Class.forName "[Lmondrian.olap.type.Type;", true, class_loader
+          add_method_signature("getParameterTypes", [type_array_class])
+
+          def getReturnType(parameterTypes)
+            @returnType ||= get_java_type self.class.returns
+          end
+          add_method_signature("getReturnType", [Java::mondrian.olap.type.Type, type_array_class])
+
+          def getReservedWords
+            nil
+          end
+          string_array_class = java.lang.Class.forName "[Ljava.lang.String;", true, class_loader
+          add_method_signature("getReservedWords", [string_array_class])
+
+          def execute(evaluator, arguments)
+            values = []
+            self.class.parameters.each_with_index do |p,i|
+              value = UDF_SCALAR_TYPES[p] ? arguments[i].evaluateScalar(evaluator) : arguments[i].evaluate(evaluator)
+              values << value
+            end
+            call_with_evaluator(evaluator, *values)
+          end
+          arguments_array_class = java.lang.Class.forName "[Lmondrian.spi.UserDefinedFunction$Argument;", true, class_loader
+          add_method_signature("execute", [java.lang.Object, Java::mondrian.olap.Evaluator, arguments_array_class])
+
+          # Override this metho if evaluator is needed
+          def call_with_evaluator(evaluator, *values)
+            call(*values)
+          end
+
+          private
+
+          def get_java_type(type)
+            if type_class = UDF_SCALAR_TYPES[type]
+              type_class.new
+            else
+              UDF_OTHER_TYPES[type]
+            end
+          end
+
+          def self.stringified_type(type)
+            type = stringify(type)
+            raise ArgumentError, "invalid user defined function type #{type.inspect}" unless UDF_SCALAR_TYPES[type] || UDF_OTHER_TYPES[type]
+            type
+          end
+
+          def self.stringify(arg)
+            arg = arg.to_s.split('_').map{|s| s.capitalize}.join if arg.is_a? Symbol
+            arg
+          end
+        end
+
+        def ruby(*options, &block)
+          udf_class_name = if options.include?(:shared)
+            "#{name.capitalize}Udf"
+          end
+          if udf_class_name && self.class.const_defined?(udf_class_name)
+            udf_class = self.class.const_get(udf_class_name)
+          else
+            udf_class = Class.new(RubyUdfBase)
+            self.class.const_set(udf_class_name, udf_class) if udf_class_name
+          end
+          udf_class.function_name = name
+          udf_class.class_eval(&block)
+          udf_java_class = udf_class.become_java!(false)
+
+          class_name udf_java_class.getName
+        end
+      end
+
+      class Script < SchemaElement
+        attributes :language
+        content :text
+      end
+
+      class CellFormatter < SchemaElement
+        include ScriptElements
+        # Name of a formatter class for the appropriate cell being displayed.
+        # The class must implement the mondrian.olap.CellFormatter interface.
+        attributes :class_name
+        elements :script
+
+        def initialize(name = nil, attributes = {}, parent = nil, &block)
+          super
+          if name && !attributes[:class_name] && !block_given?
+            # use shared ruby implementation
+            @attributes[:class_name] = ruby_formatter_java_class_name(name)
+            @attributes.delete(:name)
+          end
+        end
+
+        def coffeescript(text)
+          coffeescript_function('(value)', text)
+        end
+
+        def ruby(*options, &block)
+          ruby_formatter(options, Java::mondrian.spi.CellFormatter, 'formatCell', [java.lang.String, java.lang.Object], &block)
+        end
+      end
+
+      class MemberFormatter < SchemaElement
+        include ScriptElements
+        attributes :class_name
+        elements :script
+
+        def coffeescript(text)
+          coffeescript_function('(member)', text)
+        end
+
+        def ruby(*options, &block)
+          ruby_formatter(options, Java::mondrian.spi.MemberFormatter, 'formatMember', [java.lang.String, Java::mondrian.olap.Member], &block)
+        end
+      end
+
+      class PropertyFormatter < SchemaElement
+        include ScriptElements
+        attributes :class_name
+        elements :script
+
+        def coffeescript(text)
+          coffeescript_function('(member,propertyName,propertyValue)', text)
+        end
+
+        def ruby(*options, &block)
+          ruby_formatter(options, Java::mondrian.spi.PropertyFormatter, 'formatProperty', [java.lang.String, Java::mondrian.olap.Member, java.lang.String, java.lang.Object], &block)
+        end
+      end
+
+    end
+  end
+end

data/lib/mondrian/olap/version.rb

@@ -0,0 +1,5 @@
+module Mondrian
+  module OLAP
+    VERSION = File.read(File.expand_path('../../../../VERSION', __FILE__)).chomp
+  end
+end

data/spec/connection_role_spec.rb

@@ -0,0 +1,130 @@
+require "spec_helper"
+
+describe "Connection role" do
+
+  describe "create connection" do
+    before(:each) do
+      @role_name = role_name = 'California manager'
+      @role_name2 = role_name2 = 'Dummy, with comma'
+      @schema = Mondrian::OLAP::Schema.define do
+        cube 'Sales' do
+          table 'sales'
+          dimension 'Gender', :foreign_key => 'customer_id' do
+            hierarchy :has_all => true, :primary_key => 'id' do
+              table 'customers'
+              level 'Gender', :column => 'gender', :unique_members => true
+            end
+          end
+          dimension 'Customers', :foreign_key => 'customer_id' do
+            hierarchy :has_all => true, :all_member_name => 'All Customers', :primary_key => 'id' do
+              table 'customers'
+              level 'Country', :column => 'country', :unique_members => true
+              level 'State Province', :column => 'state_province', :unique_members => true
+              level 'City', :column => 'city', :unique_members => false
+              level 'Name', :column => 'fullname', :unique_members => true
+            end
+          end
+          dimension 'Time', :foreign_key => 'time_id' do
+            hierarchy :has_all => false, :primary_key => 'id' do
+              table 'time'
+              level 'Year', :column => 'the_year', :type => 'Numeric', :unique_members => true
+              level 'Quarter', :column => 'quarter', :unique_members => false
+              level 'Month', :column => 'month_of_year', :type => 'Numeric', :unique_members => false
+            end
+          end
+          measure 'Unit Sales', :column => 'unit_sales', :aggregator => 'sum'
+          measure 'Store Sales', :column => 'store_sales', :aggregator => 'sum'
+        end
+        role role_name do
+          schema_grant :access => 'none' do
+            cube_grant :cube => 'Sales', :access => 'all' do
+              dimension_grant :dimension => '[Measures]', :access => 'all'
+              hierarchy_grant :hierarchy => '[Customers]', :access => 'custom',
+                              :top_level => '[Customers].[State Province]', :bottom_level => '[Customers].[City]' do
+                member_grant :member => '[Customers].[USA].[CA]', :access => 'all'
+                member_grant :member => '[Customers].[USA].[CA].[Los Angeles]', :access => 'none'
+              end
+            end
+          end
+        end
+        role role_name2
+
+        # to test that Role elements are generated before UserDefinedFunction
+        user_defined_function 'Factorial' do
+          ruby do
+            parameters :numeric
+            returns :numeric
+            def call(n)
+              n <= 1 ? 1 : n * call(n - 1)
+            end
+          end
+        end
+      end
+      @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema)
+    end
+
+    it "should connect" do
+      @olap.should be_connected
+    end
+
+    it "should get available role names" do
+      @olap.available_role_names.should == [@role_name, @role_name2]
+    end
+
+    it "should not get role name if not set" do
+      @olap.role_name.should be_nil
+      @olap.role_names.should be_empty
+    end
+
+    it "should set and get role name" do
+      @olap.role_name = @role_name
+      @olap.role_name.should == @role_name
+      @olap.role_names.should == [@role_name]
+    end
+
+    it "should raise error when invalid role name is set" do
+      expect {
+        @olap.role_name = 'invalid'
+      }.to raise_error {|e|
+        e.should be_kind_of(Mondrian::OLAP::Error)
+        e.message.should == "org.olap4j.OlapException: Unknown role 'invalid'"
+        e.root_cause_message.should == "Unknown role 'invalid'"
+      }
+    end
+
+    it "should set and get several role names" do
+      @olap.role_names = [@role_name, @role_name2]
+      @olap.role_name.should == "[#{@role_name}, #{@role_name2}]"
+      @olap.role_names.should == [@role_name, @role_name2]
+    end
+
+    it "should not get non-visible member" do
+      @cube = @olap.cube('Sales')
+      @cube.member('[Customers].[USA].[CA].[Los Angeles]').should_not be_nil
+      @olap.role_name = @role_name
+      @cube.member('[Customers].[USA].[CA].[Los Angeles]').should be_nil
+    end
+
+    # TODO: investigate why role name is not returned when set in connection string
+    # it "should set role name from connection parameters" do
+    #   @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema,
+    #     :role => @role_name)
+    #   @olap.role_name.should == @role_name
+    # end
+
+    it "should not get non-visible member when role name set in connection parameters" do
+      @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema,
+        :role => @role_name)
+      @cube = @olap.cube('Sales')
+      @cube.member('[Customers].[USA].[CA].[Los Angeles]').should be_nil
+    end
+
+    it "should not get non-visible member when several role names set in connection parameters" do
+      @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema,
+        :roles => [@role_name, @role_name2])
+      @cube = @olap.cube('Sales')
+      @cube.member('[Customers].[USA].[CA].[Los Angeles]').should be_nil
+    end
+
+  end
+end