finexclub 0.1.1

data/lib/finexclub/manager.rb

@@ -0,0 +1,103 @@
+require "mongo"
+require "ap"
+
+module Finexclub
+  class Manager
+
+    attr_reader :core
+    attr_accessor :db
+
+    def initialize(core)
+      @core = core
+    end
+
+    def collection
+      raise("No db configured") if db.nil?
+      db.collection('charts')
+    end
+
+    def find(query, opts = {})
+      Cursor.new(core, 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
+    end
+
+    def last_updated
+      c = collection.find({}, :fields => {:updated => 1}, :sort => [['updated', :desc]], :limit => 1).first
+      c.nil?? nil : Time.at(c["updated"])
+    end
+
+    def add_signal(signal_type, params)
+      signal = Signal.build(core, signal_type, params.merge(:updated => Time.now))
+      c = {
+        :symbol => signal.symbol,
+        :date => signal.updated_at.strftime("%Y-%m-%d")
+      }
+      collection.update(c, {"$push" => {signal_type => signal.to_doc}, "$set" => {:updated => signal.updated}}, :upsert => true)
+    end
+
+    class Cursor
+      include Enumerable
+      attr_accessor :mongo_cursor
+      attr_reader :core
+      
+      def initialize(core, obj_class, mongo_cursor)
+        @core         = core
+        @obj_class    = obj_class
+        @mongo_cursor = mongo_cursor
+      end
+
+      #def method_missing(name, *args)
+        #@mongo_cursor.send name, *args
+      #end
+      
+      # Is the cursor empty? This method is much more efficient than doing cursor.count == 0
+      def empty?
+        @mongo_cursor.has_next? == false
+      end
+      
+      def next_document
+        if doc = @mongo_cursor.next_document
+          obj = @obj_class.new(core)
+          obj.build(doc)
+          obj
+        end
+      end
+      
+      alias :next :next_document
+      
+      def each
+        @mongo_cursor.each do |doc|
+          obj = @obj_class.new(core)
+          obj.build(doc)
+          yield(obj)
+        end
+      end
+      
+      def current_limit
+        @mongo_cursor.limit
+      end
+      
+      def limit(number_to_return)
+        @mongo_cursor.limit(number_to_return); self
+      end
+      
+      def current_skip
+        @mongo_cursor.skip
+      end
+      
+      def skip(number_to_skip)
+        @mongo_cursor.skip(number_to_skip); self
+      end
+      
+      def sort(key_or_list, direction = nil)
+        @mongo_cursor.sort(key_or_list, direction); self
+      end
+    end
+  end
+end

data/lib/finexclub/signal.rb

@@ -0,0 +1,27 @@
+module Finexclub
+  class Signal
+    include Finexclub::Document
+    attr_reader :core
+
+    def initialize(core, meta = {})
+      @core = core
+      apply_meta(meta)
+    end
+
+    class << self
+      def handler_for(signal_type)
+        #class_name = signal_type.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+        class_name = signal_type.to_s.gsub(/^(.)/) { $1.upcase }
+        Finexclub::Signals.const_get(class_name)
+      end
+
+      def build(core, signal_type, params)
+        signal = handler_for(signal_type).new(core)
+        signal.build(params)
+        signal
+      end
+    end
+
+  end
+end
+

data/lib/finexclub/signals/alpha.rb

@@ -0,0 +1,28 @@
+module Finexclub
+  module Signals
+
+    class Alpha < Signal
+      field :symbol, :symbol
+      field :updated, :timestamp
+      field :index, :integer
+      field :direction, :integer
+
+      doc_fields :updated, :index, :direction
+
+      def trend
+        direction == 1 ? :bullish : :bearish
+      end
+      
+      def stability
+        case index
+          when 100 then :confirmed
+          when 90..99 then :high
+          when 80..89 then :medium
+          when 70..79 then :low
+          else :unstable
+        end
+      end
+    end
+
+  end
+end

data/lib/finexclub/signals/zeta.rb

@@ -0,0 +1,26 @@
+module Finexclub
+  module Signals
+
+    class Zeta < Signal
+      field :symbol, :symbol
+      field :updated, :timestamp
+
+      field :up_support,   :float
+      field :up_resist,    :float
+      field :down_support, :float
+      field :down_resist,  :float
+      field :screenshot,   :image
+
+      doc_fields :up_support, :up_resist, :down_support, :down_resist, :screenshot, :updated
+
+      def up_channel?
+        up_support != 0 && up_resist != 0
+      end
+      
+      def down_channel?
+        down_support != 0 && down_resist != 0
+      end
+    end
+
+  end
+end

data/lib/finexclub.rb

@@ -0,0 +1,45 @@
+# AUTOLOAD EVERYTHING IN THE FINEXCLUB DIRECTORY TREE
+
+# The convention is that dirs are modules
+# so declare them here and autoload any modules/classes inside them
+# All paths here are absolute
+def camelize(path)
+  # e.g. 'test/this_one' => Test::ThisOne
+  "#{path}".
+    chomp('/').
+    gsub('/','::').
+    gsub(/([^a-z])(\w)/){ "#{$1}#{$2.upcase}" }.
+    gsub('_','').
+    sub(/^(\w)/){ $1.upcase }
+end
+def autoload_files_in_dir(path, namespace)
+  # Define the module
+  eval("module #{namespace}; end")
+  # Autoload modules/classes in that module
+  Dir.glob("#{path}/*.rb").each do |file|
+    file = File.expand_path(file)
+    sub_const_name = camelize( File.basename(file, '.rb') )
+    eval("#{namespace}.autoload('#{sub_const_name}', '#{file}')")
+  end
+  # Recurse on subdirectories
+  Dir.glob("#{path}/*/").each do |dir|
+    sub_namespace = camelize( File.basename(dir) )
+    autoload_files_in_dir(dir, "#{namespace}::#{sub_namespace}")
+  end
+end
+
+autoload_files_in_dir("#{File.dirname(__FILE__)}/finexclub", 'Finexclub')
+
+require 'forwardable'
+
+module Finexclub
+  class << self
+    extend Forwardable
+    def_delegators :core, :store, :find, :configure
+    def_delegators :core, :images, :signals
+
+    def core
+      Core.instance
+    end
+  end
+end

data/spec/finexclub/alpha_spec.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'Finexclub::Signals::Alpha' do
+  before do
+    @core = mock_core
+    @alpha = Finexclub::Signals::Alpha.new(@core)
+  end
+
+  it 'should provide attribute accessors' do
+    @alpha.build("direction" => 1, "index" => 100)
+    @alpha.direction.should == 1
+    @alpha.index.should == 100
+  end
+
+  {
+    1 => :bullish,
+    -1 => :bearish,
+    0 => :bearish
+  }.each do |direction, trend|
+    it "should return #{trend} trend when direction is #{direction}" do
+      @alpha.direction = direction
+      @alpha.trend.should == trend
+    end
+  end
+
+  {
+    :confirmed => 100..100,
+    :high => 90..99,
+    :medium => 80..89,
+    :low => 70..79,
+    :unstable => 0..60
+  }.each do |stability, range|
+    it "should return #{stability} stability when index within #{range}" do
+      @alpha.index = range.first
+      @alpha.stability.should == stability
+
+      @alpha.index = range.last
+      @alpha.stability.should == stability
+    end 
+  end
+
+  it 'should export valid doc' do
+    @alpha.build("direction" => 1, "index" => 100, "updated" => 123)
+    @alpha.to_doc.should == {:updated => 123, :index => 100, :direction => 1}
+  end
+end
+

data/spec/finexclub/app_spec.rb

@@ -0,0 +1,89 @@
+ENV['RACK_ENV'] = 'test'
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'rack/test'
+
+include Rack::Test::Methods
+include Finexclub::Fabrication
+
+Finexclub.configure do |f|
+  f.images.screenshot_path = TEST_IMAGES_PATH
+  f.signals.db = Mongo::Connection.new.db("finexclub_test")
+end
+
+def app
+  Finexclub::App
+end
+
+def charts
+  Finexclub.signals.collection
+end
+
+def make_request(url, opts = {})
+  post url, opts 
+  last_response
+end
+
+def date(ts = nil)
+  ts ||= Time.now.utc
+  ts.strftime("%Y-%m-%d")
+end
+
+def alpha_params()
+  params = {}
+  params[:alpha] = Finexclub::Chart::SYMBOLS.inject([]) {|alpha, symbol| alpha << raw_alpha_hash("symbol" => symbol.upcase)}
+  params
+end
+
+def zeta_params(options = {})
+  #options[:symbol] ||= "EURUSD"
+  params = {}
+  params[:zeta] = [raw_zeta_hash(options)]
+  params
+end
+
+describe 'Finexclub::App' do
+  describe 'saving Alpha' do
+    before do
+      charts.remove
+    end
+    
+    it 'should create first signal' do
+      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 == 1
+    end
+
+    it 'should add more alpha signals' do
+      Timecop.travel
+      response = make_request('/alpha', alpha_params)
+      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
+    end
+  end
+  
+  describe 'saving Zeta' do
+    before do
+      charts.remove
+    end
+    
+    it 'should create first zeta signals' do
+      response = make_request('/zeta', zeta_params)
+      response.status.should == 200
+
+      charts.find().count.should == 1
+      charts.find_one(:date => date, :symbol => 'eurusd')["zeta"].size.should == 1
+    end
+  end
+
+  describe 'keep alive ping' do
+  end
+end
+

data/spec/finexclub/chart_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'Finexclub::Chart' do
+  before do
+    @core = mock_core
+    @chart = Finexclub::Chart.new(@core)
+  end
+
+  describe 'Instance' do
+    before do
+      @a1, @a2 = mock('a1'), mock('a2')
+      @z1, @z2 = mock('z1'), mock('z2')
+      @ts = Time.now.to_i
+      
+      chart_doc = {
+        :symbol => 'eurusd',
+        :date => '2010-09-08',
+        :updated => @ts,
+        :alpha => [ @a1, @a2 ],
+        :zeta => [ @z1, @z2 ]
+      }
+      @chart.build(chart_doc)
+    end
+
+    it 'should have attribute accessors' do
+      @chart.symbol.should == 'eurusd'
+      @chart.date.should == '2010-09-08'
+      @chart.updated.should == @ts
+    end
+
+    it 'should return all alpha signals' do
+      @chart.signals(:alpha).should.equal [@a1, @a2]
+    end
+
+    it 'should return all zeta signals' do
+      @chart.signals(:zeta).should.equal [@z1, @z2]
+    end
+
+    it 'should return latest alpha signal as Alpha' do
+      Finexclub::Signal.should.receive(:build).with(@core, :alpha, @a2).and_return(a = mock('alpha'))
+      @chart.alpha.should == a
+    end
+    
+    it 'should return latest zeta signals as Zeta' do
+      Finexclub::Signal.should.receive(:build).with(@core, :zeta, @z2).and_return(z = mock('zeta'))
+      @chart.zeta.should == z
+    end
+  end
+
+end
+

data/spec/finexclub/core_spec.rb

@@ -0,0 +1,91 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'Finexclub::Core' do
+
+  describe '.instance' do
+    it 'should create instance if it does not already exists' do
+      app = Finexclub::Core.instance
+      app.should.be.instance_of Finexclub::Core
+    end
+
+    it 'should return an existing instance' do
+      app = Finexclub::Core.instance
+      Finexclub::Core.instance.should == app
+    end
+
+    it 'should work with Finexclub.core' do
+      Finexclub.core.should == Finexclub::Core.instance
+    end
+  end
+  
+  describe '.new' do
+    it 'should not be callable' do
+      lambda {
+        Finexclub::Core.new
+      }.should.raise(NoMethodError)
+    end
+  end
+
+  describe '.configure' do
+    before do
+      @core = test_core
+    end
+
+    it 'should allow to configure' do
+      @core.configure do |f|
+        f.should == @core
+      end
+    end
+  end
+
+  describe '#images' do
+    before do
+      @core = test_core
+    end
+    it 'should return Images' do
+      @core.images.class.should == Finexclub::Images
+    end
+  end
+
+  describe '#signals' do
+    before do
+      @core = test_core
+    end
+    it 'should return Manager' do
+      @core.signals.class.should == Finexclub::Manager
+    end
+  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 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
+
+end
+