mondrian-rest 0.5.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fca6cfddd8cf42e7d87ec8e35f10b8389fdd08ff
+  data.tar.gz: 08b4017a7cdc2eebc4f0b2218b51822396061dd5
+SHA512:
+  metadata.gz: 9fba6d67d771da283e085b0d89784baa093b5676b0c737aa89cdc5ef2b4ba1e9f3c9a68574db21b85759733e7f1161ec538e2051820bc641d446a62ac6577fd9
+  data.tar.gz: 44ed30d9adf06ddfbb7fe157a8a2a6d5e1765936b82fbdbc2b24bbc12d2dbf88f23c41285d3c1f745034e82d4228d8b936128de6583c1e7e51b5d17d8fcacc59

data/.gitignore

@@ -0,0 +1 @@
+.DS_Store

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - jruby-9.1.5.0
+env:
+  - JRUBY_OPTS=--debug
+
+branches:
+  only:
+    - public

data/Gemfile

@@ -0,0 +1,5 @@
+source 'http://rubygems.org'
+gem 'mondrian-olap', :git => 'https://github.com/rsim/mondrian-olap.git', :branch => 'master'
+gem 'coveralls', require: false
+
+gemspec

data/README.md

@@ -0,0 +1,38 @@
+# mondrian-rest [![Build Status](https://travis-ci.org/jazzido/mondrian-rest.svg?branch=public)](https://travis-ci.org/jazzido/mondrian-rest) [![Coverage Status](https://coveralls.io/repos/github/jazzido/mondrian-rest/badge.svg?branch=public)](https://coveralls.io/github/jazzido/mondrian-rest?branch=public)
+
+A REST endpoint for [Mondrian](http://community.pentaho.com/projects/mondrian/)
+
+## Usage
+
+See [`mondrian-rest-demo`](https://github.com/jazzido/mondrian-rest-demo) and [`mondrian-rest-foodmart`](https://github.com/jazzido/mondrian-rest-foodmart) for example OLAP cubes implemented with `mondrian-rest`.
+
+[`mondrian-rest-ui`](https://github.com/jazzido/mondrian-rest-ui) is an experimental visualization tool for `mondrian-rest`, inspired by [CubesViewer](https://github.com/jjmontesl/cubesviewer) and [Polestar](https://github.com/vega/polestar).
+
+## Credits
+
+Initial inspiration for this project came from the [Stefan Urbanek](https://github.com/Stiivi)'s [`cubes`](http://cubes.databrewery.org/) OLAP server. `mondrian-rest` uses [Raimonds Simanovskis](https://github.com/rsim)'s fantastic [`mondrian-olap`](https://github.com/rsim/mondrian-olap) library.
+
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Manuel Aristarán
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,21 @@
+require "rspec/core/rake_task"
+
+require_relative './lib/mondrian_rest.rb'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov = true
+  t.rcov_opts =  ['--exclude', '/Library,spec/']
+end
+
+desc "API Routes"
+task :routes do
+  Mondrian::REST::Api.routes.each do |api|
+    method = api.route_method.ljust(10)
+    path = api.route_path
+    puts "     #{method} #{path}"
+  end
+end
+
+task :default => [:spec]

data/lib/mondrian_rest/api.rb

@@ -0,0 +1,175 @@
+require 'uri'
+
+require_relative './api_helpers.rb'
+require_relative './query_helper.rb'
+require_relative './api_formatters.rb'
+
+module Mondrian::REST
+
+  class Api < Grape::API
+    version '1', using: :header, vendor: 'mondrian_rest'
+    format :json
+
+    helpers Mondrian::REST::APIHelpers
+    helpers Mondrian::REST::QueryHelper
+    helpers do
+      def logger
+        Api.logger
+      end
+    end
+
+    resource :mdx do
+      content_type :xls, "application/vnd.ms-excel"
+      formatter :xls, Mondrian::REST::Formatters::XLS
+      content_type :csv, "text/csv"
+      formatter :csv, Mondrian::REST::Formatters::CSV
+      content_type :json, "application/json"
+      formatter :json, Mondrian::REST::Formatters::AggregationJSON
+
+      desc "Execute an MDX query against a cube"
+      content_type :txt, "text/plain"
+      post do
+        status 200
+
+        rbody = env['api.request.body'].force_encoding('utf-8')
+        mdx(rbody)
+      end
+    end
+
+    resource :cubes do
+      desc "Returns the cubes defined in this server's schema"
+      get do
+        {
+          'cubes' => olap.cube_names.map { |cn| olap.cube(cn).to_h }
+        }
+      end
+
+      route_param :cube_name do
+        desc "Return a cube"
+        params do
+          requires :cube_name, type: String, desc: "Cube name"
+        end
+
+        get do
+          cube = get_cube_or_404(params[:cube_name])
+          cube.to_h
+        end
+
+        resource :members do
+            desc "return a member by its full name"
+            params do
+              requires :full_name,
+                       type: String,
+                       regexp: /[a-z0-9\.,\-\s%\\[\\]\(\)]+/i
+            end
+            get do
+              member_full_name = URI.decode(params[:full_name])
+
+              m = get_member(get_cube_or_404(params[:cube_name]),
+                             member_full_name)
+              if m.nil?
+                error!("Member `#{member_full_name}` not found in cube `#{params[:cube_name]}`", 404)
+              end
+              m.to_h.merge({
+                             ancestors: m.ancestors.map(&:to_h),
+                             dimension: m.dimension_info
+                           })
+            end
+        end
+
+
+        resource :aggregate do
+          content_type :xls, "application/vnd.ms-excel"
+          formatter :xls, Mondrian::REST::Formatters::XLS
+          content_type :csv, "text/csv"
+          formatter :csv, Mondrian::REST::Formatters::CSV
+          content_type :json, "application/json"
+          formatter :json, Mondrian::REST::Formatters::AggregationJSON
+
+          desc "aggregate from query parameters"
+          params do
+            optional :measures, type: Array
+            optional :cut, type: Array, desc: "Specification of slicer axis"
+            optional :drilldown, type: Array, desc: "Dimension(s) to be drilled down"
+            optional :nonempty, type: Boolean, desc: "Only return non empty cells"
+            optional :distinct, type: Boolean, desc: "Apply DISTINCT() to every axis"
+            optional :parents, type: Boolean, desc: "Include members' ancestors"
+            optional :debug, type: Boolean, desc: "Include generated MDX", default: false
+            optional :properties, type: Array, desc: "Include member properties"
+          end
+          get do
+            cube = get_cube_or_404(params[:cube_name])
+            query = build_query(cube, params)
+            mdx_query = query.to_mdx
+
+            result = mdx(query.to_mdx)
+            result.mdx = mdx_query if params[:debug]
+            result.properties = params[:properties]
+            result.cube = cube
+
+            result
+          end
+        end
+
+        resource :dimensions do
+          route_param :dimension_name do
+            desc "Return a dimension's members"
+            params do
+              requires :cube_name, type: String, desc: "Cube name"
+              requires :dimension_name, type: String, desc: "Dimension name"
+            end
+
+            get do
+              cube = get_cube_or_404(params[:cube_name])
+              dimension = cube.dimension(params[:dimension_name])
+              dimension.to_h
+            end
+
+            resource :levels do
+              route_param :level_name do
+                resource :members do
+
+                  params do
+                    optional :member_properties, type: Array
+                  end
+
+                  get do
+                    cube = get_cube_or_404(params[:cube_name])
+
+                    dimension = cube.dimension(params[:dimension_name])
+                    if dimension.nil?
+                      error!("dimension #{params[:dimension_name]} not found in cube #{params[:cube_name]}", 404)
+                    end
+
+                    level = dimension.hierarchies[0].level(params[:level_name])
+                    if level.nil?
+                      error!("level #{params[:level_name]} not found in dimension #{params[:dimension_name]}")
+                    end
+
+                    level.to_h(params[:member_properties])
+                  end
+
+                  route_param :member_key,
+                              type: String,
+                              requirements: { member_key: /[a-z0-9\.\-\s]+/i } do
+                    get do
+                      cube = get_cube_or_404(params[:cube_name])
+                      dimension = cube.dimension(params[:dimension_name])
+                      level = dimension.hierarchies[0].level(params[:level_name])
+
+                      member = level.members.detect { |m|
+                        m.property_value('MEMBER_KEY').to_s == params[:member_key]
+                      }
+                      error!('member not found', 404) if member.nil?
+                      member.to_h.merge({ancestors: member.ancestors.map(&:to_h)})
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mondrian_rest/api_formatters.rb

@@ -0,0 +1,126 @@
+require 'csv'
+require 'writeexcel'
+
+module Mondrian::REST::Formatters
+
+  module AggregationJSON
+    def self.call(result, env)
+      add_parents = env['rack.request.query_hash']['parents'] == 'true'
+      debug = env['rack.request.query_hash']['debug'] == 'true'
+
+      result.to_h(add_parents, debug).to_json
+    end
+  end
+
+  module XLS
+    def self.call(result, env)
+      add_parents = env['rack.request.query_hash']['parents'] == 'true'
+      debug = env['rack.request.query_hash']['debug'] == 'true'
+
+      out = StringIO.new
+      book = WriteExcel.new(out)
+      sheet = book.add_worksheet
+
+      Mondrian::REST::Formatters
+        .tidy(result,
+              add_parents: add_parents,
+              debug: debug)
+        .each_with_index do |row, i|
+          row.each_with_index { |cell, j|
+            sheet.write(i, j, cell)
+          }
+      end
+
+      book.close
+      out.string
+    end
+  end
+
+  module CSV
+    def self.call(result, env)
+      add_parents = env['rack.request.query_hash']['parents'] == 'true'
+      debug = env['rack.request.query_hash']['debug'] == 'true'
+
+      rows = Mondrian::REST::Formatters.tidy(result,
+                                             add_parents: add_parents,
+                                             debug: debug)
+
+      ::CSV.generate do |csv|
+        rows.each { |row| csv << row }
+      end
+    end
+  end
+
+  ##
+  # Generate 'tidy data' (http://vita.had.co.nz/papers/tidy-data.pdf)
+  # from a result set.
+  def self.tidy(result, options)
+    cube = result.cube
+
+    add_parents = options[:add_parents]
+    rs = result.to_h(add_parents, options[:debug])
+    measures = rs[:axes].first[:members]
+    dimensions = rs[:axis_dimensions][1..-1]
+    columns = []
+    slices = []
+    level_has_all = []
+
+    Enumerator.new do |y|
+      dimensions.each do |dd|
+        if add_parents
+          hier = cube.dimension(dd[:name])
+                   .hierarchies
+                   .first
+
+          level_has_all << hier.has_all?
+          slices << dd[:level_depth]
+
+          hier
+            .levels[(hier.has_all? ? 1 : 0)...dd[:level_depth]]
+            .each do |ancestor_level|
+
+            columns += ["ID #{ancestor_level.caption}", ancestor_level.caption]
+          end
+        end
+
+        columns += ["ID #{dd[:level]}", dd[:level]]
+      end
+
+      # append measure columns and yield table header
+      y.yield columns + pluck(measures, :name)
+
+      prod = rs[:axes][1..-1].map { |e|
+        e[:members].map.with_index { |e_, i| [e_,i] }
+      }
+      values = rs[:values]
+
+      prod.shift.product(*prod).each do |cell|
+        cidxs = cell.map { |c,i| i }.reverse
+
+        cm = cell.map(&:first)
+
+        msrs = measures.map.with_index { |m, mi|
+          (cidxs + [mi]).reduce(values) { |_, idx| _[idx] }
+        }
+        if add_parents
+          vdim = cm.each.with_index.reduce([]) { |cnames, (member, j)|
+            member[:ancestors][0...slices[j] - (level_has_all[j] ? 1 : 0)].each { |ancestor|
+              cnames += [ancestor[:key], ancestor[:caption]]
+            }
+            cnames += [member[:key], member[:caption]]
+          }
+          y.yield vdim + msrs
+        else
+          y.yield pluck(cm, :key)
+                    .zip(pluck(cm, :caption))
+                    .flatten \
+                  + msrs
+        end
+      end
+    end
+  end
+
+  def self.pluck(a, m)
+    a.map { |e| e[m] }
+  end
+end

data/lib/mondrian_rest/api_helpers.rb

@@ -0,0 +1,50 @@
+module Mondrian::REST
+  module APIHelpers
+
+    @@olap = nil
+    @@mdx_parser = nil
+
+    def olap
+      if @@olap.nil?
+        @@olap = Mondrian::OLAP::Connection.new(env['mondrian-olap.params'])
+        @@olap.connect
+      end
+      @@olap
+    end
+
+    ##
+    # Returns an instance of org.olap4j.mdx.parser.MdxParser
+    def mdx_parser
+      if @@mdx_parser.nil?
+        @@mdx_parser = olap.raw_connection.getParserFactory
+                       .createMdxParser(olap.raw_connection)
+      end
+      @@mdx_parser
+    end
+
+    def olap_flush
+      if olap.connected?
+        olap.flush_schema_cache
+        olap.close
+      end
+      olap.connect
+    end
+
+    def get_cube_or_404(name)
+      cube = olap.cube(name)
+      error!('Not found', 404) if cube.nil?
+      cube
+    end
+
+    def mdx(query)
+      logger.info("Executing MDX query #{query}")
+      begin
+        result = olap.execute query
+        return result
+      rescue Mondrian::OLAP::Error => st
+        error!({error: st.backtrace}, 400)
+      end
+    end
+
+  end
+end

data/lib/mondrian_rest/mondrian_ext.rb

@@ -0,0 +1,201 @@
+module Mondrian
+  module OLAP
+
+    class Cube
+      def to_h
+        # gather dimensions
+        dimensions = self.dimensions
+                     .find_all { |d| d.dimension_type != :measures }
+                     .map { |d|
+          {
+            :name => d.name,
+            :caption => d.caption,
+            :type => d.dimension_type,
+            :annotations => d.annotations,
+            :hierarchies => d.hierarchies.map { |h|
+              {
+                :name => h.name,
+                :has_all => h.has_all?,
+                :all_member_name => h.all_member_name,
+                :levels => h.levels.map { |l|
+                  {
+                    :name => l.name,
+                    :full_name => l.full_name,
+                    :caption => l.caption
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        return {
+          :name => self.name,
+          :annotations => self.annotations,
+          :dimensions => dimensions,
+          :measures => self.dimensions
+                      .find(&:measures?)
+                      .hierarchy
+                      .levels.first
+                      .members
+                      .find_all(&:visible?)
+                      .map do |m|
+            {
+              :name => m.name,
+              :caption => m.caption,
+              :annotations => m.annotations,
+              :full_name => m.full_name
+            }
+          end
+        }
+      end
+
+    end
+
+    class Dimension
+      def to_h
+        {
+          hierarchies: self.hierarchies.map { |h|
+            {
+              name: h.name,
+              has_all: h.has_all?,
+              levels: h.levels.map(&:to_h) #/levels
+            } # /hierarchies
+          } #/map
+        } #/ dimension
+      end
+    end
+
+    class Level
+      attr_reader :hierarchy
+
+      def full_name
+        @full_name ||= @raw_level.getUniqueName
+      end
+
+      def to_h(member_properties=[])
+        {
+          name: self.name,
+          caption: self.caption,
+          members: self.members
+            .uniq { |m| m.property_value('MEMBER_KEY') }
+            .map { |m| m.to_h(member_properties) }
+        }
+      end
+    end
+
+    class Member
+
+      def raw_level
+        @raw_member.getLevel
+      end
+
+      def to_h(properties=[])
+        kv = [:name, :full_name, :caption, :all_member?,
+              :drillable?, :depth].map { |m|
+          [m, self.send(m)]
+        }
+        kv << [:key, self.property_value('MEMBER_KEY')]
+        kv << [:num_children, self.property_value('CHILDREN_CARDINALITY')]
+        kv << [:parent_name, self.property_value('PARENT_UNIQUE_NAME')]
+
+        if properties.size > 0
+          kv << [
+            :properties,
+            properties.reduce({}) { |h, p| h[p] = self.property_value(p); h }
+          ]
+        end
+
+        Hash[kv]
+      end
+
+      def dimension_info
+        d = @raw_member.getDimension
+        l = @raw_member.getLevel
+        {
+          name: d.getName,
+          caption: d.getCaption,
+          type: self.dimension_type,
+          level: l.getCaption,
+          level_depth: l.depth
+        }
+      end
+
+      def ancestors
+        @raw_member.getAncestorMembers.map { |am|
+          self.class.new(am)
+        }
+      end
+    end
+
+    class Result
+
+      attr_accessor :cube, :mdx, :properties
+
+      def to_json
+        to_h.to_json
+      end
+
+      def to_h(parents=false, debug=false)
+        # XXX TODO
+        # return the contents of the filter axis
+        # puts self.raw_cell_set.getFilterAxis.inspect
+
+        dimensions = self.axis_members.map { |am| am.first.dimension_info }
+
+        pprops = unless self.properties.nil?
+                   parse_properties(dimensions[1..-1]) # exclude Measures dimension
+                 else
+                   {}
+                 end
+
+        rv = {
+          axes: self.axis_members.each_with_index.map { |a, i|
+            {
+              members: a.map { |m|
+                mh = m.to_h(pprops[m.raw_member.getDimension.name] || [])
+                if parents
+                  mh.merge!({
+                              ancestors: m.ancestors.map { |ma|
+                                ma.to_h(pprops[ma.raw_member.getDimension.name] || [])
+                              }
+                            })
+                end
+                mh
+              }
+            }
+          },
+          axis_dimensions: dimensions,
+          values: self.values
+        }
+
+        rv[:mdx] = self.mdx if debug
+
+        rv
+
+      end
+
+      private
+
+      ##
+      #
+      def parse_properties(dimensions)
+        self.properties.reduce({}) { |h, p|
+          sl = org.olap4j.mdx.IdentifierNode.parseIdentifier(p).getSegmentList.to_a
+          if sl.size != 2
+            raise "Properties must be in the form `Dimension.Property Name`"
+          end
+
+          # check that the dimension is in the drilldown list
+          if dimensions.find { |ad| sl[0].name == ad[:name] }.nil?
+            raise "Dimension `#{sl[0].name}` not in drilldown list"
+          end
+
+          h[sl[0].name] ||= []
+          h[sl[0].name] << sl[1].name
+          h
+        }
+      end
+    end
+  end
+end

data/lib/mondrian_rest/query_helper.rb

@@ -0,0 +1,188 @@
+module Mondrian::REST
+  module QueryHelper
+
+    def unparse_node(node)
+      sw = java.io.StringWriter.new
+      ptw = org.olap4j.mdx.ParseTreeWriter.new(sw)
+      node.unparse(ptw)
+      sw.toString
+    end
+
+    def get_dimension(cube, dname)
+      cube_dimensions = cube.dimensions
+                        .find_all { |d| d.dimension_type != :measures }
+      dim = cube_dimensions.find { |d| d.name == dname }
+      error!("Dimension #{dname} does not exist", 400) if dim.nil?
+      dim
+    end
+
+    def get_member(cube, member_exp)
+      begin
+        rm = cube.raw_cube
+           .lookupMember(org.olap4j.mdx.IdentifierNode.parseIdentifier(member_exp).getSegmentList)
+      rescue Java::JavaLang::IllegalArgumentException
+        error!("Illegal member expression: #{member_exp}", 400)
+      end
+      member = nil
+      unless rm.nil?
+        member = Mondrian::OLAP::Member.new(rm)
+      end
+      member
+    end
+
+    def parse_cut(cube, cut_expr)
+      p = mdx_parser.parseExpression(cut_expr)
+
+      case p
+      when org.olap4j.mdx.CallNode
+        case p.getOperatorName
+        when "{}"
+          # check that the set contains only Members of a single dimension level
+          ls = p.getArgList.map { |id_node|
+            get_member(cube, unparse_node(id_node)).raw_level
+          }.uniq
+          unless ls.size == 1
+            error!("Illegal cut: " + cut_expr, 400)
+          end
+          { level: ls.first, cut: unparse_node(p), type: :set }
+        when "()"
+          # check that the range contains a valid range
+
+          unless p.getArgList.first.is_a?(org.olap4j.mdx.CallNode) \
+            and p.getArgList.first.getOperatorName == ':'
+            error!("Illegal cut: " + cut_expr, 400)
+          end
+
+          ls = p.getArgList.first.getArgList.map { |id_node|
+            get_member(cube, unparse_node(id_node)).raw_level
+          }.uniq
+
+          unless ls.size == 1
+            error!("Illegal cut: " + cut_expr, 400)
+          end
+
+          { level: ls.first, cut: unparse_node(p), type: :range }
+        else
+          error!("Illegal cut: " + cut_expr, 400)
+        end
+      when org.olap4j.mdx.IdentifierNode
+        # if `cut_expr` looks like a member, check that it's level is
+        # equal to `level`
+        m = get_member(cube, cut_expr)
+        { level: m.raw_level, cut: cut_expr, type: :member }
+      else
+        error!("Illegal cut: " + cut_expr, 400)
+      end
+    end
+
+    ##
+    # Parses a drilldown specification
+    # XXX TODO write doc
+    def parse_drilldown(cube, drilldown)
+      begin
+        s = org.olap4j.mdx.IdentifierNode.parseIdentifier(drilldown).getSegmentList
+      rescue Java::JavaLang::IllegalArgumentException
+        error!("Illegal drilldown specification: #{drilldown}", 400)
+      end
+
+      if s.size > 3 || s.map(&:quoting).any? { |q| q.name == 'KEY' }
+        error!("Illegal drilldown specification: #{drilldown}", 400)
+        return
+      end
+
+      dimension = get_dimension(cube, s.first.name)
+      hierarchy = dimension.hierarchies.first
+      level = hierarchy.levels[hierarchy.has_all? ? 1 : 0]
+
+      if s.size > 1
+        if s.size == 3 # 3 parts, means that a hierarchy was provided
+          hierarchy = dimension.hierarchies.find { |h_| h_.name == "#{dimension.name}.#{s[1].name}" }
+          if hierarchy.nil?
+            error!("Hierarchy `#{s[1].name}` does not exist in dimension #{dimension.name}", 404)
+          end
+        end
+        level = hierarchy.levels.find { |l_| l_.name == s[s.size - 1].name }
+        if level.nil?
+          error!("Level `#{s[1].name}` does not exist in #{dimension.name}", 404)
+        end
+      end
+
+      level
+    end
+
+    def build_query(cube, options={})
+
+      measure_members = cube.dimension('Measures').hierarchy.levels.first.members
+      options = {
+        'cut' => [],
+        'drilldown' => [],
+        'measures' => [measure_members.first.name],
+        'nonempty' => false,
+        'distinct' => false
+      }.merge(options)
+
+      # validate measures exist
+      cm_names = measure_members.map(&:name)
+
+      options['measures'].each { |m|
+        error!("Measure #{m} does not exist in cube #{cube.name}", 404) unless cm_names.include?(m)
+      }
+
+      # measures go in axis(0) of the resultset
+      query = olap.from(cube.name)
+              .axis(0,
+                    *options['measures'].map { |m|
+                      measure_members.find { |cm| cm.name == m }.full_name
+                    })
+      if options['nonempty']
+        query = query.nonempty
+      end
+      axis_idx = 1
+
+      query_axes = options['drilldown'].map { |dd| parse_drilldown(cube, dd) }
+
+      slicer_axis = options['cut'].reduce({}) { |h, cut_expr|
+        pc = parse_cut(cube, cut_expr)
+        h[pc[:level]] = pc
+        h
+      }
+
+      dd = query_axes.map do |qa|
+        # there's a slice (cut) on this axis
+        if slicer_axis[qa.raw_level]
+          cut = slicer_axis.delete(qa.raw_level)
+          case cut[:type]
+          when :member
+            "{#{cut[:cut]}}"
+          else
+            cut[:cut]
+          end
+        else
+          qa.raw_level.unique_name + '.Members'
+        end
+      end
+
+      # query axes (drilldown)
+      dd.each do |ds|
+        query = query.axis(axis_idx,
+                           ds)
+
+        if options['distinct']
+          query = query.distinct
+        end
+
+        if options['nonempty']
+          query = query.nonempty
+        end
+
+        axis_idx += 1
+      end
+
+      # slicer axes (cut)
+      if slicer_axis.size >= 1
+        query = query.where(slicer_axis.values.map { |v| v[:cut] })
+      end
+      query
+    end
+  end
+end

data/lib/mondrian_rest/version.rb

@@ -0,0 +1,3 @@
+module Mondrian::REST
+  VERSION = "0.5.0"
+end

data/lib/mondrian_rest.rb

@@ -0,0 +1,9 @@
+require 'json'
+
+Java::JavaLang::System.setProperty("jdbc.driver.autoload", "true")
+
+require 'mondrian-olap'
+require 'grape'
+
+require_relative './mondrian_rest/api.rb'
+require_relative './mondrian_rest/mondrian_ext.rb'

data/mondrian-rest.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+Gem::Specification.new do |s|
+  s.name        = "mondrian-rest"
+  s.version     = '0.5.0'
+  s.authors     = ["Manuel Aristarán"]
+  s.email       = ["manuel@jazzido.com"]
+  s.homepage    = "https://github.com/jazzido/mondrian-rest"
+  s.summary     = %q{A REST interface for Mondrian ROLAP server}
+  s.description = %q{A REST interface for Mondrian ROLAP server}
+  s.license     = 'MIT'
+
+  s.platform = 'java'
+
+  s.files         = `git ls-files`.split("\n").reject { |f| f =~ /^spec\// }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency 'mondrian-olap', ["~> 0.7.0"]
+  s.add_runtime_dependency 'grape', ["~> 0.14.0"]
+  s.add_runtime_dependency 'writeexcel', '~> 1.0', '>= 1.0.5'
+
+  s.add_development_dependency 'rake', '~> 10.4', '>= 10.4.2'
+  s.add_development_dependency 'rspec', '~> 3.4', '>= 3.4.0'
+  s.add_development_dependency 'jdbc-derby', '~> 10.11', '>= 10.11.1.1'
+  s.add_development_dependency 'jdbc-sqlite3', '~> 3.8', '>= 3.8.11.2'
+  s.add_development_dependency 'rack-test', '~> 0.6.3'
+  s.add_development_dependency 'rubyzip', '~> 1.1', '>= 1.1.7'
+end

metadata

@@ -0,0 +1,219 @@
+--- !ruby/object:Gem::Specification
+name: mondrian-rest
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: java
+authors:
+- Manuel Aristarán
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2016-10-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  name: mondrian-olap
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  name: grape
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  name: writeexcel
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  name: rake
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.11.1.1
+  name: jdbc-derby
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.11.1.1
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.11.2
+  name: jdbc-sqlite3
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.11.2
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  name: rack-test
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.7
+  name: rubyzip
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.7
+description: A REST interface for Mondrian ROLAP server
+email:
+- manuel@jazzido.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/mondrian_rest.rb
+- lib/mondrian_rest/api.rb
+- lib/mondrian_rest/api_formatters.rb
+- lib/mondrian_rest/api_helpers.rb
+- lib/mondrian_rest/mondrian_ext.rb
+- lib/mondrian_rest/query_helper.rb
+- lib/mondrian_rest/version.rb
+- mondrian-rest.gemspec
+homepage: https://github.com/jazzido/mondrian-rest
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.8
+signing_key:
+specification_version: 4
+summary: A REST interface for Mondrian ROLAP server
+test_files: []