tr8n_core 4.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a162e743cb6de4c17ba8f8f37d3213bdd9a99ba4
+  data.tar.gz: 8e94f38ea626036fd739a19d2c83c35fea72fc25
+SHA512:
+  metadata.gz: 310264af7f85f21dae165ddb1b269218fc3941716292173251b198163fae28c9f561133f1d5efdcd86f27ce6e7b640605e600036e2150e3b8b8141113093b7d4
+  data.tar.gz: 3ec53152d4ce2a91302ba8737bee70773faad63342e0fc1c1d5a1166b8175680ac0d011cae0e91aeee967a451c2d1b75e2a1ae21edc90d85e41d867c9563321b

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+
+MIT License
+
+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,69 @@
+<p align="center">
+  <img src="https://raw.github.com/tr8n/tr8n/master/doc/screenshots/tr8nlogo.png">
+</p>
+
+Tr8n Core Library For Ruby
+==================
+
+This library provides a set of Tr8n client side tools that can be used in any ruby based project.
+
+[![Build Status](https://travis-ci.org/tr8n/tr8n_ruby_core.png?branch=master)](https://travis-ci.org/tr8n/tr8n_ruby_core)
+[![Coverage Status](https://coveralls.io/repos/tr8n/tr8n_ruby_core/badge.png)](https://coveralls.io/r/tr8n/tr8n_ruby_core)
+[![Gem Version](https://badge.fury.io/rb/tr8n_core.png)](http://badge.fury.io/rb/tr8n_core)
+[![Dependency Status](https://www.versioneye.com/user/projects/52e36cc8ec1375c6f4000078/badge.png)](https://www.versioneye.com/user/projects/52e36cc8ec1375c6f4000078)
+[![Project status](http://stillmaintained.com/tr8n/tr8n_ruby_core.png)](http://stillmaintained.com/tr8n/tr8n_ruby_core.png)
+
+Installation
+==================
+
+To install the gem, use:
+
+    gem install tr8n_core
+
+
+Usage
+==================
+
+The library can be invoked from the IRB. To use tr8n client you must first require it, and instantiat the application with the key and secret you aquired during registration:
+
+    irb(main):001:0> require 'tr8n_core'
+    irb(main):002:0> app = Tr8n::Application.init(TR8N_SERVICE_HOST, APPLICATION_KEY, SECRET)
+    irb(main):003:0> russian = app.language('ru')
+
+
+Simplest example:
+
+    irb(main):004:0> russian.translate('Hello World')
+    => "Привет Мир"
+
+Using context:
+
+    irb(main):004:0> russian.translate('Invite', 'An invitation')
+    => "Приглашение"
+    irb(main):005:0> russian.translate('Invite', 'An action to invite')
+    => "Пригласить"
+
+Basic numeric rules with transform tokens:
+
+    irb(main):006:0> russian.translate('You have {count||message}.', :count => 1)
+    => "У вас есть 1 сообщение."
+    irb(main):007:0> russian.translate('You have {count||message}.', :count => 2)
+    => "У вас есть 2 сообщения."
+    irb(main):008:0> russian.translate('You have {count||message}.', :count => 5)
+    => "У вас есть 5 сообщений."
+
+Basic gender rules with language cases:
+
+    irb(main):009:0> actor = {:gender => :female, :name => "Анна"}
+    irb(main):010:0> target = {:gender => :male, :name => "Михаил"}
+    irb(main):011:0> russian.translate('{actor} sent {target} a gift.', :actor => {:object => actor, :attribute => :name}, :target => {:object => target, :attribute => :name})
+    => "Анна послала подарок Михаилу."
+    irb(main):011:0> russian.translate('{actor} sent {target} a gift.', :actor => {:object => target, :attribute => :name}, :target => {:object => actor, :attribute => :name})
+    => "Михаил послал подарок Анне."
+
+Tr8n
+==================
+
+To read more about TML (Translation Markup Language) syntax, please visit http://wiki.tr8nhub.com
+
+If you are planning to use Tr8n in Rails application, you can use the tr8n_rails_client_sdk gem instead.

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+Dir["#{File.dirname(__FILE__)}/tasks/**/*.rake"].sort.each { |ext| load ext }
+
+task :default => :spec

data/config/config.yml

@@ -0,0 +1,34 @@
+defaults:
+  enabled:        true
+  default_locale: en-US
+  default_level:  0
+  application:
+    host:         http://localhost:3000
+    key:          default
+    secret:       12345
+  logger:
+    enabled:      true
+    path:         /log/tr8n.log
+  cache:
+    enabled:      false
+    adapter:      file
+    path:         /cache
+    version:      1
+    timeout:      3600
+    host:         localhost:11211
+  localization:
+    default_day_names:        [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
+    default_abbr_day_names:   [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
+    default_month_names:      [January, February, March, April, May, June, July, August, September, October, November, December]
+    default_abbr_month_names: [Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
+    custom_date_formats:
+      default:                '%m/%d/%Y'            # 07/4/2008
+      short_numeric:          '%m/%d'               # 07/4
+      short_numeric_year:     '%m/%d/%y'            # 07/4/08
+      long_numeric:           '%m/%d/%Y'            # 07/4/2008
+      verbose:                '%A, %B %d, %Y'       # Friday, July  4, 2008
+      monthname:              '%B %d'               # July 4
+      monthname_year:         '%B %d, %Y'           # July 4, 2008
+      monthname_abbr:         '%b %d'               # Jul 4
+      monthname_abbr_year:    '%b %d, %Y'           # Jul 4, 2008
+      date_time:              '%m/%d/%Y at %H:%M'   # 01/03/1010 at 5:30

data/config/tokens/data.yml

@@ -0,0 +1,45 @@
+#############################################################################
+#
+# Tr8n Default Data Tokens
+#
+#############################################################################
+
+html:
+  ndash:    "–"       # –
+  mdash:    "—"       # —
+  iexcl:    "¡"       # ¡
+  iquest:   "¿"      # ¿
+  quot:     """        # "
+  ldquo:    "“"       # “
+  rdquo:    "”"       # ”
+  lsquo:    "‘"       # ‘
+  rsquo:    "’"       # ’
+  laquo:    "«"       # «
+  raquo:    "»"       # »
+  nbsp:     " "        # space
+  lsaquo:   "‹"      # ‹
+  rsaquo:   "›"      # ›
+  br:       "<br/>"         # line break
+  lbrace:   "{"
+  rbrace:   "}"
+  trade:    "&trade;"       # TM
+
+plain:
+  ndash:        "–"         # –
+  mdash:        "—"         # —
+  iexcl:        "¡"         # ¡
+  iquest:       "¿"         # ¿
+  quot:         '"'         # "
+  ldquo:        "“"         # “
+  rdquo:        "”"         # ”
+  lsquo:        "‘"         # ‘
+  rsquo:        "’"         # ’
+  laquo:        "«"         # «
+  raquo:        "»"         # »
+  nbsp:         " "         # space
+  lsaquo:       "‹"         # ‹
+  rsaquo:       "›"         # ›
+  br:           "\n"        # line break
+  lbrace:       "{"
+  rbrace:       "}"
+  trade:        "™"         # TM

data/config/tokens/decorations.yml

@@ -0,0 +1,37 @@
+#############################################################################
+#
+# Tr8n Default Decoration Tokens
+#
+#############################################################################
+
+html:
+  strong:     "<strong>{$0}</strong>"
+  bold:       "<strong>{$0}</strong>"
+  b:          "<strong>{$0}</strong>"
+  em:         "<em>{$0}</em>"
+  italic:     "<i>{$0}</i>"
+  i:          "<i>{$0}</i>"
+  link:       "<a href='{$href}'>{$0}</a>"
+  br:         "<br>{$0}"
+  strike:     "<strike>{$0}</strike>"
+  div:        "<div id='{$id}' class='{$class}' style='{$style}'>{$0}</div>"
+  span:       "<span id='{$id}' class='{$class}' style='{$style}'>{$0}</span>"
+  h1:         "<h1>{$0}</h1>"
+  h2:         "<h2>{$0}</h2>"
+  h3:         "<h3>{$0}</h3>"
+
+plain:
+  strong:     "{$0}"
+  bold:       "{$0}"
+  b:          "{$0}"
+  em:         "{$0}"
+  italic:     "{$0}"
+  i:          "{$0}"
+  link:       "{$0}:{$1}"
+  br:         "\n{$0}"
+  strike:     "{$0}"
+  div:        "{$0}"
+  span:       "{$0}"
+  h1:         "{$0}"
+  h2:         "{$0}"
+  h3:         "{$0}"

data/lib/tr8n/application.rb

@@ -0,0 +1,320 @@
+#--
+# Copyright (c) 2013 Michael Berkovich, tr8nhub.com
+#
+# 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.
+#++
+
+require 'faraday'
+
+API_PATH = '/tr8n/api/'
+
+class Tr8n::Application < Tr8n::Base
+  attributes :host, :key, :secret, :access_token, :name, :description, :threshold, :default_locale, :default_level
+  has_many :features, :languages, :sources, :components, :tokens
+
+  def self.init(host, key, secret, options = {})
+    options[:definition] = true if options[:definition].nil?
+
+    Tr8n.cache.reset_version
+
+    Tr8n.logger.info("Initializing application...")
+
+    Tr8n.config.application = Tr8n.cache.fetch(cache_key(key)) do
+      # get access token and store it in the application
+      access_token = api("oauth/request_token", {:client_id => key, :client_secret => secret, :grant_type => :client_credentials}, {:host => host})
+
+      # get application details
+      api("application", {:client_id => key, :definition => options[:definition]}, {:host => host, :access_token => access_token["access_token"], :class => Tr8n::Application, :attributes => {
+          :host => host,
+          :key => key,
+          :secret => secret,
+          :access_token => access_token["access_token"]
+      }})
+    end
+  end
+
+  def initialize(attrs = {})
+    super
+
+    self.attributes[:languages] = []
+    if hash_value(attrs, :languages)
+      self.attributes[:languages] = hash_value(attrs, :languages).collect{ |l| Tr8n::Language.new(l.merge(:application => self)) }
+    end
+
+    self.attributes[:sources] = []
+    if hash_value(attrs, :sources)
+      self.attributes[:sources] = hash_value(attrs, :sources).collect{ |l| Tr8n::Source.new(l.merge(:application => self)) }
+    end
+
+    self.attributes[:components] = []
+    if hash_value(attrs, :components)
+      self.attributes[:components] = hash_value(attrs, :components).collect{ |l| Tr8n::Component.new(l.merge(:application => self)) }
+    end
+
+    @translation_keys         = {}
+
+    @languages_by_locale      = nil
+    @sources_by_key           = nil
+    @components_by_key        = nil
+    @missing_keys_by_sources  = nil
+  end
+
+  def language(locale = nil, fetch = true)
+    locale ||= default_locale || Tr8n.config.default_locale
+
+    @languages_by_locale ||= {}
+    return @languages_by_locale[locale] if @languages_by_locale[locale]
+
+    if Tr8n.config.cache_enabled?
+      language = Tr8n.cache.fetch(Tr8n::Language.cache_key(locale))
+      if language
+        language.application = self
+        @languages_by_locale[locale] = language
+        return language
+      end
+    end
+
+    return nil unless fetch
+
+    # for translator languages will continue to build application cache
+    @languages_by_locale[locale] = get("language", {:locale => locale}, {:class => Tr8n::Language, :attributes => {:application => self}})
+
+    if Tr8n.config.cache_enabled? and not Tr8n.cache.read_only?
+      Tr8n.cache.store(Tr8n::Language.cache_key(locale), @languages_by_locale[locale])
+    end
+
+    @languages_by_locale[locale]
+  end
+
+  def locales
+    @locales ||= languages.collect{|lang| lang.locale}
+  end
+
+  # Mostly used for testing
+  def add_language(new_language)
+    lang = language(new_language.locale, false)
+    return lang if lang
+
+    new_language.application = self
+    self.languages << new_language
+    @languages_by_locale[new_language.locale] = new_language
+    new_language
+  end
+
+  def source(key, register = true)
+    key = key.source if key.is_a?(Tr8n::Source)
+
+    @sources_by_key ||= begin
+      srcs = {}
+      (sources || []).each do |src|
+        srcs[src.source] = src
+      end
+      srcs
+    end
+
+    return @sources_by_key[key] if @sources_by_key[key]
+    return nil unless register
+
+    @sources_by_key[key] ||= post("source/register", {:source => key}, {:class => Tr8n::Source, :attributes => {:application => self}})
+  end
+
+  def component(key, register = true)
+    key = key.key if key.is_a?(Tr8n::Component)
+
+    @components_by_key ||= begin
+      cmps = {}
+      (components || []).each do |cmp|
+        cmps[cmp.key] = cmp
+      end
+      cmps
+    end
+
+    return @components_by_key[key] if @components_by_key[key]
+    return nil unless register
+
+    @components_by_key[key] ||= post("component/register", {:component => key}, {:class => Tr8n::Component, :attributes => {:application => self}})
+  end
+
+  def translation_keys
+    @translation_keys ||= {}
+  end
+
+  def translation_key(key)
+    translation_keys[key]
+  end
+
+  def cache_translation_key(tkey)
+    cached_key = translation_key(tkey.key)
+
+    if cached_key
+      # move translations from tkey to the cached key
+      tkey.translations.each do |locale, translations|
+        cached_key.set_language_translations(language(locale), translations)
+      end
+      return cached_key
+    end
+
+    tkey.set_application(self)
+    @translation_keys[tkey.key] = tkey
+  end
+
+  def cache_translation_keys(tkeys)
+    tkeys.each do |tkey|
+      cache_translation_key(tkey)
+    end
+  end
+
+  def register_missing_key(tkey, source)
+    @missing_keys_by_sources ||= {}
+    @missing_keys_by_sources[source.source] ||= {}
+    @missing_keys_by_sources[source.source][tkey.key] ||= tkey
+  end
+
+  def submit_missing_keys
+    return if @missing_keys_by_sources.nil? or @missing_keys_by_sources.empty?
+    params = []
+    @missing_keys_by_sources.each do |source, keys|
+      next unless keys.values.any?
+      params << {:source => source, :keys => keys.values.collect{|tkey| tkey.to_hash(:label, :description, :locale, :level)}}
+    end
+    post('source/register_keys', {:source_keys => params.to_json}, :method => :post)
+    @missing_keys_by_sources = nil
+  end
+
+  def featured_languages
+    @featured_languages ||= begin
+      locales = Tr8n.cache.fetch("featured_locales") do
+        get("application/featured_locales")
+      end
+      # use app languages, there is no need for rules for this call
+      (locales.nil? or locales.empty?) ? [] : languages.select{|l| locales.include?(l.locale)}
+    end
+  end
+ 
+  def translators
+    get("application/translators", {}, {:class => Tr8n::Translator, :attributes => {:application => self}})
+  end
+
+  def default_decoration_token(token)
+    hash_value(tokens, "decoration.#{token.to_s}")
+  end
+
+  def default_data_token(token)
+    hash_value(tokens, "data.#{token.to_s}")
+  end
+
+  def js_boot_url
+    "#{host}/tr8n/api/proxy/boot.js?client_id=#{key}"
+  end
+
+  def feature_enabled?(key)
+    hash_value(features, key.to_s)
+  end
+
+  #######################################################################################################
+  ##  Cache Methods
+  #######################################################################################################
+
+  def self.cache_prefix
+    'a@'
+  end
+
+  def self.cache_key(key)
+    "#{cache_prefix}_[#{key}]"
+  end
+
+  def to_cache_hash
+    hash = to_hash(:host, :key, :secret, :access_token, :name, :description, :threshold, :default_locale, :default_level, :features)
+    hash["languages"] = []
+    languages.each do |lang|
+      hash["languages"] << lang.to_hash(:locale, :name, :english_name, :native_name, :right_to_left, :flag_url)
+    end
+    hash
+  end
+
+  #######################################################################################################
+  ##  API Methods
+  #######################################################################################################
+  ## TODO: maybe caching can be done generically on the API level during gets?
+  ## TODO: think about it...
+
+  def get(path, params = {}, opts = {})
+    api(path, params, opts)
+  end
+
+  def post(path, params = {}, opts = {})
+    api(path, params, opts.merge(:method => :post))
+  end
+
+  def self.error?(data)
+    not data["error"].nil?
+  end
+
+  def api(path, params = {}, opts = {})
+    #:access_token => access_token,
+    params = params.merge(:client_id => key,  :t => Time.now.to_i)
+    self.class.api(path, params, opts.merge(:host => self.host))
+  end
+
+  def self.api(path, params = {}, opts = {})
+    Tr8n.logger.trace_api_call(path, params) do
+      conn = Faraday.new(:url => opts[:host]) do |faraday|
+        faraday.request(:url_encoded)               # form-encode POST params
+        # faraday.response :logger                  # log requests to STDOUT
+        faraday.adapter(Faraday.default_adapter)    # make requests with Net::HTTP
+      end
+      
+      if opts[:method] == :post
+        response = conn.post("#{API_PATH}#{path}", params)
+      else
+        response = conn.get("#{API_PATH}#{path}", params)
+      end
+
+      data = JSON.parse(response.body)
+
+      unless data["error"].nil?
+        raise Tr8n::Exception.new("Error: #{data["error"]}")
+      end
+
+      process_response(data, opts)
+    end
+  end
+
+  def self.object_class(opts)
+    return unless opts[:class]
+    opts[:class].is_a?(String) ? opts[:class].constantize : opts[:class]
+  end
+
+  def self.process_response(data, opts)
+    if data["results"]
+      Tr8n.logger.debug("recieved #{data["results"].size} result(s)")
+      return data["results"] unless object_class(opts)
+      objects = []
+      data["results"].each do |data|
+        objects << object_class(opts).new(data.merge(opts[:attributes] || {}))
+      end
+      return objects
+    end
+
+    return data unless object_class(opts)
+    Tr8n.logger.debug("constructing #{object_class(opts).name}")
+    object_class(opts).new(data.merge(opts[:attributes] || {}))
+  end
+end

data/lib/tr8n/base.rb

@@ -0,0 +1,123 @@
+#--
+# Copyright (c) 2013 Michael Berkovich, tr8nhub.com
+#
+# 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.
+#++
+
+class Tr8n::Base
+  attr_reader :attributes
+
+  def initialize(attrs = {})
+    @attributes = {}
+    attrs.each do |key, value|
+      # pp [self.class.name, key, self.class.attributes, self.class.attributes.include?(key.to_sym)]
+      next unless self.class.attributes.include?(key.to_sym)
+      @attributes[key.to_sym] = value
+    end
+  end
+
+  def self.attributes(*attrs)
+    @attribute_names ||= []
+    @attribute_names += attrs.collect{|a| a.to_sym} unless attrs.nil?
+    @attribute_names
+  end
+  def self.belongs_to(*attrs) self.attributes(*attrs); end
+  def self.has_many(*attrs) self.attributes(*attrs); end
+
+  def self.thread_safe_attributes(*attrs)
+    @thread_safe_attribute_names ||= []
+    @thread_safe_attribute_names += attrs.collect{|a| a.to_sym} unless attrs.nil?
+    @thread_safe_attribute_names
+  end
+
+  def method_missing(meth, *args, &block)
+    method_name = meth.to_s
+    method_suffix = method_name[-1, 1]
+    method_key = method_name.to_sym
+    if ['=', '?'].include?(method_suffix)
+      method_key = method_name[0..-2].to_sym 
+    end
+
+    if self.class.attributes.index(method_key)
+      if method_name[-1, 1] == '='
+        attributes[method_key] = args.first
+        return attributes[method_key]
+      end
+      return attributes[method_key]
+    end
+
+    if self.class.thread_safe_attributes.index(method_key)
+      if method_name[-1, 1] == '='
+        Thread.current[method_key] = args.first
+        return Thread.current[method_key]
+      end
+      return Thread.current[method_key]
+    end
+
+    super
+  end      
+
+  def self.hash_value(hash, key, opts = {})
+    return nil unless hash.is_a?(Hash)
+    return hash[key.to_s] || hash[key.to_sym] if opts[:whole]
+
+    value = hash
+    key.to_s.split('.').each do |part|
+      return nil unless value.is_a?(Hash)
+      value = value[part.to_sym] || value[part.to_s]
+    end
+    value
+  end
+
+  def hash_value(hash, key, opts = {})
+    self.class.hash_value(hash, key, opts)
+  end
+
+  def reset!
+    self.class.thread_safe_attributes.each do |key|
+      Thread.current[key] = nil
+    end
+  end
+
+  def to_hash(*attrs)
+    if attrs.nil? or attrs.empty?
+      # default hashing only includes basic types
+      keys = []
+      self.class.attributes.each do |key|
+        value = attributes[key]
+        next if value.kind_of?(Tr8n::Base) or value.kind_of?(Hash) or value.kind_of?(Array)
+        keys << key
+      end
+    else
+      keys = attrs
+    end
+
+    hash = {}
+    keys.each do |key|
+      hash[key] = attributes[key]
+    end
+
+    proc = Proc.new { |k, v| v.kind_of?(Hash) ? (v.delete_if(&proc); nil) : v.nil? }
+    hash.delete_if(&proc)
+
+    hash    
+  end
+
+end