martyr 0.1.74.pre

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in martyr.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Amit Aharoni
+
+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/README.md

@@ -0,0 +1,265 @@
+# Martyr
+  A multi-dimensional semantic layer on top of ActiveRecord that allows running pivot table queries and rendering
+  them as CSV, HTML, or KickChart-ready hashes. Supports time dimensions, cohort analysis, custom rollups, and drilling
+  through to the underlying ActiveRecord objects.
+
+  Designed predominantly to allow staff members and site owners to slice and dice data and easily produce reports.
+
+  Warning:
+  This gem is not production ready.
+
+  More to come...
+
+## The problem
+  The following simple queries demonstrate a core issue with relational data:
+
+```ruby
+# Fetch count of all posts that were created 3 days ago
+Post.where('created_at > ?', 3.days.ago)
+
+# Fetch count of all posts that were created by the author whose email is me@domain.com
+Post.joins(:author).where('authors.email' => 'me@domain.com')
+```
+   These two queries represent similar requests from the perspective of a human user. However, fulfilling these requests
+   requires knowledge about the structure of the database. This limits the  ability to provide "free form" slicing and dicing of data.
+
+   Compare these queries with Martyr standard query interface:
+```ruby
+# Fetch count of all posts that were created 3 days ago
+PostCube.slice('post.created_at', gt: 3.days.ago)
+
+# Fetch count of all posts that were created by the author whose email is me@domain.com
+PostCube.slice('author.email', with: 'me@domain.com')
+
+# As a compound hash format:
+PostCube.slice('author.email' => {with: 'me@domain.com'}, 'post.created_at' => {gt: 3.days.ago})
+```
+  The last example demonstrates an important aspect of Martyr. A simple standard hash - which can be easily
+  serialized over HTTP requests - represents a slice of data that can be further manipulated. This means you can have
+  one standard controller action for displaying tables and graphs of any data you like.
+
+  Martyr keeps track of the slice of every element you query:
+
+```ruby
+pivot_table = PostCube.slice('post.created_at', gt: 3.days.ago).pivot.on_columns('post_count').on_rows('authors.email')
+first_row = pivot_table.rows.first
+cell = first_row.cell_at['post_count']
+cell.coordinates
+# => { 'metric' => 'posts_cube.post_count', 'post.created_at' => {gt: 3.days.ago}, 'authors.email' => {with: 'first_row@domain.com'} }
+```
+
+  So an ERB partial that renders this cell as a link to another report - number of comments per post-type for that particular author and created_at constraints - may look like this:
+```ERB
+<% data = Base64.urlsafe_encode64 {current_slice: cell.coordinates,
+                                   on_rows: ['post.type'],
+                                   on_columns: ['comment.type'],
+                                   view: 'my_drill_down_report' }.to_json %>
+
+<%= link_to cell.value, standard_report_action_path(data: data) %>
+```
+
+  And the standard (non-secure) controller action can be as simple as:
+```ruby
+def standard_drill_down
+  hash = JSON.parse(Base64.urlsafe_decode64(params[:data]}
+  query = PostCube.slice(hash['current_slice']).granulate(hash['on_rows'] + hash['on_columns'])
+  @pivot_table = query.pivot.on_columns(hash['on_columns']).on_rows(hash['on_rows'])
+  render hash['view']
+end
+```
+
+
+The examples that follow refer to the open source Chinook database schema.
+
+## Semantic layer DSL
+
+```ruby
+class SharedDimensions < Martyr::Cube
+  define_dimension :genres do
+    degenerate_level :name
+  end
+
+  define_dimension :media_types do
+    degenerate_level :name
+  end
+
+  define_dimension :customers do
+    degenerate_level :country
+    degenerate_level :state
+    degenerate_level :city
+    query_level :last_name, -> { Customer.all }, fact_key: 'customers.id'
+  end
+end
+
+class MyCube < SharedDimensions
+  has_dimension_level :genres, :name
+  has_dimension_level :media_types, :name
+  has_dimension_level :customers, :last_name
+
+  has_sum_metric :units_sold, 'SUM(invoice_lines.quantity)'
+  has_sum_metric :amount, 'SUM(invoice_lines.unit_price * invoice_lines.quantity)'
+
+  has_custom_metric :commission, ->(fact) { (fact['amount'] * 0.3) }
+
+  has_custom_rollup :avg_transaction, ->(fact_set) { fact_set['amount'] / fact_set['units_sold'] }
+  has_custom_rollup :usa_amount, ->(fact_set) { fact_set.locate('customers.country', with: 'USA')['amount'] }
+  has_custom_rollup :cross_country_avg_transaction, ->(fact_set) { fact_set.locate(reset: 'customers.*')['avg_transaction'] }
+  has_custom_rollup :usa_avg_transaction, ->(fact_set) { fact_set.locate('customers.country', with: 'USA')['avg_transaction'] }
+
+  main_query do
+    InvoiceLine.joins(track: [:genre, :media_type], invoice: :customer)
+  end
+end
+```
+
+## Query interface
+
+Use `#granulate` to perform group by:
+```ruby
+q = MyCube.granulate('genres.name', 'customers.city').pivot.on_columns(:metrics).on_rows('genres.name', 'customers.city')
+q.to_csv
+q.to_chart      # => Kick chart format
+```
+
+Use `#select` to choose metrics and `#slice` to perform where:
+```ruby
+MyCube.select('units_sold', 'amount').
+       granulate('genres.name', 'customers.city').
+       slice('customers.country', with: 'USA').
+       pivot.on_columns(:metrics).on_rows('genres.name', 'customers.city').to_csv
+```
+
+The same thing can be done in stages:
+```ruby
+query = MyCube.select('units_sold', 'amount').
+                  granulate('genres.name', 'customers.city').
+                  slice('customers.country', with: 'USA').build
+
+query.pivot.on_columns(:metrics).on_rows('genres.name', 'customers.city').to_csv
+```
+
+Which allows further slicing in memory - in the same standard way - rather than in SQL:
+```ruby
+query = MyCube.select('units_sold', 'amount').granulate('genres.name', 'customers.city').build
+usa_slice = query.slice('customers.country', with: 'USA')
+france_slice = query.slice('customers.country', with: 'France')
+
+# One DB query, two reports
+usa_slice.pivot.on_columns('genres.name').on_rows('customers.city').in_cells('units_sold').to_csv
+france_slice.pivot.on_columns('genres.name').on_rows(:metrics).to_csv
+```
+
+## Virtual cubes DSL
+
+Virtual cubes allow referring to two or more cubes, each with different granularity, on the same report.
+```ruby
+class MyOtherCube < SharedDimensions
+  define_dimension :playlists do
+    query_level :name, -> { Playlist.all }, label_key: 'name'
+  end
+
+  has_dimension_level :genres, :name
+  has_dimension_level :media_types, :name
+  has_dimension_level :playlists, :name, fact_key: 'playlists.id'
+
+  has_sum_metric :tracks_count, 'COUNT(playlists.id)'
+
+  main_query do
+    Playlist.joins(tracks: [:genre, :media_type])
+  end
+end
+
+class MyVirtualCube < Martyr::VirtualCube
+  use_cube 'MyCube'
+  use_cube 'MyOtherCube'
+end
+```
+
+## Using virtual cubes
+
+Usage is the same as regular cubes.
+```ruby
+query = MyVirtualCube.granulate('genres.name').on_columns('genres.name').on_rows('my_other_cube.tracks_count', 'my_cube.units_sold')
+```
+
+
+
+
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'martyr'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install martyr
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/martyr/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+
+Limitations:
+- If you want to connect degenerate levels directly to the fact, make sure that they are unique across the entire
+  dimension.
+
+  For example, consider a simple dimension 'customers.country', 'customers.city', 'customers.name', and that
+  'customers.name' is a query level, and the other levels are degenerates.
+
+  Problem:
+    If the cube connects with 'customers.city', the grain is 'customers.city', and the slice is 'customers.city' => 'Dover',
+    When you run `facts.first['customers.country']` you may receive either US or UK (if Dover appears once for each in
+    the dimension).
+
+    The reason is that Martyr needs a query level in order to resolve higher degenerate levels that do not connect to
+    the fact. To do that, it maintains one "representative" 'customers.name' record for each degenerate 'customers.city'
+    value. It then asks this representative to fetch its 'customers.country', which could be either US or UK, depending
+    on the randomly chosen representative.
+
+  Workaround 1:
+    Connect 'customers.country' to the fact.
+    Martyr always prefer to take degenerates from the facts if they are available.
+
+  Workaround 2:
+    Connect 'customers.name' to the cube and add it to the grain.
+    Martyr will prefer to use the query level 'customers.name' when resolving for 'customers.country'.
+
+  Reproduce:
+    c = Customer.create first_name: 'Amit', last_name: 'Aharoni', city: 'Paris', country: 'Hungary', email: 'amit.sites@gmail.com'
+    i = Invoice.create customer_id: c.id, invoice_date: Time.now, billing_country: 'Hungary', billing_city: 'Paris', total: 100
+    InvoiceLine.create invoice_id: i.id, track_id: 1, unit_price: 1, quantity: 100
+
+    sub_cube1 = MartyrSpec::DegeneratesAndNoQueryLevel.granulate('customers.city', 'genres.name').slice('customers.city', with: 'Paris').build.sub_cubes.first
+    sub_cube2 =    MartyrSpec::DegeneratesAndAllLevels.granulate('customers.city', 'genres.name').slice('customers.city', with: 'Paris').build.sub_cubes.first
+    sub_cube3 = MartyrSpec::NoHighLevels.granulate('customers.last_name', 'genres.name').slice('customers.city', with: 'Paris').build.sub_cubes.first
+
+    sub_cube1.elements(levels: ['customers.city', 'customers.country']).count
+    # => 1
+    sub_cube2.elements(levels: ['customers.city', 'customers.country']).count
+    # => 2
+    sub_cube3.elements(levels: ['customers.city', 'customers.country']).count
+    # => 2

data/Rakefile

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

data/TODO.txt

@@ -0,0 +1,54 @@
+
+Add ability to add includes directive to an existing dimension scope.
+
+Add ability to sort results
+
+============================
+
+- QueryContext currently only supports one #slice operation. It should really return a decorator of itself that allies
+  the memory slice on it.
+
+- The #for_cube_name method on both memory slices and data slices is dangerous - once the block returns the object's
+  scoping is useless. Create either one decorator for both, or a different decorator for each one that acts as a filter.
+
+- Coordinate currently communicate with the memory slice in order to reset and set its values. This is useless, memory
+  slice should be immutable to the cells, otherwise custom rollups that reset dimension level on a memory slice 2:
+  <data slice 1> + <memory slice 2> will return a different value than the same custom rollup on data slice 3:
+  <data slice 3> = <data slice 1> + <memory slice 2> though they should be the same.
+
+  E.g., the rollup:
+  has_custom_rollup :usa_amount, ->(fact_set) { fact_set.locate('customers.country', with: 'USA')['amount'] }
+
+  Will have different result for these two:
+  Cube.slice('customers.country', with: 'France').build   # => rollup will not be able to locate USA element
+  Cube.build.slice('customers.country', with: 'France')   # => rollup will be able to locate USA element
+
+- Virtual cube builder needs fixing. The #build method with all combinations is not working right. It should be
+  transitioned to something more performing that does not rely on all possible combinations.
+
+- Coordinate, ElementLocator and FactIndexer all do things very similar. Why do we need ElementLocator when we have
+  FactIndexer? Does Coordinates really need to know about MemorySlice? Can ElementLocator have an #all method?
+
+
+  If memory slice is immutable, while FactIndexer holds all facts and is able to address multiple memory slices,
+  it makes sense to have an element locator that is cube-specific and memory-slice-specific, so the user does not need
+  to provide the memory slice every time a cell is needed.
+  In this case, the locator is injected to the element to perform location search operations.
+
+  Coordinates does not need to contain a memory slice. Any attempt to go outside the slice will yield an empty cell.
+  So it's simply a hash. We can further remove the knowledge of coordinates about what is a level and what is a
+  metric by having this be resolved by the ElementLocator (it has to know fact indexer anyways).
+
+  VirtualElement #locate will continue to be as today - delegating to the individual locators.
+
+  VirtualElementBuilder can be simplified - it can simply be provided with the locators, which now will know how to
+  fetch all elements if necessary. --> Although: locator should not hold the level ids.. elements grain is really
+  based on the pivot grain which can be different than the sub cube grain, and can change dynamically based on whether
+  totals are calculated. So perhaps it's better to have the locator be unrelated to the #elements operation.
+  Actually, it can be injected into elements instead of memory slice!
+
+  Standardization of metric names can be moved to the locator too, so "dirty" user input is handled in one place.
+
+- Due to the way the grain is initialized in cubes, I'm not sure if currently a virtual cube containing 2 cubes one
+  of which contains one more detailed level of granularity is going to work (select_supported_level_ids selects
+  all levels in supported dimensions, regardless of whether the level itself can actually be fetched)

data/bin/console

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "martyr"
+require "chinook_database"
+ChinookDatabase.connect
+require_relative "../spec/models/spec_models"
+
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+module Martyr
+  def self.reload!
+    Reloader.new(self).reload
+  end
+
+  class Reloader
+    def initialize(top)
+      @top = top
+    end
+
+    def reload
+      cleanup
+      load_all
+    end
+
+    private
+
+    def all_project_objects_lookup
+      @_all_project_objects_lookup ||= Hash[all_project_objects.map{|x| [x, true]}]
+    end
+
+    def all_project_objects(current = @top)
+      return [] unless current.is_a?(Module) and current.to_s.split('::').first == @top.to_s
+      [current] + current.constants.flat_map{|x| all_project_objects(current.const_get(x))}
+    end
+
+    def cleanup(parent = Object, current = @top)
+      return unless all_project_objects_lookup[current]
+      current.constants.each {|const| cleanup current, current.const_get(const)}
+      parent.send(:remove_const, current.to_s.split('::').last.to_sym)
+    end
+
+    def loaded_files
+      $LOADED_FEATURES.select{|x| x.starts_with?(File.expand_path('../../lib/martyr'))}
+    end
+
+    def load_all
+      loaded_files.each{|x| load x}
+      true
+    end
+  end
+end
+
+def reload!
+  Martyr.reload!
+end
+
+require "pry"
+Pry.start
+
+# require "irb"
+# IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/martyr/base_cube.rb

@@ -0,0 +1,73 @@
+module Martyr
+  class BaseCube
+    extend Martyr::Translations
+
+    def self.set_cube_name(value)
+      @name = value.to_s
+    end
+
+    def self.cube_name
+      @name || name.split('::').last.underscore
+    end
+
+    def self.contained_cube_classes
+      raise NotImplementedError
+    end
+
+    def self.new_query_context_builder
+      Runtime::QueryContextBuilder.new(self, @named_scopes.try(:query_helper_module))
+    end
+
+    # @return [NamedScopedCollection] and extends for the first time the helper module used to delegate scope names to
+    #   a new query context builder
+    def self.named_scopes
+      return @named_scopes if @named_scopes
+      @named_scopes = Schema::NamedScopeCollection.new
+      extend(@named_scopes.cube_helper_module)
+      @named_scopes
+    end
+
+    class << self
+      delegate :scope, to: :named_scopes
+    end
+
+    def self.dimension_definitions
+      {}
+    end
+
+    def self.supported_dimension_definitions
+      raise NotImplementedError
+    end
+
+    # @param dimension_names
+    # @return [Runtime::DimensionScopeCollection] a collection with dimensions that maintain SQL scoped queries and
+    #   their results. All dimensions that have at least one level supported by the cube are included.
+    def self.build_dimension_scopes(dimension_names)
+      dimension_scopes = Runtime::DimensionScopeCollection.new(dimension_definitions)
+      supported_dimension_definitions.slice(*dimension_names).values.flat_map(&:level_objects).each do |level|
+        dimension_scopes.register_level(level)
+      end
+      dimension_scopes
+    end
+
+    def self.find_metric(metric_name)
+      raise NotImplementedError
+    end
+
+    # @param metric_id [String] fully qualified metric ID
+    # @return [MetricDefinition]
+    def self.find_metric_id(metric_id)
+      cube_name, metric_name = id_components(metric_id)
+      raise(Schema::Error.new "Metric for cube `#{cube_name}` was asked for cube `#{self.cube_name}`") unless
+        cube_name == self.cube_name
+
+      find_metric(metric_name)
+    end
+
+    # @param metric_id [String] fully qualified metric ID
+    # @return [Boolean]
+    def self.metric?(metric_id)
+      find_metric_id(metric_id).present? rescue false
+    end
+  end
+end

data/lib/martyr/cube.rb

@@ -0,0 +1,134 @@
+module Martyr
+  class Cube < BaseCube
+    extend Martyr::LevelComparator
+
+    def self.contained_cube_classes
+      [self]
+    end
+
+    def self.fact_definitions
+      @fact_definitions ||= Schema::FactDefinitionCollection.new(self)
+    end
+
+    # Return all dimension definitions regardless of whether they are supported by the cube.
+    # A cube +supports+ a dimension only if it calls the #has_dimension_level DSL method.
+    # It is quite typical to have multiple cubes inherenting from a context with shared dimensions.
+    # So it is typical to have cubes that maintain a reference to a dimension definition they do not support.
+    #
+    # @see #supported_dimension_definitions to get only the supported dimensions.
+    #
+    # In the example below, Cube1 does not support shared_dimension_2:
+    #
+    #   class Common < Martyr::Cube
+    #     define_dimension :shared_dimension_1 do
+    #       ...
+    #     end
+    #
+    #     define_dimension :shared_dimension_2 do
+    #       ...
+    #     end
+    #   end
+    #
+    #   class Cube1 < Common
+    #     has_dimension_level :shared_dimension_1, :level1
+    #   end
+    #
+    #   Cube1.dimension_definitions.keys
+    #   # => ['shared_dimension_1', 'shared_dimension_2']
+    #
+    # @return [Schema::DimensionDefinitionCollection]
+    def self.dimension_definitions
+      return @dimension_definitions if @dimension_definitions
+      @dimension_definitions = Schema::DimensionDefinitionCollection.new
+      @dimension_definitions.merge! parent_schema_class.dimension_definitions if parent_schema_class.present?
+      @dimension_definitions
+    end
+
+    def self.set_default_fact_grain(*level_ids_arr)
+      @default_fact_grain = level_ids_arr
+    end
+
+    def self.default_fact_grain
+      @default_fact_grain || []
+    end
+
+    # @return [Array<LevelAssociation>]
+    def self.default_fact_grain_level_associations
+      level_association_lookup = level_associations.index_by(&:id)
+      default_fact_grain.map do |x|
+        level_association_lookup[x] || raise(Schema::Error.new("`#{x}` is in the default fact grain but not connected to the fact query"))
+      end
+    end
+
+    class << self
+      delegate :define_dimension, to: :dimension_definitions
+      delegate :main_fact, :build_fact_scopes, :sub_query, to: :fact_definitions
+      delegate :has_dimension_level, :has_count_distinct_metric, :has_min_metric, :has_max_metric, # DSL
+               :has_sum_metric, :has_custom_metric, :has_custom_rollup, :main_query, # DSL
+               :metrics, :find_metric, :dimension_associations, to: :main_fact # Runtime
+
+      delegate :select, :slice, :granulate, :pivot, :build, to: :new_query_context_builder
+      alias_method :all, :new_query_context_builder
+    end
+
+    def self.martyr_schema_class?
+      true
+    end
+
+    def self.virtual?
+      false
+    end
+
+    # @return [nil, Base]
+    def self.parent_schema_class
+      ancestors[1..-1].find { |x| x != self and x.respond_to?(:martyr_schema_class?) }
+    end
+
+    # @see comment for #dimension_definitions
+    #
+    # @return [Schema::DimensionDefinitionCollection] including dimensions that have at least one level
+    #   supported by the cube through #has_dimension_level
+    def self.supported_dimension_definitions
+      dimension_definitions.slice(*dimension_associations.keys)
+    end
+
+    # Return all levels that are directly connected to the cube with #has_dimension_level.
+    #
+    # @return [Array<LevelAssociation>]
+    def self.level_associations
+      dimension_associations.flat_map { |_name, dimension_association| dimension_association.level_objects }
+    end
+
+    # @return [Array<BaseLevelDefinition>]
+    def self.supported_level_definitions
+      lowest_level_of(level_associations).flat_map do |level_association|
+        level_association.level_definition.level_and_above
+      end
+    end
+
+    # @return [Array<String>]
+    def self.supported_level_ids
+      supported_level_definitions.map(&:id)
+    end
+
+    # Helper methods used to filter out unsupported levels.
+    #
+    # @param level_ids [Array<String>]
+    # @return [Array<String>] all ids that are supported by the cube through the dimension
+    def self.select_supported_level_ids(level_ids)
+      level_ids = Array.wrap(level_ids)
+      unsupported = level_ids - supported_level_ids
+      level_ids - unsupported
+    end
+
+    # @return [Schema::DependencyInferrer]
+    def self.metric_dependency_inferrer
+      @metric_dependency_inferrer ||= Schema::DependencyInferrer.new.add_cube_levels(self)
+    end
+
+    def self.standardizer
+      @standardizer ||= Martyr::MetricIdStandardizer.new(cube_name, raise_if_not_ok: false)
+    end
+
+  end
+end

data/lib/martyr/dimension_reference.rb

@@ -0,0 +1,26 @@
+module Martyr
+  class DimensionReference
+    attr_reader :dimension_definition
+    delegate :name, to: :dimension_definition
+
+    include Martyr::HasLevelCollection
+
+    delegate :lowest_level, :level_above, :find_level, :level_names, :level_objects, :has_level?,
+      :has_dimension_level, :register_level, to: :levels
+
+    # For reflection
+    def dimension?
+      true
+    end
+
+    def initialize(dimension_definition, levels_collection_class, &block)
+      @dimension_definition = dimension_definition
+      @levels = levels_collection_class.new(dimension: self, &block)
+    end
+
+    # @param mod [Module]
+    def register_element_helper_methods(mod)
+      level_objects.each {|l| l.register_element_helper_methods(mod)}
+    end
+  end
+end

data/lib/martyr/errors.rb

@@ -0,0 +1,20 @@
+module Martyr
+  class Error < StandardError
+  end
+
+  module Internal
+    class Error < ::Martyr::Error
+    end
+  end
+
+  module Schema
+    class Error < ::Martyr::Error
+    end
+  end
+
+  module Query
+    class Error < ::Martyr::Error
+    end
+  end
+
+end