wherever-positions 0.1.1

data/lib/wherever/db_store/record_matcher.rb

@@ -0,0 +1,28 @@
+module DbStore
+  module RecordMatcher
+    def ==(record)
+      self.clean_attributes == record.clean_attributes
+    end
+    
+    protected
+    def clean_attributes
+      att = self.attributes.clone
+      att.delete('_id')
+      att
+    end
+
+    def clean_attributes_a
+      clean_hash(self.attributes)
+    end
+
+    def clean_hash(values)
+      res = {}
+      values.each do |k, v|
+        if k == :_id
+          res[k.to_s] = v.is_a?(Hash) ? clean_hash(v) : v
+        end
+      end
+      res
+    end
+  end
+end

data/lib/wherever/db_store/store.rb

@@ -0,0 +1,9 @@
+module DbStore
+  class Store
+    include Mongoid::Document
+    embedded_in :marker, :class_name => 'DbStore::Marker'
+    embeds_many :datasets, :class_name => 'DbStore::Dataset'
+    embeds_many :identifiers, :class_name => 'DbStore::Identifier'
+    field :key, :type => Array
+  end
+end

data/lib/wherever/db_store.rb

@@ -0,0 +1,10 @@
+module DbStore
+end
+
+require 'wherever/db_store/record_matcher'
+require 'wherever/db_store/marker'
+require 'wherever/db_store/store'
+require 'wherever/db_store/dataset'
+require 'wherever/db_store/identifier'
+
+require 'wherever/db_store/lookup'

data/lib/wherever/wherever/accessors.rb

@@ -0,0 +1,30 @@
+class Wherever
+  module Accessors
+    def get_key_store(*keys)
+      mark = keys.last.is_a?(Hash) ? keys.pop["marker"] : marker
+      collection(mark).stores.find_or_create_by(:key => keys)
+    end
+    
+    def collection(mark=marker)
+      DbStore::Marker.find_by_name(mark)
+    end
+    
+    def identifier_set
+      get_key_store("identifier")
+    end
+    
+    def unique_set
+      get_key_store("unique")
+    end
+    
+    def identifier_key
+      key = version_key
+      key.delete("version")
+      key
+    end
+    
+    def version_key
+      {}.merge(@options["unique"]).merge(@options["keys"])
+    end
+  end
+end

data/lib/wherever/wherever/adder.rb

@@ -0,0 +1,71 @@
+class Wherever
+  module Adder
+    def add(values, options)
+      @options = options
+      if record = find
+        update(record.diff(values), record)
+      else
+        create(values)
+      end
+    end
+  
+    def find
+      identifier_set.datasets.where(identifier_key).first
+    end
+  
+    def create(values)
+      for_unique(values)
+      id_record = create_for_identifier(values)
+      config.key_groups.each do |group|
+        for_group(group, values, id_record)
+      end
+    end
+
+    def update(diff, record)
+      for_unique(diff)
+      id_record = update_for_identifier(diff, record)
+      config.key_groups.each do |group|
+        for_group(group, diff, id_record)
+      end
+    end
+  
+    def create_for_identifier(values)
+      record = identifier_set.datasets.create(version_key)
+      update_record(record, values, record)
+    end
+  
+    def update_for_identifier(diff, record)
+      record["version"] = @options["unique"]["version"]
+      update_record(record, diff, record)
+    end
+
+    def update_record(record, data, id_record, keys=config.keys)
+      @grouping.call(record.values, data.clone, id_record, keys)
+      record.save!
+      record
+    end
+  
+    def for_unique(values)
+      unique_set.datasets.create(version_key.merge("values" => values.clone))
+    end
+  
+    def for_group(group_keys, values, id_record)
+      key = {}
+      group_keys.each do |key_values|
+        k_id = "#{key_values}_id"
+        key.merge!(k_id => @options["keys"][k_id])
+      end
+      store = get_key_store(*group_keys)
+      record = store.datasets.find_or_create_by(key)
+
+      update_record(record, values, id_record, group_keys)
+      update_identifier(store, @options["unique"])
+    end
+  
+    def update_identifier(store, unique)
+      record = store.identifiers.find_or_create_by(config._id => unique[config._id])
+      record["version"] = unique["version"]
+      record.save
+    end
+  end
+end

data/lib/wherever/wherever/getter.rb

@@ -0,0 +1,31 @@
+class Wherever
+  module Getter
+    def get(selector, mark=marker)
+      keys = get_keys_from(selector) + [{"marker" => mark}]
+      result = Hash.new(0)
+      if keys.first == "identifier"
+        get_key_store(*keys).datasets.where(selector).all.each do |record|
+          @grouping.call(result, record.values, result, config)
+        end
+        result
+      else
+        get_key_store(*keys).datasets.where(selector).first.try(:values) || {}
+      end
+    end
+    
+    protected
+    def get_keys_from(selector)
+      check_keys(selector.keys)
+      keys = selector.keys.map{|key| key.gsub(/_id$/, '') }
+      config.key_groups.each do |group|
+        return group if (group & keys) == group && (keys & group) == keys
+      end
+      ["identifier"]
+    end
+    
+    def check_keys(keys)
+      invalid_keys = (keys - config.keys)
+      raise InvalidSelector,"Unknown Selector: #{invalid_keys.join(' ')}" unless invalid_keys.empty?
+    end
+  end
+end

data/lib/wherever/wherever/lookup.rb

@@ -0,0 +1,66 @@
+class Wherever
+  module Lookup
+    def create_lookup(name, keys)
+      lookup = DbStore::Lookup.find_or_create_by(:name => name)
+      lookup.keys = keys
+      lookup.save
+
+      self.class.class_eval do
+        define_method "set_#{name}" do |version, values|
+          lookup, record = create_lookup_record(name, version)
+          record.values = key_to_string(values)
+          record.save
+          recalculate if set_price_lookup(version)
+        end
+      end
+    
+      self.class.class_eval do
+        define_method "get_#{name}" do |version, data|
+          lookup, record = get_lookup_record(name, version)
+          value_key = lookup.keys.map{|key| data[key]}.join('_')
+          record.values[value_key] || 0
+        end
+      end
+    end
+  
+    protected
+    def key_to_string(values)
+      string_values = {}
+      values.each {|k, v| string_values[Array[k].join('_')] = v}
+      string_values
+    end
+    
+    def set_price_lookup(version)
+      return false if collection.price == version
+      collection.update_attributes(:price => version)
+    end
+    
+    def recalculate
+      config.key_groups.each do |group|
+        get_key_store(*group).datasets.delete_all
+      end
+      
+      identifier_set.datasets.all.each do |record|
+        @grouping.call(record.values, nil, record, config.keys)
+        record.save!
+        config.key_groups.each do |group|
+          for_group(group, record.values, record)
+        end
+      end
+    end
+    
+    def get_lookup_record(name, version)
+      lookup = DbStore::Lookup.where(:name => name).first
+      raise InvalidLookup, "Attempt to access invalid lookup: #{name}" unless lookup
+      return [lookup, lookup.versions.find_or_create_by(:name => version)]
+    end
+    
+    def create_lookup_record(name, version)
+      lookup = DbStore::Lookup.where(:name => name).first
+      raise InvalidLookup, "Attempt to access invalid lookup: #{name}" unless lookup
+      records = lookup.versions.where(:name => version)
+      raise InvalidLookupSetter, "Lookup '#{version}' for '#{name}' already set" unless records.empty?
+      return [lookup, lookup.versions.find_or_create_by(:name => version)]
+    end
+  end
+end

data/lib/wherever/wherever/mark.rb

@@ -0,0 +1,11 @@
+class Wherever
+  module Mark
+    def mark(name)
+      marker = collection(name)
+      marker.price = collection.price
+      collection.stores.all.each do |store|
+        marker.stores.create(:key => store.key, :datasets => store.datasets.clone) unless store.key == ["unique"]
+      end
+    end
+  end
+end

data/lib/wherever/wherever.rb

@@ -0,0 +1,26 @@
+class InvalidSelector < StandardError; end
+class InvalidLookup <  StandardError; end
+class InvalidLookupSetter <  StandardError; end
+
+class Wherever
+  include Accessors
+  include Adder
+  include Getter
+  include Lookup
+  include Mark
+  attr_reader :config, :marker
+  
+  def initialize(options={}, &grouping)
+    @config = Configure.new(options)
+    @marker = options[:marker] || 'current'
+    if block_given?
+      @grouping = grouping
+    else
+      @grouping = lambda do |values, data, record, keys|
+        data.keys.each do  |key|
+          values[key] += data[key]
+        end
+      end
+    end
+  end
+end

data/lib/wherever.rb

@@ -0,0 +1,10 @@
+require 'mongoid'
+require 'wherever/wherever/accessors'
+require 'wherever/wherever/adder'
+require 'wherever/wherever/getter'
+require 'wherever/wherever/lookup'
+require 'wherever/wherever/mark'
+require 'wherever/wherever'
+require 'wherever/configure'
+require 'wherever/wherever/adder'
+require 'wherever/db_store'

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'wherever'
+require 'ruby-debug'
+require 'database_cleaner'
+
+Wherever.new("keys" => ["fund_id"], "database" => 'wherever_test')
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+#  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.before(:each) do
+    DatabaseCleaner.orm = "mongoid" 
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.clean
+  end
+end

data/spec/wherever/adder_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Wherever" do
+  let(:wherever) { Wherever.new("keys" => keys, "database" => 'wherever_test', "key_groups" => key_groups, "key" => "trade_id") }
+  let(:keys) { ["fund_id"] }
+  let(:key_groups) { nil }
+    
+  context 'adding the first record' do
+    let(:options) { {"unique" => {"trade_id" => 12, "version" => 1}, "keys" => {"fund_id" => 2}} }
+    context 'the unique dataset' do
+      it 'inserts a record' do
+        wherever.add({"settled" => 100, "unsettled" => 0}, options)
+        wherever.get_key_store("unique").datasets.should == 
+              [DbStore::Dataset.new("trade_id" => 12, "values" => {"unsettled" => 0, "settled" => 100}, "version" => 1, "fund_id" => 2)] 
+      end
+    end
+    
+    context 'the id dataset' do
+      it 'inserts a record' do
+        wherever.add({"settled" => 100, "unsettled" => 0}, options)
+        wherever.get_key_store("identifier").datasets.should ==
+            [DbStore::Dataset.new("trade_id" => 12, "values" => {"unsettled" => 0, "settled" => 100}, "version" => 1, "fund_id" => 2)] 
+      end
+    end
+
+    context 'the key datasets' do
+      context 'with a single key' do
+        it 'inserts a record' do
+          wherever.add({"settled" => 100, "unsettled" => 0}, options)
+          wherever.get_key_store("fund").datasets.should ==
+              [DbStore::Dataset.new("values" => {"unsettled" => 0, "settled" => 100}, "fund_id" => 2)] 
+          wherever.get_key_store("fund").identifiers.should ==
+              [DbStore::Identifier.new("trade_id" => 12, "version" => 1)] 
+        end
+      end
+
+      context 'with a multiple keys' do
+        let(:keys) { ["fund_id", "security_id"] }
+        let(:options) { {"unique" => {"trade_id" => 12, "version" => 1}, "keys" => {"fund_id" => 2, "security_id" => 4}} }
+        
+        it 'inserts a record for each key combination' do
+          wherever.add({"settled" => 100, "unsettled" => 0}, options)
+
+          wherever.get_key_store("fund").datasets.should ==
+              [DbStore::Dataset.new("values" => {"unsettled" => 0, "settled" => 100}, "fund_id" => 2)] 
+          wherever.get_key_store("fund").identifiers.should ==
+              [DbStore::Identifier.new("trade_id" => 12, "version" => 1)] 
+
+          wherever.get_key_store("security").datasets.should ==
+              [DbStore::Dataset.new("values" => {"unsettled" => 0, "settled" => 100}, "security_id" => 4)] 
+          wherever.get_key_store("security").identifiers.should ==
+              [DbStore::Identifier.new("trade_id" => 12, "version" => 1)] 
+        end
+      end
+
+      context 'with a multiple keys and grouping configured' do
+        let(:keys) { ["fund_id", "security_id"] }
+        let(:key_groups) { ["fund", "security", ["fund", "security"]] }
+        let(:options) { {"unique" => {"trade_id" => 12, "version" => 1}, "keys" => {"fund_id" => 2, "security_id" => 4}} }
+        
+        it 'inserts a record for each key combination' do
+          wherever.add({"settled" => 100, "unsettled" => 0}, options)
+
+          wherever.get_key_store("fund").datasets.should ==
+              [DbStore::Dataset.new("values" => {"unsettled" => 0, "settled" => 100}, "fund_id" => 2)] 
+          wherever.get_key_store("fund").identifiers.should ==
+              [DbStore::Identifier.new("trade_id" => 12, "version" => 1)] 
+
+          wherever.get_key_store("security").datasets.should ==
+              [DbStore::Dataset.new("values" => {"unsettled" => 0, "settled" => 100}, "security_id" => 4)] 
+          wherever.get_key_store("security").identifiers.should ==
+              [DbStore::Identifier.new("trade_id" => 12, "version" => 1)] 
+
+          wherever.get_key_store("fund", "security").datasets.should ==
+              [DbStore::Dataset.new("fund_id" => 2, "security_id" => 4, "values" => {"unsettled" => 0, "settled" => 100})] 
+          wherever.get_key_store("fund", "security").identifiers.should ==
+              [DbStore::Identifier.new("trade_id" => 12, "version" => 1)] 
+        end
+      end
+    end
+  end
+  
+  context 'adding subsequent records' do
+    let(:options_first) { {"unique" => {"trade_id" => 12, "version" => 1}, "keys" => {"fund_id" => 2}} }
+    let(:options_second) { {"unique" => {"trade_id" => 12, "version" => 2}, "keys" => {"fund_id" => 2}} }
+    before do
+      wherever.add({"settled" => 100, "unsettled" => 0}, options_first)
+    end
+    
+    context 'the unique dataset' do
+      it 'add the change' do
+        wherever.add({"settled" => 110, "unsettled" => 0}, options_second)
+
+        wherever.get_key_store("unique").datasets.should ==
+            [DbStore::Dataset.new("fund_id" => 2, "trade_id" => 12, "version" => 1, "values" => {"unsettled" => 0, "settled" => 100}),
+             DbStore::Dataset.new("fund_id" => 2, "trade_id" => 12, "version" => 2, "values" => {"unsettled" => 0, "settled" => 10})] 
+      end
+    end
+
+    context 'the identifier dataset' do
+      it 'updates the record' do
+        wherever.add({"settled" => 110, "unsettled" => 0}, options_second)
+
+        wherever.get_key_store("identifier").datasets.should ==
+            [DbStore::Dataset.new("fund_id" => 2, "trade_id" => 12, "version" => 2, "values" => {"unsettled" => 0, "settled" => 110})]
+      end
+    end
+
+    context 'the key datasets' do
+      context 'with a single key' do
+        it 'inserts a record' do
+          wherever.add({"settled" => 110, "unsettled" => 0}, options_second)
+          wherever.get_key_store("fund").datasets.should ==
+              [DbStore::Dataset.new("values" => {"unsettled" => 0, "settled" => 110}, "fund_id" => 2)] 
+          wherever.get_key_store("fund").identifiers.should ==
+              [DbStore::Identifier.new("trade_id" => 12, "version" => 2)] 
+        end
+      end
+    end
+  end
+end