post_json 1.0.3

data/lib/generators/post_json/install/templates/enable_extensions.rb

@@ -0,0 +1,28 @@
+class EnableExtensions < ActiveRecord::Migration
+  def change
+    # Install Postgresql 9.2 with PLV8 (might require )
+    # 1. sudo add-apt-repository ppa:pitti/postgresql 
+    # 2. sudo apt-get update
+    # 3. sudo apt-get install postgresql-9.2 postgresql-contrib-9.2 postgresql-server-dev-9.2 libv8-dev
+    # 4. sudo su - postgres
+    # 5. Enter psql and run "CREATE USER webnuts WITH PASSWORD 'webnuts';" and "ALTER USER webnuts CREATEDB;" and "ALTER USER webnuts SUPERUSER;"
+    # 6. git clone https://code.google.com/p/plv8js/
+    # 7. cd plv8js
+    # 8. make
+    # 9. sudo make install
+
+    # bundle exec rake db:create:all
+    # bundle exec rake db:migrate
+    # bundle exec rake db:test:prepare
+
+    # See all available extensions:
+    # ActiveRecord::Base.connection.execute("select * from pg_available_extensions;").each_row do |row|
+    #   puts row.to_s
+    # end
+
+    enable_extension 'uuid-ossp'  # generate universally unique identifiers (UUIDs)
+    enable_extension 'hstore'     # data type for storing sets of (key, value) pairs
+    enable_extension 'plv8'       # PL/JavaScript (v8) trusted procedural language
+    #enable_extension 'plcoffee'   # PL/CoffeeScript (v8) trusted procedural language
+  end
+end

data/lib/generators/post_json/install/templates/initializer.rb

@@ -0,0 +1,9 @@
+# PostJson.setup "people" do |collection|
+#   collection.record_timestamps = true                           # default is 'true'
+#   collection.created_at_attribute_name = "created_at"           # default is 'created_at'
+#   collection.updated_at_attribute_name = "updated_at"           # default is 'updated_at'
+#   collection.include_version_number = true                      # default is 'true'
+#   collection.version_attribute_name = "version"                 # default is 'version'
+#   collection.use_dynamic_index = true                           # default is 'true'
+#   collection.create_dynamic_index_milliseconds_threshold = 50   # default is '50'
+# end

data/lib/post_json.rb

@@ -0,0 +1,56 @@
+require 'core_ext/hash_extend'
+require 'core_ext/abstract_adapter_extend'
+require 'core_ext/active_record_relation_extend'
+require 'post_json/concerns/argument_methods'
+require 'post_json/concerns/query_methods'
+require 'post_json/concerns/finder_methods'
+require 'post_json/concerns/settings_methods'
+require 'post_json/concerns/dynamic_index_methods'
+require 'post_json/query_translator'
+require 'post_json/base'
+require 'post_json/model_settings'
+require 'post_json/dynamic_index'
+require 'post_json/version'
+
+module PostJson
+  class << self
+    def setup(collection_name, &block)
+      collection = Collection[collection_name]
+      collection.transaction do
+        block.call(collection)
+      end
+    end
+  end
+
+  class Collection
+    module Proxy
+      class << self
+        def const_missing(class_name)
+          const_set(class_name, Class.new(PostJson::Base))
+        end
+      end
+    end
+
+    class << self
+      def [](collection_name)
+        name_digest = PostJson::ModelSettings.collection_name_digest(collection_name)
+        class_name = "Collection_#{name_digest}"
+        model_class = Proxy.const_get(class_name)
+        model_class.collection_name = collection_name
+        model_class
+      end
+
+      def names
+        ModelSettings.order('collection_name').pluck('collection_name')
+      end
+
+      def to_a
+        names.map { |collection_name| self[collection_name] }
+      end
+
+      def each(&block)
+        to_a.each(&block)
+      end
+    end
+  end
+end

data/lib/post_json/base.rb

@@ -0,0 +1,278 @@
+module PostJson
+  class Base < ActiveRecord::Base
+    self.abstract_class = true
+    self.table_name = "post_json_documents"
+    self.lock_optimistically = false
+
+    include SettingsMethods
+    include DynamicIndexMethods
+
+    def initialize(*args)
+      __local__primary_key = self.class.primary_key
+      __local__attrs = (args[0] || {}).with_indifferent_access
+      __local__attrs[__local__primary_key] = __local__attrs[__local__primary_key].to_s if __local__attrs.has_key?(__local__primary_key)
+      args[0] = {__local__primary_key => __local__attrs[__local__primary_key], '__doc__body' => __local__attrs}.with_indifferent_access
+      super
+    end
+
+    def cache_key
+      @dashed_name ||= self.class.name.underscore.dasherize
+      __local__unique_version = __doc__version || Digest::MD5.hexdigest(attributes.inspect)
+      "#{@dashed_name}-#{id}-version-#{__local__unique_version}"
+    end
+
+    def attributes
+      read_attribute('__doc__body').try(:with_indifferent_access) || HashWithIndifferentAccess.new
+    end
+
+    def to_h
+      attributes.deep_dup
+    end
+
+    def write_attribute(attribute_name, value)
+      attribute_name = attribute_name.to_s
+      if attribute_name == '__doc__body'
+        value = value.try(:with_indifferent_access)
+        self.__doc__body_will_change! unless self.__doc__body.try(:with_indifferent_access) == value
+        super('__doc__body', value)
+      elsif attribute_name.in?(attribute_names)
+        super
+      else
+        __doc__body_write_attribute(attribute_name, value)
+      end
+    end
+
+    def attribute_changed?(attribute_name)
+      attribute_name = attribute_name.to_s
+      if attribute_name.in?(attribute_names)
+        super
+      else
+        __doc__body_attribute_changed?(attribute_name)
+      end
+    end
+
+    def __doc__body_read_attribute(attribute_name)
+      __local__value = self.__doc__body[attribute_name.to_s] if self.__doc__body
+      __doc__body_convert_attribute_type(attribute_name, __local__value)
+    end
+
+    def __doc__body_write_attribute(attribute_name, value)
+      self.__doc__body = HashWithIndifferentAccess.new(self.__doc__body).merge(attribute_name.to_s => value)
+      value
+    end
+
+    def __doc__body_attribute_was(attribute_name)
+      self.__doc__body_was == nil ? nil : self.__doc__body_was.with_indifferent_access[attribute_name]
+    end
+
+    def __doc__body_attribute_changed?(attribute_name)
+      (self.__doc__body == nil ? nil : self.__doc__body.with_indifferent_access[attribute_name]) != self.__doc__body_attribute_was(attribute_name)
+    end
+
+    def __doc__body_attribute_change(attribute_name)
+      __local__change = [__doc__body_attribute_was(attribute_name), __doc__body_read_attribute(attribute_name)]
+      if __local__change[0] == __local__change[1]
+        nil
+      else
+        __local__change
+      end
+    end
+
+    def __doc__body_convert_attribute_type(attribute_name, value)
+      case value
+      when /^[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-5][0-9]:[0-5][0-9]\.[0-9]{3}Z$/
+        Time.parse(value).in_time_zone
+      when Hash
+        value.inject(HashWithIndifferentAccess.new) do |result, (key, value)|
+          result[key] = convert_document_attribute_type("#{attribute_name}.#{key}", value)
+          result
+        end
+      when Array
+        value.map.with_index do |array_value, index|
+          convert_document_attribute_type("#{attribute_name}[#{index}]", array_value)
+        end
+      else
+        value
+      end
+    end
+
+    def [](attribute_name)
+      self.__doc__body_read_attribute(attribute_name)
+    end
+
+    def []=(attribute_name, value)
+      self.__doc__body_write_attribute(attribute_name, value)
+    end
+
+    def respond_to?(method_symbol, include_all = false)
+      if super
+        true
+      else
+        method_name = method_symbol.to_s
+        attribute_name =  if method_name.end_with?("_changed?")
+                            method_name[0..-10]
+                          elsif method_name.end_with?("_was")
+                            method_name[0..-5]
+                          elsif method_name.end_with?("=")
+                            method_name[0..-2]
+                          elsif method_name.end_with?("_change")
+                            method_name[0..-8]
+                          else
+                            method_name
+                          end
+        attributes.has_key?(attribute_name)
+      end
+    end
+
+    def method_missing(method_symbol, *args, &block)
+      method_name = method_symbol.to_s
+      attribute_name =  if method_name.end_with?("_changed?")
+                          method_name[0..-10]
+                        elsif method_name.end_with?("_was")
+                          method_name[0..-5]
+                        elsif method_name.end_with?("=")
+                          method_name[0..-2]
+                        elsif method_name.end_with?("_change")
+                          method_name[0..-8]
+                        else
+                          method_name
+                        end
+
+      if attribute_name.in?(attribute_names) == false
+        self.class.define_attribute_accessor(attribute_name)
+        send(method_symbol, *args)
+      else
+        super
+      end
+    end
+
+    class << self
+      def post_json_all
+        QueryTranslator.new(original_all)
+      end
+
+      alias_method :original_all, :all
+      alias_method :all, :post_json_all
+
+      def page(*args)
+        all.page(*args)
+      end
+
+      def default_scopes
+        if @collection_name
+          model_settings = ModelSettings.table_name
+          # query = original_all.joins("INNER JOIN #{model_settings} ON #{table_name}.__doc__model_settings_id = #{model_settings}.id")
+          # query = query.where("lower(#{model_settings}.collection_name) = ?", collection_name.downcase)
+
+          query = original_all.joins("INNER JOIN #{model_settings} ON lower(#{model_settings}.collection_name) = '#{collection_name.downcase}'")
+          query = query.where("#{table_name}.__doc__model_settings_id = #{model_settings}.id")
+
+          [Proc.new { query }] + super
+        else
+          [Proc.new { none }] + super
+        end
+      end
+
+      def collection_name
+        message = "You need to assign a collection name to class \"#{name}\":
+class #{name}
+  self.collection_name = \"people\"
+end"
+        raise ArgumentError, message unless @collection_name.present?
+        @collection_name
+      end
+
+      def collection_name=(name)
+        raise ArgumentError, "Collection name must be present" unless name.present?
+        @collection_name = name.to_s.strip
+      end
+
+      def rename_collection(new_name)
+        new_name = new_name.to_s.strip
+        settings = find_settings
+        if settings
+          settings.collection_name = new_name
+          settings.save!
+        end
+        @collection_name = new_name
+      end
+
+      def define_attribute_accessor(attribute_name)
+        class_eval <<-RUBY
+          def #{attribute_name}
+            __doc__body_read_attribute('#{attribute_name}')
+          end
+
+          def #{attribute_name}=(value)
+            __doc__body_write_attribute('#{attribute_name}', value)
+          end
+
+          def #{attribute_name}_changed?
+            __doc__body_attribute_changed?('#{attribute_name}')
+          end
+
+          def #{attribute_name}_was
+            __doc__body_attribute_was('#{attribute_name}')
+          end
+
+          def #{attribute_name}_change
+            __doc__body_attribute_change('#{attribute_name}')
+          end
+        RUBY
+      end
+    end
+
+  protected
+
+    def timestamp_attributes_for_update
+      [] # ActiveRecord depend on real table columns, so we use an alternative timestamps method
+    end
+
+    def timestamp_attributes_for_create
+      [] # ActiveRecord depend on real table columns, so we use an alternative timestamps method
+    end
+
+    def create_record
+      self.id = self.__doc__body['id'].to_s.strip.downcase
+      if self.id.blank?
+        self.id = self.__doc__body['id'] = SecureRandom.uuid
+      end
+
+      self.__doc__model_settings_id = __model__settings.id
+      self.__doc__version = 1
+
+      if __model__settings.include_version_number == true &&
+         __doc__body_read_attribute(__model__settings.version_attribute_name) == nil
+        __doc__body_write_attribute(__model__settings.version_attribute_name, self.__doc__version)
+      end
+
+      if __model__settings.use_timestamps
+        __local__current_time = Time.zone.now.strftime('%Y-%m-%dT%H:%M:%S.%LZ')
+        __doc__body_write_attribute(__model__settings.created_at_attribute_name, __local__current_time)
+        __doc__body_write_attribute(__model__settings.updated_at_attribute_name, __local__current_time)
+      end
+      super
+    end
+
+    def update_record(*args)
+      if self.changed_attributes.keys.include?(self.class.primary_key)
+        raise ArgumentError, "Primary key '#{self.class.primary_key}' cannot be modified."
+      end
+
+      if self.__doc__body_changed?
+        self.__doc__version = self.__doc__version + 1
+      end
+
+      if __model__settings.include_version_number == true &&
+         __doc__body_attribute_changed?(__model__settings.version_attribute_name) == false
+        __doc__body_write_attribute(__model__settings.version_attribute_name, self.__doc__version)
+      end
+
+      if __model__settings.use_timestamps && __doc__body_attribute_changed?(__model__settings.updated_at_attribute_name)
+        __local__current_time = Time.zone.now.strftime('%Y-%m-%dT%H:%M:%S.%LZ')
+        __doc__body_write_attribute(__model__settings.updated_at_attribute_name, __local__current_time)
+      end
+      super
+    end
+  end
+end 

data/lib/post_json/concerns/argument_methods.rb

@@ -0,0 +1,33 @@
+ module PostJson
+  module ArgumentMethods
+    extend ActiveSupport::Concern
+
+    def join_arguments(*arguments)
+      arguments = arguments[0] if arguments.length == 1 && arguments[0].is_a?(Array)
+      arguments = arguments[0].split(',') if arguments.length == 1 && arguments[0].is_a?(String)
+
+      arguments = arguments.map do |arg|
+        case arg
+        when nil
+          nil
+        when String
+          arg.strip.gsub(/\s+/, ' ')
+        when Symbol
+          arg.to_s
+        else
+          arg
+        end
+      end
+
+      arguments.join(',')
+    end
+
+    def flatten_arguments(*arguments)
+      join_arguments(*arguments).split(',')
+    end
+
+    def assert_valid_indifferent_keys(options, *valid_keys)
+      options.stringify_keys.assert_valid_keys(flatten_arguments(*valid_keys))
+    end
+  end
+end

data/lib/post_json/concerns/dynamic_index_methods.rb

@@ -0,0 +1,34 @@
+module PostJson
+  module DynamicIndexMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def dynamic_indexes
+        settings = find_settings
+        if settings
+          DynamicIndex.indexed_selectors(settings.id)
+        else
+          []
+        end
+      end
+
+      def create_dynamic_index(selector)
+        create_dynamic_indexes(selector)
+      end
+
+      def create_dynamic_indexes(*selectors)
+        settings = find_settings_or_create
+        DynamicIndex.ensure_index(settings.id, *selectors).count
+      end
+
+      def destroy_dynamic_index(selector)
+        settings = find_settings_or_create
+        if settings
+          DynamicIndex.destroy_index(settings.id, selector)
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/post_json/concerns/finder_methods.rb

@@ -0,0 +1,343 @@
+require "hashie"
+
+module PostJson
+  module FinderMethods
+    extend ActiveSupport::Concern
+
+    #
+    # This module depends upon method 'execute'
+    #
+
+    include QueryMethods
+    include ArgumentMethods
+
+    def any?
+      execute { |documents| documents.any? }
+    end
+
+    def blank?
+      execute { |documents| documents.blank? }
+    end
+
+    def count(column_name = nil, options = {})
+      selector =  if column_name.present?
+                    define_selector(column_name)
+                  else
+                    column_name
+                  end
+      execute { |documents| documents.count(selector, options) }
+    end
+
+    def delete(id_or_array)
+      where(id: id_or_array).delete_all
+    end
+
+    def delete_all(conditions = nil)
+      where(conditions).execute { |documents| documents.delete_all }
+    end
+
+    def destroy(id)
+      execute { |documents| documents.destroy(id) }
+    end
+
+    def destroy_all(conditions = nil)
+      where(conditions).execute { |documents| documents.destroy_all }
+    end
+
+    def empty?
+      execute { |documents| documents.empty? }
+    end
+
+    def exists?(conditions = nil)
+      query = case conditions
+              when nil
+                self
+              when Numeric, String
+                where({id: conditions})
+              else
+                where(conditions)
+              end
+
+      query.execute { |documents| documents.exists? }
+    end
+
+    def find(*args)
+      execute { |documents| documents.find(*args) }
+    end
+
+    def find_by(*args)
+      where(*args).first
+    end
+
+    def find_by!(*args)
+      find_by(*args) or raise ActiveRecord::RecordNotFound
+    end
+
+    def find_each(options = {})
+      execute { |documents| documents.find_each(options) }
+    end
+
+    def find_in_batches(options = {})
+      execute { |documents| documents.find_in_batches(options) }
+    end
+
+    def first(limit = nil)
+      if limit
+        limit(limit).execute { |documents| documents.first }
+      else
+        execute { |documents| documents.first }
+      end
+    end
+
+    def first!
+      execute { |documents| documents.first! }
+    end
+
+    def first_or_create(attributes = {})
+      attributes = where_values_hash.with_indifferent_access.deep_merge(attributes)
+      first or create(attributes)
+    end
+
+    def first_or_initialize(attributes = {})
+      attributes = where_values_hash.with_indifferent_access.deep_merge(attributes)
+      first or model_class.new(attributes)
+    end
+
+    def ids
+      pluck('id')
+    end
+
+    def last(limit = nil)
+      reverse_order.first(limit)
+    end
+
+    def last!
+      reverse_order.first!
+    end
+
+    def load
+      execute { |documents| documents.load }
+    end
+
+    def many?
+      execute { |documents| documents.many? }
+    end
+
+    def pluck(*selectors)
+      selectors = join_arguments(*selectors)
+      if selectors == ""
+        []
+      elsif selectors == "*"
+        execute { |documents| documents.pluck("\"#{table_name}\".__doc__body") }
+      elsif selectors == "id"
+        execute { |documents| documents.pluck("\"#{table_name}\".id") }
+      else
+        result = nil
+        execute { |documents| result = documents.pluck("json_selectors('#{selectors}', \"#{table_name}\".__doc__body)") }
+        if selectors.include?(",")
+          result
+        else
+          result.flatten(1)
+        end
+      end
+    end
+
+    def select(*selectors)
+      selectors = selectors.flatten(1)
+      if selectors.length == 0
+        []
+      elsif selectors.length == 1
+        selector = selectors[0]
+        case selector
+        when String, Symbol
+          selector = selector.to_s.gsub(/\s+/, '')
+          if selector == "*"
+            pluck("*").map { |body| body ? Hashie::Mash.new(body) : body }
+          else
+            selectors = selector.split(",")
+            if selectors.length == 1
+              select({selector => selector})
+            else
+              select(selectors)
+            end
+          end
+        when Hash
+          flat_hash = selector.flatten_hash
+          pluck(flat_hash.values).map do |row|
+            flat_body = if flat_hash.keys.length == 1
+                          {flat_hash.keys[0] => row}
+                        else
+                          Hash[flat_hash.keys.zip(row)]
+                        end
+            deep_hash = flat_body.deepen_hash
+            Hashie::Mash.new(deep_hash) if deep_hash
+          end
+        else
+          raise ArgumentError, "Invalid argument(s): #{selectors.inspect}"
+        end
+      else
+        select(Hash[selectors.zip(selectors)])
+      end
+    end
+
+    def size
+      execute { |documents| documents.size }
+    end
+
+    def take(limit = nil)
+      execute { |documents| documents.take(limit) }
+    end
+
+    def take!
+      execute { |documents| documents.take! }
+    end
+
+    def to_a
+      execute { |documents| documents.to_a }
+    end
+
+    def to_sql
+      execute { |documents| documents.to_sql }
+    end
+
+    def where_values_hash
+      where_equals = query_tree[:where_equal] || []
+      values_hash = where_equals.inject({}) do |result, where_equal|
+        key = where_equal[:attribute]
+        result[key] = where_equal[:argument]
+        result
+      end
+      values_hash.deepen_hash
+    end
+
+  protected
+
+    def define_selector(attribute_name)
+      case attribute_name.to_s
+      when "id"
+        "\"#{table_name}\".id"
+      else
+        "json_selector('#{attribute_name}', \"#{table_name}\".__doc__body)"
+      end
+    end
+
+    def prepare_query_tree_for_method_mapping(query_tree)
+      prepared_query_tree = query_tree.map do |method_sym, arguments_collection|
+        arguments_collection.map do |arguments|
+          case method_sym
+          when :limit
+            [:limit, arguments]
+          when :offset
+            [:offset, arguments]
+          when :order
+            name, direction = arguments.split(" ")
+            selector = define_selector(name)
+            [:order, "#{selector} #{direction}"]
+          when :where_function
+            function = arguments[:function]
+            escape_sql_single_quote = function.gsub("'", "''")
+            condition = "js_filter('#{escape_sql_single_quote}', '#{arguments[:arguments]}', \"#{table_name}\".__doc__body) = 1"
+            [:where, condition]
+          when :where_forward
+            if arguments[0].is_a?(String)
+              json_regex = "json_([^ =]+)"
+              arguments[0] = arguments[0].gsub(/^#{json_regex}\ /) {"json_selector('#{$1}', \"#{table_name}\".__doc__body) "}
+              arguments[0] = arguments[0].gsub(/\ #{json_regex}\ /) {" json_selector('#{$1}', \"#{table_name}\".__doc__body) "}
+              arguments[0] = arguments[0].gsub(/\ #{json_regex}$/) {" json_selector('#{$1}', \"#{table_name}\".__doc__body)"}
+            end
+            [:where, arguments]
+          when :where_equal
+            selector = define_selector(arguments[:attribute])
+            argument = arguments[:argument]
+            case argument
+            when Array
+              values = argument.map{|v| v ? v.to_s : nil}
+              [:where, "(#{selector} IN (?))", values]
+            when Range
+              first_value = argument.first ? argument.first.to_s : nil
+              last_value = argument.last ? argument.last.to_s : nil
+              [:where, "(#{selector} BETWEEN ? AND ?)", first_value, last_value]
+            else
+              value = argument ? argument.to_s : nil
+              [:where, "#{selector} = ?", value]
+            end
+          else
+            raise NotImplementedError, "Query tree method '#{method_sym}' not mapped to Active Record."
+          end
+        end
+      end
+      prepared_query_tree.flatten(1)
+    end
+
+    def active_record_send_invocations
+      prepare_query_tree_for_method_mapping(query_tree)
+    end
+  end
+end
+
+    # def query(params)
+    #   valid_params = params.slice(:filter, :filter_arguments, :count, :page, :per_page, :order, :limit, :offset, :select)
+
+    #   inquiry = self
+    #   inquiry = inquiry.where(valid_params[:filter], valid_params[:filter_arguments]) if valid_params[:filter].present?
+
+    #   total_count = inquiry.count
+
+    #   if valid_params[:count].to_s.downcase.in? ["true", "yes", "1"]
+    #     total_count
+    #   else
+    #     meta = {
+    #       page: 1,
+    #       per_page: nil,
+    #       total_pages: 1,
+    #       total_count: total_count,
+    #     }
+
+    #     page, per_page = valid_params[:page].to_i, valid_params[:per_page].to_i
+
+    #     inquiry = if valid_params[:page].present?
+    #                 total_pages = total_count/per_page
+    #                 total_pages = total_pages + 1 if 0 < total_count%per_page
+    #                 meta[:page] = page
+    #                 meta[:per_page] = per_page
+    #                 meta[:total_pages] = total_pages
+    #                 inquiry.page(page, per_page)
+    #               else
+    #                 inquiry
+    #               end
+
+    #     inquiry = inquiry.order(valid_params[:order]) if valid_params[:order].present?
+    #     inquiry = inquiry.limit(valid_params[:limit].to_i) if valid_params[:limit].present?
+    #     inquiry = inquiry.offset(valid_params[:offset].to_i) if valid_params[:offset].present?
+
+    #     meta[:updated_at] = inquiry.except(:order)
+    #                                .order('updatedAt desc')
+    #                                .limit(1)
+    #                                .select("updatedAt")
+    #                                .first
+    #                                .try("updatedAt")
+
+    #     bodies =  if valid_params[:select].present?
+    #                 inquiry.select(valid_params[:select])
+    #               else
+    #                 inquiry.pluck("body")
+    #               end
+
+    #     {documents: bodies, meta: meta}
+    #   end
+    # end
+
+    # def digest_etag(seed = nil)
+    #   inquery = except(:order).order('id')
+    #   digest_seed = (inquery.pluck(:etag) + [inquery.to_sql + seed.to_s]).join
+    #   etag = Digest::SHA2.hexdigest(digest_seed)
+    # end
+
+    # def latest_updated_at
+    #   except(:order).order('updated_at DESC').limit(1).pluck(:updated_at).first
+    # end
+
+    # def xor_uuids(uuid_array)
+    #   # move work to db: http://stackoverflow.com/questions/17739887/how-to-xor-md5-hash-values-and-cast-them-to-hex-in-postgresql
+    #   uuid_array.inject("") { |result, uuid| (result.to_i(16) ^ uuid.to_i(16)).to_s(16) }
+    # end