finexclub 0.4.3 → 0.5.1

data/README.rdoc

@@ -1,6 +1,51 @@
 = finexclub
 
-Nobody is really interested in this gem. Finexclub gem helps us to run http://trendsonforex.com and http://finexclub.net
+Nobody is really interested in this gem. Finexclub gem helps us to run http://trendsonforex.com and http://finexclub.net.
+
+Signals are saved into MongoDB according to the scheme:
+
+  chart:
+    symbol: 'eurusd'             # Currency pair symbol, eg. 'eurusd', 'gbpusd', etc.
+    timeframe: 'h1'              # Timeframe 'h1', 'h4', 'd1'
+    starts:  1293447600          # Timestamp when this timeframe slot starts, eg. Dec, 27 11:00:00 
+    expires: 1293451200          # Timestamp when this timeframe slot is expired, eg. Dec, 27 12:00:00 
+    updated: 1293447840          # UTC timestamp when this timeframe was last updated, eg. Dec, 27 11:04:00
+    indicators:                  # Latest data from indicators
+
+      alpha:                     # Alpha: trendline analysis
+        updated: 1293447840
+        index: 89                # Trend stability index 0..100
+        direction: 'up'          # Trend direction 'up', 'down'
+
+      octopus:                   # Octopus: wave based analysis
+        updated: 1293447840
+        action: 'buy'            # Order 'buy', 'sell', 'hold_buy', 'hold_sell', 'stop'
+        take_profit: 1.3350
+        profit: 90               # Possible profit in pips 
+        stop_loss: 1.3250
+        loss: 60                 # Possible loss in pips 
+        index: 89                # Wave quality index 0..100; 0 - no wave matches found
+        screenshot: '...'        # Path to S3 image
+
+      prognosis:                 # Prognosis: chaos theory based analysis
+        updated: 1293447840
+        action: 'hold_buy'
+        take_profit: 1.3350
+        profit: 90
+        stop_loss: 1.3250
+        loss: 60
+        acceleration: 'low'      # 'high', 'low', 'undefined'
+        screenshot: '...'
+
+      zeta:                      # Zeta: support & resistance channels
+        updated: 1293447840
+        up_support: 1.3350       # 0 if no up-channel found
+        up_resist: 1.3250        
+        down_support: 1.3250     # 0 if no down-channel found 
+        down_resist: 1.3250       
+        screenshot: '...'
+
+To save a signal it looks for a valid (not expired) chart record in MongoDB that corresponds to the given symbol and timeframe. If chart has expired, it creates a new one with prolongated expiration date to accumulate incoming signals.
 
 == Copyright
 

data/VERSION

@@ -1 +1 @@
-0.4.3
+0.5.1

data/finexclub.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{finexclub}
-  s.version = "0.4.3"
+  s.version = "0.5.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alex Levin"]
-  s.date = %q{2010-12-20}
+  s.date = %q{2011-02-04}
   s.default_executable = %q{finexclub_updater}
   s.description = %q{Finexclub gem stores and retrieves Forex signals and screenshots. It is the heart of the http://trendsonforex.com and http://finexclub.net}
   s.email = %q{clubfinex@gmail.com}

data/lib/finexclub/app.rb

@@ -19,10 +19,16 @@ module Finexclub
       end
     end
 
-    post "/:signal" do
-      signal_type = params[:signal].to_sym
-      ap params[signal_type]
-      Finexclub.store(signal_type, params[signal_type]) 
+    post "/:indicator" do
+      indicator = params[:indicator].to_sym
+      indicator_data = params[indicator]
+
+      indicator_data = params[indicator].is_a?(Array) ? params[indicator] : [ params[indicator] ]
+      indicator_data.each do |s|
+        ap s.merge(:updated => Time.now.utc)
+        Finexclub.signals.add_signal(indicator, s, Time.now.utc)
+      end
+
       status 200
     end
   end

data/lib/finexclub/chart.rb

@@ -4,35 +4,67 @@ module Finexclub
 
     include Document
 
-    field :updated, :timestamp
     field :symbol, :symbol
     field :timeframe, :string
-    field :date, :string
+    field :starts, :timestamp
+    field :expires, :timestamp
+    field :updated, :timestamp
 
     attr_reader :core
+    attr_accessor :indicators
+
+    doc_fields :symbol, :timeframe, :starts, :expires, :updated, :indicators
 
     def initialize(core)
       @core = core
-      @signals = {}
+      @indicators = {}
     end
 
-    [:alpha, :zeta, :octopus, :prognosis].each do |indicator|
-      define_method("#{indicator}=") do |arr|
-        @signals[indicator] = arr
-      end
+    def handler_for(indicator)
+      self.class.handler_for(indicator)
+    end
+
+    def self.build_new(core, symbol, tf, time)
+      time = time.is_a?(Time) ? time : Time.at(time).utc
 
-      define_method(indicator) do
-        return nil unless signals(indicator)
-        Signal.build(core, indicator, signals(indicator).last)
+      c = Chart.new(core)
+      c.updated= time.to_i 
+      c.symbol= symbol
+      c.timeframe = tf
+      c.starts = Time.utc(time.year, time.month, time.day, time.hour, 0).to_i
+      c.expires = c.starts + 1*60*60
+      c
+    end
+
+    def self.indicator_handler(indicator, indicator_handler_class)
+      add_handler_for(indicator, indicator_handler_class)
+
+      #define_method("#{indicator}=") do |doc|
+        #@indicator_docs[indicator] = doc
+      #end
+
+      define_method("#{indicator}") do
+        return nil unless doc = indicators[indicator.to_s]
+
+        indicator_obj = handler_for(indicator.to_s).new(core)
+        indicator_obj.build(doc)
+        indicator_obj
       end
     end
 
-    def signals(indicator)
-      @signals[indicator]
+    def self.add_handler_for(indicator, klass)
+      @handlers ||= {}
+      @handlers[indicator.to_s] = klass
     end
-    
-    def to_doc
-      {:symbol => symbol, :date => updated_date}
+
+    def self.handler_for(indicator)
+      @handlers ||= {}
+      @handlers[indicator.to_s]
     end
+
+    indicator_handler :alpha, Finexclub::Signals::Alpha
+    indicator_handler :zeta,  Finexclub::Signals::Zeta
+    indicator_handler :octopus,  Finexclub::Signals::Octopus
+    indicator_handler :prognosis,  Finexclub::Signals::Prognosis
   end
 end

data/lib/finexclub/core.rb

@@ -17,23 +17,24 @@ module Finexclub
       self
     end
 
-    def store(signal_type, params)
-      params = params.is_a?(Array) ? params : [params]
-      params.each do |s|
-        signals.add_signal(signal_type, s)
-      end
-    end
+    #def store(signal_type, params)
+      #params = params.is_a?(Array) ? params : [params]
+      #params.each do |s|
+        #signals.add_signal(signal_type, s)
+      #end
+    #end
+
+    #def find(symbol_or_array, date)
+      #case symbol_or_array
+      #when :all
+        #signals.find(:date => date)
+      #when Array
+        #signals.find(:date => date, :symbol => {:$in => symbol_or_array})
+      #when String
+        #signals.find_one(:date => date, :symbol => symbol_or_array)
+      #end
+    #end
 
-    def find(symbol_or_array, date)
-      case symbol_or_array
-      when :all
-        signals.find(:date => date)
-      when Array
-        signals.find(:date => date, :symbol => {:$in => symbol_or_array})
-      when String
-        signals.find_one(:date => date, :symbol => symbol_or_array)
-      end
-    end
   end
 end
 

data/lib/finexclub/document.rb

@@ -7,6 +7,11 @@ module Finexclub
         extend ClassMethods
 
         def _id=(value)
+          @id = value
+        end
+
+        def _id
+          @id
         end
       end
     end

data/lib/finexclub/fabrication.rb

@@ -1,12 +1,13 @@
 module Finexclub
   module Fabrication
     def raw_alpha_hash(options = {})
-      {"symbol" => "EURUSD", "index"=>"2", "direction"=>"1"}.merge(options)
+      {"symbol" => "EURUSD", "timeframe" => 'h1', "index"=>"2", "direction"=>"1"}.merge(options)
     end
 
     def raw_zeta_hash(options={})
       {
         "symbol" => "EURUSD",
+        "timeframe" => "h1",
         "up_support" => "1.124", 
         "up_resist" => "1.123",
         "down_support" => "1.124",

data/lib/finexclub/manager.rb

@@ -12,34 +12,61 @@ module Finexclub
     end
 
     def collection
-      raise("No db configured") if db.nil?
+      raise ConfigurationError.new("No db is configured") if db.nil?
       db.collection('charts')
     end
 
     def find(query, opts = {})
-      Cursor.new(core, Chart, collection.find(query, opts))
+      Cursor.new(core, Finexclub::Chart, collection.find(query, opts))
     end
 
-    def find_one(query, opts = {})
-      return nil unless doc = collection.find_one(query, opts)
-      chart = Chart.new(core)
-      chart.build(doc)
-      chart
+    def find_one(symbol, tf, time = nil)
+      time ||= Time.now.utc
+      time = time.respond_to?(:to_i) ? time.to_i : time
+      find({:symbol => symbol, :timeframe => tf, :starts => {:$lte => time}, :expires => {:$gt => time}}, :limit => 1, :sort => [[:expires, -1]]).first
     end
 
-    def last_updated
-      c = collection.find({}, :fields => {:updated => 1}, :sort => [['updated', :desc]], :limit => 1).first
-      c.nil?? nil : Time.at(c["updated"])
+    def find_many(symbol_or_array, tf, time = nil)
+      time ||= Time.now.utc
+      time = time.respond_to?(:to_i) ? time.to_i : time
+      find({:symbol => {:$in => symbol_or_array}, :timeframe => tf, :starts => {:$lte => time}, :expires => {:$gt => time}}, :limit => 1, :sort => [[:expires, -1]])
     end
 
-    def add_signal(signal_type, params)
-      signal = Signal.build(core, signal_type, params.merge(:updated => Time.now))
-      c = {
-        :symbol => signal.symbol,
-        :timeframe => signal.timeframe,
-        :date => signal.updated_at.strftime("%Y-%m-%d")
-      }
-      collection.update(c, {"$push" => {signal_type => signal.to_doc}, "$set" => {:updated => signal.updated}}, :upsert => true)
+    def find_latest(symbol, tf)
+      find({:symbol => symbol, :timeframe => tf}, :sort => [[:expires, :desc]], :limit => 1).first
+    end
+
+    def find_one_or_create(symbol, tf, time)
+      chart = find_one(symbol, tf, time)
+      return chart if chart
+
+      id = collection.insert(Chart.build_new(core, symbol, tf, time).to_doc)
+      find({"_id" => id}).first
+    end
+
+    def last_updated(tf)
+      doc = collection.find({:timeframe => tf}, :fields => {:updated => 1}, :sort => [[:updated, :desc]], :limit => 1).first
+      doc.nil?? nil : doc["updated"]
+    end
+
+    def last_updated_at(tf)
+      ts = last_updated(tf)
+      ts.nil? ? nil : Time.at(ts).utc
+    end
+
+    def add_signal(indicator, params, time)
+      time = time.respond_to?(:to_i) ? time.to_i : time
+
+      signal = Signal.build(core, indicator, params.merge(:updated => time))
+      chart = find_one_or_create(signal.symbol, signal.timeframe, time)
+
+      c = if chart._id
+        {"_id" => chart._id}
+      else
+        chart.to_doc
+      end
+
+      collection.update(c, {"$set" => {:updated => signal.updated, "indicators.#{indicator}" => signal.to_doc}}, :upsert => true)
     end
 
     class Cursor

data/lib/finexclub.rb

@@ -33,9 +33,11 @@ autoload_files_in_dir("#{File.dirname(__FILE__)}/finexclub", 'Finexclub')
 require 'forwardable'
 
 module Finexclub
+  class ConfigurationError < StandardError; end
+
   class << self
     extend Forwardable
-    def_delegators :core, :store, :find, :configure
+    def_delegators :core, :configure
     def_delegators :core, :images, :signals
 
     def core

data/spec/finexclub/app_spec.rb

@@ -24,62 +24,130 @@ def make_request(url, opts = {})
   last_response
 end
 
-def date(ts = nil)
-  ts ||= Time.now.utc
-  ts.strftime("%Y-%m-%d")
-end
+describe 'Finexclub::App' do
+  before do
+    charts.drop
+  end
 
-def alpha_params()
-  params = {}
-  params[:alpha] = Finexclub::Chart::SYMBOLS.inject([]) {|alpha, symbol| alpha << raw_alpha_hash("symbol" => symbol.upcase)}
-  params
-end
+  describe 'Alpha' do
+    before do
+      @params = {} 
+      @params[:alpha] = []
+
+      Finexclub::Chart::SYMBOLS.each do |symbol|
+        @params[:alpha] << {
+          "symbol" => symbol.upcase,
+          "timeframe" => 'h1',
+          "direction" => 1,
+          "index" => 100
+        }
+      end
+      @params
+    end
 
-def zeta_params(options = {})
-  #options[:symbol] ||= "EURUSD"
-  params = {}
-  params[:zeta] = [raw_zeta_hash(options)]
-  params
-end
+    it 'should save signal' do
+      response = nil
+      Timecop.travel(Time.utc(2010, 12, 27, 11, 5)) do 
+        response = make_request('/alpha', @params)
+      end
+      response.status.should == 200
 
-describe 'Finexclub::App' do
-  describe 'saving Alpha' do
+      charts.find(:timeframe => 'h1').count.should == 28
+      c = charts.find_one(:symbol => 'eurusd')
+      c["updated"].should == Time.utc(2010, 12, 27, 11, 5).to_i
+      c["indicators"]["alpha"].should.not.be.nil?
+    end
+  end
+  
+  describe 'Zeta' do
     before do
-      charts.remove
+      @params = {}
+      @params[:zeta] = [{
+        "symbol" => "EURUSD",
+        "timeframe" => "h1",
+        "up_support" => "1.124", 
+        "up_resist" => "1.123",
+        "down_support" => "2.124",
+        "down_resist" => "2.123",
+        "screenshot_filename" => "egg.png"
+      }]
     end
     
-    it 'should create first signal' do
-      response = make_request('/alpha', alpha_params)
+    it 'should save signal' do
+      response = nil
+      Timecop.travel(Time.utc(2010, 12, 27, 11, 5)) do 
+        response = make_request('/zeta', @params)
+      end
       response.status.should == 200
 
-      charts.find().count.should == 28
-      charts.find_one(:date => date, :symbol => 'eurusd')["alpha"].size.should == 1
+      charts.find(:timeframe => 'h1').count.should == 1 
+      c = charts.find_one(:symbol => 'eurusd')
+      c["updated"].should == Time.utc(2010, 12, 27, 11, 5).to_i
+      c["indicators"]["zeta"].should.not.be.nil?
     end
-
-    it 'should add more alpha signals' do
-      Timecop.travel
-      response = make_request('/alpha', alpha_params)
+  end
+  
+  describe 'Octopus' do
+    before do
+      @params = {}
+      @params[:octopus] = [{
+        "symbol" => "EURUSD",
+        "timeframe" => "h1",
+        "action" => "buy",
+        "take_profit" => 1.123,
+        "profit" => 100,
+        "stop_loss" => 2.123,
+        "loss" => 50,
+        "index" => 100,
+        "tsi" => 90,
+        "trend" => 1,
+        "screenshot_filename" => "egg.png"
+      }]
+    end
+    
+    it 'should save signal' do
+      response = nil
+      Timecop.travel(Time.utc(2010, 12, 27, 11, 5)) do 
+        response = make_request('/octopus', @params)
+      end
       response.status.should == 200
 
-      Timecop.travel(1*60*60) #travel 1 hour later
-      response = make_request('/alpha', alpha_params)
-      response.status.should == 200
-      charts.find().count.should == 28
-      charts.find_one(:date => date, :symbol => 'eurusd')["alpha"].size.should == 2
+      charts.find(:timeframe => 'h1').count.should == 1 
+      c = charts.find_one(:symbol => 'eurusd')
+      c["updated"].should == Time.utc(2010, 12, 27, 11, 5).to_i
+      c["indicators"]["octopus"].should.not.be.nil?
     end
   end
-  
-  describe 'saving Zeta' do
+
+  describe 'Prognosis' do
     before do
-      charts.remove
+      @params = {}
+      @params[:prognosis] = [{
+        "symbol" => "EURUSD",
+        "timeframe" => "h1",
+        "action" => "buy",
+        "acceleration" => "undefined",
+        "take_profit" => 1.123,
+        "profit" => 100,
+        "stop_loss" => 2.123,
+        "loss" => 50,
+        "tsi" => 90,
+        "trend" => 1,
+        "screenshot_filename" => "egg.png"
+      }]
     end
     
-    it 'should create first zeta signals' do
-      response = make_request('/zeta', zeta_params)
+    it 'should save signal' do
+      response = nil
+      Timecop.travel(Time.utc(2010, 12, 27, 11, 5)) do 
+        response = make_request('/prognosis', @params)
+      end
       response.status.should == 200
 
-      charts.find().count.should == 1
-      charts.find_one(:date => date, :symbol => 'eurusd')["zeta"].size.should == 1
+      charts.find(:timeframe => 'h1').count.should == 1 
+      c = charts.find_one(:symbol => 'eurusd')
+      c["updated"].should == Time.utc(2010, 12, 27, 11, 5).to_i
+      c["indicators"]["prognosis"].should.not.be.nil?
     end
   end
 

data/spec/finexclub/chart_spec.rb

@@ -2,59 +2,153 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe 'Finexclub::Chart' do
   before do
-    @core = mock_core
+    @core = test_core
     @chart = Finexclub::Chart.new(@core)
+
+    Finexclub.signals.collection.drop
+  end
+  
+  describe 'indicators handling' do
+    before do
+      class Omega < Finexclub::Signal
+        field :symbol, :symbol
+        field :timeframe, :string
+        field :updated, :timestamp
+        field :foo, :string
+
+        doc_fields :foo, :updated
+      end
+    end
+
+    describe 'Chart#indicator_handler(:omega, Omega)' do
+      before do
+        Finexclub::Chart.indicator_handler(:omega, Omega)
+      end
+
+      it 'should return valid class as indicator handler' do
+        Finexclub::Chart.handler_for(:omega).should == Omega
+        @chart.handler_for(:omega) == Omega
+      end
+
+      describe '#omega signal accessor' do
+        before do
+          @omega_doc = {:symbol => 'usdjpy', :timeframe => 'h1', :foo => "Ololo!"}
+          Finexclub.signals.add_signal(:omega, @omega_doc, Time.utc(2010, 12, 27, 11, 5))
+          @chart = Finexclub.signals.find_one('usdjpy', 'h1', Time.utc(2010, 12, 27, 11, 10))
+        end
+
+        it 'should return valid Omega object' do
+          @chart.should.respond_to?(:omega)
+          @chart.omega.should.not == nil
+          @chart.omega.class.should == Omega
+
+          @chart.omega.foo.should == "Ololo!"
+          @chart.omega.updated.should == Time.utc(2010, 12, 27, 11, 5).to_i
+        end
+
+        it 'should return nil if no indicator doc is available' do
+          @chart.alpha.should == nil
+        end
+      end
+      
+      #it 'should add #omega=(Signal) accessor to save raw document' do
+        #omega_doc = {:foo => "Ololo!", :updated => Time.now.utc.to_i} 
+        #@chart.omega =  
+        #@chart.indicators[:omega].should == omega_doc
+      #end
+    end
+
+    describe 'complex chart with default indicators' do
+      before do
+        Finexclub.signals.add_signal(:alpha, {:symbol => 'eurusd', :timeframe => 'h1'}, Time.now.utc) 
+        Finexclub.signals.add_signal(:zeta, {:symbol => 'eurusd', :timeframe => 'h1'}, Time.now.utc) 
+        Finexclub.signals.add_signal(:octopus, {:symbol => 'eurusd', :timeframe => 'h1'}, Time.now.utc) 
+        Finexclub.signals.add_signal(:prognosis, {:symbol => 'eurusd', :timeframe => 'h1'}, Time.now.utc) 
+      end
+
+      {
+        :alpha => Finexclub::Signals::Alpha,
+        :zeta => Finexclub::Signals::Zeta,
+        :octopus => Finexclub::Signals::Octopus,
+        :prognosis => Finexclub::Signals::Prognosis
+      }.each do |indicator, klass|
+        it "should have :#{indicator} handler as #{klass}" do
+          Finexclub::Chart.handler_for(indicator).should == klass
+        end
+
+        it "should access chart.#{indicator}" do
+          chart = Finexclub.signals.find_one('eurusd', 'h1')
+          chart.send(indicator).class.should == klass
+        end
+      end
+    end
+  end
+
+  describe 'Chart.build_signal(indicator, params)' do
+  end
+
+  describe 'Chart.build_new(symbol, tf, time)' do
+    before do
+      @chart = Finexclub::Chart.build_new(@core, 'eurusd', 'h1', Time.utc(2010, 12, 27, 11, 30).to_i)
+    end
+
+    it 'should return valid new (unsaved) chart instance' do
+      @chart._id.should == nil
+      @chart.symbol.should     == 'eurusd'
+      @chart.timeframe.should  == 'h1'
+      @chart.starts.should     == Time.utc(2010, 12, 27, 11, 0).to_i
+      @chart.expires.should    == Time.utc(2010, 12, 27, 12, 0).to_i
+      @chart.updated.should    == Time.utc(2010, 12, 27, 11, 30).to_i
+      @chart.indicators.should == {}
+    end
+
+    it 'should build valid chart given time as Time object' do
+      Finexclub::Chart.build_new(@core, 'eurusd', 'h1', Time.utc(2010, 12, 27, 11, 30)).starts.should == Time.utc(2010, 12, 27, 11, 0).to_i
+    end
+
   end
+  
 
-  describe 'Instance' do
+  describe 'instance' do
     before do
       @a1, @a2 = mock('a1'), mock('a2')
-      @z1, @z2 = mock('z1'), mock('z2')
-      @ts = Time.now.to_i
+      @z1 = mock('z1')
       
-      chart_doc = {
+      @chart_doc = {
         :symbol => 'eurusd',
-        :date => '2010-09-08',
         :timeframe => 'h1',
-        :updated => @ts,
-        :alpha => [ @a1, @a2 ],
-        :zeta => [ @z1, @z2 ]
+        :starts => Time.utc(2010, 12, 27, 11, 0).to_i,
+        :expires => Time.utc(2010, 12, 27, 12, 0).to_i,
+        :updated => Time.utc(2010, 12, 27, 11, 5).to_i,
+        :indicators => {
+          :alpha => @a1,
+          :zeta => @z1
+        }
       }
-      @chart.build(chart_doc)
-    end
 
-    it 'should have attribute accessors' do
-      @chart.symbol.should == 'eurusd'
-      @chart.timeframe.should == 'h1'
-      @chart.date.should == '2010-09-08'
-      @chart.updated.should == @ts
+      @chart.build(@chart_doc)
     end
-  end
 
-  [ 
-    :alpha, 
-    :zeta, 
-    :octopus, 
-    :prognosis
-  ].each do |indicator|
-    describe "#{indicator} signals" do
-      before do
-        @s1, @s2 = mock("signal_#{indicator}_1"), mock("signal_#{indicator}_2")
-        @chart.build(indicator => [@s1, @s2])
-      end
+    it 'should provide access to raw indicator documents' do
+      @chart.indicators[:alpha].should == @a1
+      @chart.indicators[:zeta].should == @z1
+    end
 
-      it "should provide :#{indicator} signals" do
-        @chart.signals(indicator).should == [@s1, @s2]
-      end
+    it 'should update raw indicator document' do
+      @chart.indicators[:alpha] = @a2
+      @chart.indicators[:alpha].should == @a2
+    end
 
-      it "should return latest :#{indicator} wrapped as Signal" do
-        Finexclub::Signal.should.receive(:build).with(@core, indicator, @s2).and_return(a = mock('signal'))
-        @chart.send(indicator).should == a
-      end
+    it 'should provide common accessors' do
+      @chart.symbol.should == 'eurusd'
+      @chart.timeframe.should == 'h1'
+      @chart.updated.should == @chart_doc[:updated]
+      @chart.starts.should == @chart_doc[:starts]
+      @chart.expires.should == @chart_doc[:expires]
     end
 
-    it "should return nil as latest if no #{indicator} signals available" do
-      @chart.send(indicator).should == nil
+    it 'should export valid document' do
+      @chart.to_doc.should == @chart_doc
     end
   end
 

data/spec/finexclub/core_spec.rb

@@ -59,41 +59,41 @@ describe 'Finexclub::Core' do
     end
   end
 
-  describe '#find' do
-    before do
-      @core = test_core
-    end
+  #describe '#find' do
+    #before do
+      #@core = test_core
+    #end
 
-    it 'should fetch all charts for given date' do
-      @core.signals.should.receive(:find).with({:date => "2010-10-01"}).and_return(c = mock('cursor'))
-      @core.find(:all, "2010-10-01").should == c
-    end
+    #it 'should fetch all charts for given date' do
+      #@core.signals.should.receive(:find).with({:date => "2010-10-01"}).and_return(c = mock('cursor'))
+      #@core.find(:all, "2010-10-01").should == c
+    #end
 
-    it 'should fetch an array of charts for given date' do
-      @core.signals.should.receive(:find).with({:symbol => {:$in => ["eurusd", "usdjpy"]}, :date => "2010-10-01"}).and_return(c = mock('cursor'))
-      @core.find(["eurusd", "usdjpy"], "2010-10-01").should == c
-    end
+    #it 'should fetch an array of charts for given date' do
+      #@core.signals.should.receive(:find).with({:symbol => {:$in => ["eurusd", "usdjpy"]}, :date => "2010-10-01"}).and_return(c = mock('cursor'))
+      #@core.find(["eurusd", "usdjpy"], "2010-10-01").should == c
+    #end
 
-    it 'should allow fetching signals by date and symbol' do
-      @core.signals.should.receive(:find_one).with({:date => "2010-10-01", :symbol => "eurusd"}).and_return(chart = mock('chart'))
-      @core.find("eurusd", "2010-10-01").should == chart
-    end
-  end
+    #it 'should allow fetching signals by date and symbol' do
+      #@core.signals.should.receive(:find_one).with({:date => "2010-10-01", :symbol => "eurusd"}).and_return(chart = mock('chart'))
+      #@core.find("eurusd", "2010-10-01").should == chart
+    #end
+  #end
 
-  describe '#store' do
-    before do
-      @core = test_core
-    end
-    it 'should store each signal given an array of params' do
-      @core.signals.should.receive(:add_signal).with(:alpha,p1=mock('p1'))
-      @core.signals.should.receive(:add_signal).with(:alpha,p2=mock('p2'))
-      @core.store(:alpha, [p1, p2])
-    end
-    it 'should store signal given signle hash of params' do
-      @core.signals.should.receive(:add_signal).with(:alpha,p1=mock('p1'))
-      @core.store(:alpha, p1)
-    end
-  end
+  #describe '#store' do
+    #before do
+      #@core = test_core
+    #end
+    #it 'should store each signal given an array of params' do
+      #@core.signals.should.receive(:add_signal).with(:alpha,p1=mock('p1'))
+      #@core.signals.should.receive(:add_signal).with(:alpha,p2=mock('p2'))
+      #@core.store(:alpha, [p1, p2])
+    #end
+    #it 'should store signal given signle hash of params' do
+      #@core.signals.should.receive(:add_signal).with(:alpha,p1=mock('p1'))
+      #@core.store(:alpha, p1)
+    #end
+  #end
 
 end
 

data/spec/finexclub/manager_spec.rb

@@ -4,59 +4,161 @@ describe 'Finexclub::Manager' do
   before do
     @core = mock_core
     @manager = Finexclub::Manager.new(@core)
-    @manager.db = mock_mongo
-  end
 
-  describe 'mongo' do
-    before do
-      @mongo = mock('mongo')
-      @manager.db = @mongo
-    end
-    it 'should provide mongo instance' do
-      @manager.db.should == @mongo
-    end
-    it 'should have collection accessor' do
-      @mongo.stub!(:collection).and_return(coll = mock('coll'))
-      @manager.collection.should == coll 
-    end
+    @mongo = test_mongo
+    @manager.db = @mongo
+
+    @mongo.collection("charts").drop
   end
 
-  describe '.find' do
-    it 'should call find on collection and return Cursor' do
-      @manager.collection.should.receive(:find).with({:date => "2010-10-01"}, {}).and_return(c = mock('cursor'))
-      @manager.find(:date => "2010-10-01")
+  describe '.db' do
+    it 'should return mongo instance' do
+      @manager.db.should == @mongo
     end
   end
 
-  describe '.find_one' do
-    it 'should call find on collection' do
-      @manager.collection.should.receive(:find_one).with({:date => "2010-10-01", :symbol => "eurusd" }, {}).and_return({})
-      @manager.find_one(:date => "2010-10-01", :symbol => "eurusd").class == Finexclub::Chart
+  describe '.collection' do
+    it 'should raise if no db is configured' do
+      @manager.db = nil
+      should.raise(Finexclub::ConfigurationError) { @manager.collection }
     end
 
-    it 'should return nil if nothing found' do
-      @manager.collection.should.receive(:find_one).with({:date => "2010-10-01", :symbol => "eurusd"}, {}).and_return(nil)
-      @manager.find_one(:date => "2010-10-01", :symbol => "eurusd").should == nil
+    it 'should return charts collection' do
+      @manager.collection.is_a?(Mongo::Collection).should.be.true 
+      @manager.collection.name.should == "charts"
     end
   end
 
-  describe '.last_updated' do
+  describe 'finding charts' do
     before do
-      @cursor = mock('cursor', :first => {"updated" => 123}) 
+      charts = @mongo.collection('charts')
+      charts.drop
+      @c1 = {:symbol => 'eurusd', :timeframe => 'h1', :starts => Time.utc(2010, 12, 27, 11, 0).to_i, :expires => Time.utc(2010, 12, 27, 12, 0).to_i, :updated => Time.utc(2010, 12, 27, 11, 3).to_i}
+      @c2 = {:symbol => 'eurusd', :timeframe => 'h1', :starts => Time.utc(2010, 12, 27, 12, 0).to_i, :expires => Time.utc(2010, 12, 27, 13, 0).to_i, :updated => Time.utc(2010, 12, 27, 12, 5).to_i}
+      @c3 = {:symbol => 'usdjpy', :timeframe => 'h1', :starts => Time.utc(2010, 12, 27, 12, 0).to_i, :expires => Time.utc(2010, 12, 27, 13, 0).to_i, :updated => Time.utc(2010, 12, 27, 12, 30).to_i}
+      @c4 = {:symbol => 'usdjpy', :timeframe => 'h1', :starts => Time.utc(2010, 12, 27, 13, 0).to_i, :expires => Time.utc(2010, 12, 27, 14, 0).to_i, :updated => Time.utc(2010, 12, 27, 13, 30).to_i}
+
+      @id1 = charts.insert(@c1)
+      @id2 = charts.insert(@c2)
+      @id3 = charts.insert(@c3)
+      @id4 = charts.insert(@c4)
     end
 
-    it 'should search for the latest timestamp in collection' do
-      @manager.collection.should.receive(:find).with({}, :fields => {:updated => 1}, :sort => [['updated', :desc]], :limit => 1).and_return(@cursor)
-      @manager.last_updated.should == Time.at(123)
+    describe 'generalized .find()' do
+      #it 'should pass given query and options to collection#find' do
+        #@mongo.collection.should.receive(:find).with({:symbol => 'eurusd'}, {})
+        #@manager.find({:symbol => 'eurusd'})
+      #end
+
+      it 'should return Cursor object' do
+        cursor = lambda {|obj| obj.is_a? Finexclub::Manager::Cursor}
+        @manager.find(:symbol => 'eurusd').should.be.a cursor
+      end
     end
 
-    it 'should return nil if nothing found' do
-      @manager.collection.stub!(:find).and_return(mock('cursor', :first => nil))
-      @manager.last_updated.should == nil 
+    describe 'find single chart' do
+      describe '.find_one(symbol, tf, time)' do
+        it 'should find a chart given time as Time' do
+          c = @manager.find_one('eurusd', 'h1', Time.utc(2010, 12, 27, 11, 30))
+          c._id.should == @id1
+        end
+
+        it 'should find a chart given symbol, timeframe and time' do
+          c = @manager.find_one('eurusd', 'h1', Time.utc(2010, 12, 27, 11, 30).to_i)
+          c._id.should == @id1
+        end
+
+        it 'should find a chart at present moment (Time.now) by default ' do
+          Timecop.travel(Time.utc(2010, 12, 27, 11, 30))
+          c = @manager.find_one('eurusd', 'h1')
+          Timecop.return
+
+          c._id.should == @id1
+        end
+
+        it 'should return nil given time greather then the last available chart' do
+          @manager.find_one('eurusd', 'h1', Time.utc(2010, 12, 27, 13, 30).to_i).should == nil
+        end
+
+        it 'should return nil if nothing found for given timeframe' do
+          @manager.find_one('eurusd', 'h4').should == nil
+        end
+
+        it 'should return nil if nothing found for given symbol' do
+          @manager.find_one('usdcad', 'h1').should == nil
+        end
+      end
+
+      describe '.find_one_or_create(symbol, tf, time)' do
+        it 'should return existing chart for given symbol, timeframe and time' do
+          c = @manager.find_one_or_create('eurusd', 'h1', Time.utc(2010, 12, 27, 11, 30))
+          c._id.should == @id1
+        end
+
+        #it 'should build valid chart if no chart exists' do
+          #Finexclub::Chart.should.receive(:build_new).with(@core, 'eurusd', 'h1', Time.utc(2010, 12, 27, 13, 5)).and_return(c = mock('chart'))
+          #@manager.find_one_or_create('eurusd', 'h1', Time.utc(2010, 12, 27, 13, 5)).should == c
+        #end
+
+        it 'should create a new chart if no chart exists' do
+          c = @manager.find_one_or_create('eurusd', 'h1', Time.utc(2010, 12, 27, 13, 5))
+          c._id.should.not.be.nil?
+        end
+      end
+
+      describe '.find_latest(symbol, tf)' do
+        it 'should find the latest chart by symbol and timeframe' do
+          c = @manager.find_latest('eurusd', 'h1')
+          c._id.should == @id2
+        end
+
+        it 'should return nil if nothing found for given timeframe' do
+          @manager.find_latest('eurusd', 'h4').should == nil
+        end
+
+        it 'should return nil if nothing found for given symbol' do
+          @manager.find_latest('usdcad', 'h1').should == nil
+        end
+      end
+
+      describe '.last_updated(tf)' do
+        it 'should return timestamp of the latest update through out all symbols for given timeframe' do
+          # it should be @c4, which is usdjpy:h1
+          @manager.last_updated('h1').should == @c4[:updated] 
+        end
+
+        it 'should return nil if no charts found' do
+          @manager.last_updated('h4').should == nil 
+        end
+      end
+
+      describe '.last_updated_at(tf)' do
+        it 'should return Time of the latest collection update' do
+          @manager.last_updated_at('h1').is_a? Time
+          @manager.last_updated_at('h1').should == Time.at(@c4[:updated]).utc
+        end
+
+        it 'should return nil if no charts found' do
+          @manager.last_updated_at('h4').should == nil 
+        end
+      end
+    end
+
+    describe 'find many charts' do
+      describe '.find_many(symbol_or_arr, tf_or_arr, time)' do
+        it 'should find charts given time as Time' do
+          #cur = @manager.find_many(['eurusd', 'usdcad'], 'h1', Time.utc(2010, 12, 27, 12, 40))
+          #cur.count.should == 2 
+          #[ cur[0]._id, cur[1]._id ].should.be.same_as [@id2, @id3]
+          should.flunk
+        end
+      end
+
     end
+    
   end
 
-  describe '.add_signal' do
+  describe 'saving signals' do
     before do
       class Omega < Finexclub::Signal
         field :symbol, :symbol
@@ -66,28 +168,77 @@ describe 'Finexclub::Manager' do
 
         doc_fields :foo, :updated
       end
+      Finexclub::Chart.indicator_handler(:omega, Omega)
+
+      charts = @mongo.collection('charts')
+      charts.drop
+      @c1 = {
+        :symbol => 'eurusd',
+        :timeframe => 'h1',
+        :starts => Time.utc(2010, 12, 27, 11, 0).to_i,
+        :expires => Time.utc(2010, 12, 27, 12, 0).to_i, 
+        :updated => nil,
+        :indicators => {}
+      }
+      @c2 = {
+        :symbol => 'usdcad',
+        :timeframe => 'h1',
+        :starts => Time.utc(2010, 12, 27, 11, 0).to_i,
+        :expires => Time.utc(2010, 12, 27, 12, 0).to_i, 
+        :updated => Time.utc(2010, 12, 27, 11, 3).to_i,
+        :indicators => {
+          :omega => {:foo => "bar", :updated => Time.utc(2010, 12, 27, 11, 3).to_i}
+        }
+      }
+      @id1 = charts.insert(@c1)
+      @id2 = charts.insert(@c2)
     end
 
-    it 'should update collection' do
-      #Mon Oct 04 18:10:20 0700 2010
-      ts = 1286190620
-
-      Finexclub::Signal.stub!(:handler_for).with(:omega).and_return(Omega)
-      @manager.collection.should.receive(:update).with(
-        {
-          :date => '2010-10-04',
-          :timeframe => 'h1',
-          :symbol => 'eurusd'
-        },
-        {
-          "$push" => {:omega => {:foo => "bar", :updated => 1286190620}},
-          "$set" => {:updated => 1286190620}
-        },
-        :upsert => true
-      )
-      
-      Timecop.travel(Time.at(ts))
-      @manager.add_signal(:omega, {"foo" => "bar", "timeframe" => 'h1', "symbol" => "EURUSD"})
+    describe '.add_signal(indicator, raw_params, time)' do
+      it 'should add signal to existing chart' do
+        @manager.add_signal(:omega, {"symbol" => "EURUSD", "timeframe" => "h1", "foo" => "bar"}, Time.utc(2010, 12, 27, 11, 5))
+
+        c = @manager.collection.find_one({"_id" => @id1})
+        c["symbol"].should == 'eurusd'
+        c["timeframe"].should == 'h1'
+        c["starts"].should == Time.utc(2010, 12, 27, 11, 0).to_i
+        c["expires"].should == Time.utc(2010, 12, 27, 12, 0).to_i
+        c["updated"].should == Time.utc(2010, 12, 27, 11, 5).to_i
+        c["indicators"]["omega"].should == {
+          "foo" => "bar",
+          "updated" => Time.utc(2010, 12, 27, 11, 5).to_i
+        }
+      end
+
+      it 'should update existing signal on existing chart' do
+        @manager.add_signal(:omega, {"symbol" => "USDCAD", "timeframe" => "h1", "foo" => "ololo!"}, Time.utc(2010, 12, 27, 11, 30))
+
+        c = @manager.collection.find_one({"_id" => @id2})
+        c["symbol"].should == 'usdcad'
+        c["timeframe"].should == 'h1'
+        c["starts"].should == Time.utc(2010, 12, 27, 11, 0).to_i
+        c["expires"].should == Time.utc(2010, 12, 27, 12, 0).to_i
+        c["updated"].should == Time.utc(2010, 12, 27, 11, 30).to_i
+        c["indicators"]["omega"].should == {
+          "foo" => "ololo!",
+          "updated" => Time.utc(2010, 12, 27, 11, 30).to_i
+        }
+      end
+
+      it 'should add signals to non-existent chart' do
+        @manager.add_signal(:omega, {"symbol" => "EURUSD", "timeframe" => "h4", "foo" => "bar"}, Time.utc(2010, 12, 27, 11, 5))
+
+        c = @manager.collection.find_one({:symbol => 'eurusd', :timeframe => 'h4'})
+        c["symbol"].should == 'eurusd'
+        c["timeframe"].should == 'h4'
+        c["starts"].should == Time.utc(2010, 12, 27, 11, 0).to_i
+        c["expires"].should == Time.utc(2010, 12, 27, 12, 0).to_i
+        c["updated"].should == Time.utc(2010, 12, 27, 11, 5).to_i
+        c["indicators"]["omega"].should == {
+          "foo" => "bar",
+          "updated" => Time.utc(2010, 12, 27, 11, 5).to_i
+        }
+      end
     end
   end
 

data/spec/spec_helper.rb

@@ -25,9 +25,15 @@ class Bacon::Context
     }.merge(extra_stubs)
     )
   end
+  
+  def test_mongo
+    Mongo::Connection.new().db('finexclub_test')
+  end
 
   def test_core
-    Finexclub::Core.send(:new)
+    core = Finexclub::Core.send(:new)
+    Finexclub.signals.db = test_mongo
+    core
   end
 end
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 4
-  - 3
-  version: 0.4.3
+  - 5
+  - 1
+  version: 0.5.1
 platform: ruby
 authors: 
 - Alex Levin
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-20 00:00:00 +07:00
+date: 2011-02-04 00:00:00 +07:00
 default_executable: finexclub_updater
 dependencies: 
 - !ruby/object:Gem::Dependency