quandl_cassandra 0.3.1 → 1.0.0

data/lib/quandl/cassandra_models/dataset/columns.rb

@@ -1,61 +0,0 @@
-module Quandl::Cassandra::Dataset::Columns
-  
-  extend ActiveSupport::Concern
-  
-  included do
-    # define_attributes :column_ids
-    before_save :save_columns
-
-  end
-  
-  module ClassMethods
-
-    def find_column_ids_by_id(id)
-      Quandl::Cassandra::Dataset.where( id: id ).pluck(:column_id, :position).sort_by{|r| r[1] }.collect{|r| r[0] }
-    end
-    
-  end
-  
-  def column_attributes=(column_attrs)
-    column_attrs.each_with_index do |attrs, index|
-      self.columns[index] ||=  Quandl::Cassandra::Column.new
-      self.columns[index].assign_attributes(attrs)
-    end
-  end
-
-  def column_units
-    @column_units ||= columns.collect(&:unit)
-  end
-
-  def column_names
-    @column_names ||= columns.collect(&:name)
-  end
-
-  def columns
-    return @columns if @columns
-    # find columns
-    columns = Quandl::Cassandra::ColumnAttribute.where( id: column_ids ).all
-    # build column where column_id was not found
-    @columns = column_ids.collect{|cid| columns.detect{|c| c.id.to_s == cid.to_s } || Quandl::Cassandra::ColumnAttribute.new( id: cid ) }
-  end
-
-  def column_ids
-    @column_ids ||= id.blank? ? [] : self.class.find_column_ids_by_id(id)
-  end
-
-
-  protected
-  
-  def clear_attributes!
-    @columns = nil
-    @column_ids = nil
-  end
-  
-  
-  private
-  
-  def save_columns
-    columns.each(&:save)
-  end
-  
-end

data/lib/quandl/cassandra_models/dataset_attribute.rb

@@ -1,6 +0,0 @@
-class Quandl::Cassandra::DatasetAttribute < Quandl::Cassandra::Base
-
-  table_name :dataset_attributes
-  define_attributes :id, :type, :updated_at, :created_at, :frequency
-  
-end

data/lib/quandl/cassandra_models/multiset.rb

@@ -1,50 +0,0 @@
-class Quandl::Cassandra::Multiset < Quandl::Cassandra::Dataset
-  
-  table_name :datasets
-  
-  define_attributes :datasets_columns
-  
-  class << self
-    
-    def with_columns(datasets_columns)
-      self.new( datasets_columns: datasets_columns )
-    end
-    
-  end
-  
-  def data_scope
-    Quandl::Cassandra::Data.collapse(:source).column_ids( column_ids ).column_frequencies( column_frequencies )
-  end
-  
-  def column_frequencies
-    @column_frequencies ||= columns.collect(&:frequency)
-  end
-  
-  def column_ids
-    @column_ids ||= column_ids_from_datasets_columns
-  end
-  
-  def column_ids_from_datasets_columns
-    ids = []
-    datasets_columns.to_s.split(',').each do |dataset_column|
-      dataset_id, column = dataset_column.split('.')
-      datasets[dataset_id] ||= Quandl::Cassandra::Dataset.find(dataset_id).try(:column_ids)
-      ids << datasets[dataset_id][ column.to_i - 1 ] if datasets[dataset_id].is_a?(Array)
-    end
-    ids
-  end
-  
-  def datasets
-    @datasets ||= {}
-  end
-  
-  def frequency
-    data.frequency
-  end
-  
-  def dataset_attribute
-    # find or initialize dataset attribute object
-    @dataset_attribute ||= Quandl::Cassandra::DatasetAttribute.new
-  end
-  
-end

data/spec/factories/dataset.rb

@@ -1,8 +0,0 @@
-FactoryGirl.define do
-
-  factory :dataset, class: Quandl::Cassandra::Dataset do
-    sequence(:id) { |n| "#{(Time.now.to_f * 1000).to_i}#{n}".to_i } 
-    data { Quandl::Fabricate::Data.rand( rows: 60, columns: 4, nils: false ).to_csv }
-  end
-
-end

data/spec/lib/quandl/cassandra_models/column/write/group_data_by_frequency_spec.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Quandl::Cassandra::Column::Write::GroupDataByFrequency do
-
-  let(:data){ Quandl::Fabricate::Data.rand( columns: 4, rows: 12, nils: false, frequency: :weekly ) }
-  let(:strategy){ Quandl::Cassandra::Column::Write::GroupDataByFrequency.new({ data: data }) }
-  
-  describe "#frequency_data" do
-    subject{ strategy.frequency_data }
-    its(:length){ should eq 4 }
-    
-    it "should have source" do
-      subject[:source].count.should eq 12
-    end
-    it "should have monthly" do
-      subject[:monthly].count.should <= 4
-    end
-    it "should have quarterly" do
-      subject[:quarterly].count.should <= 2
-    end
-    it "should have annual" do
-      subject[:annual].count.should eq 1
-    end
-    
-  end
-  
-end

data/spec/lib/quandl/cassandra_models/column/write_spec.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Quandl::Cassandra::Column::Write do
-
-  let(:id){ rand(10000*10000) + 10000*10000 }
-  let(:data){ Quandl::Fabricate::Data.rand( columns: 4, rows: 12, nils: false, frequency: :weekly ) }
-  
-  it "should not alter the original data" do
-    source_data = data.to_a.collect{|r| r.clone }
-    r = Quandl::Cassandra::Column.write( id: id, data: data )
-    data.should eq source_data
-  end
-  
-  context "given tiny data array" do
-    let(:data){ Quandl::Fabricate::Data.rand( columns: 1, rows: 2, nils: false ) }
-    before(:each){ Quandl::Cassandra::Column.write( id: id, data: data ) }
-    it "should have written the data" do
-      Quandl::Cassandra::Column.read( id: id ).should eq data
-    end
-  end
-  
-end

data/spec/lib/quandl/cassandra_models/column_attribute_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Quandl::Cassandra::ColumnAttribute do
-  
-  let(:id){ rand(10000*10000) + 10000*10000 }
-  let(:data){ Quandl::Fabricate::Data.rand( rows: 10, columns: 2 ) }
-  let(:dataset){ Quandl::Cassandra::Dataset.create( id: id, data: data ) }
-  
-  let(:column){ Quandl::Cassandra::ColumnAttribute.find(dataset.column_ids.first) }
-  
-  subject{ column }
-  
-  its(:id){ should eq dataset.column_ids.first }
-  its(:frequency){ should eq 'daily' }
-  
-end

data/spec/lib/quandl/cassandra_models/column_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Quandl::Cassandra::Column do
-  
-  let(:id){ rand(10000*10000) + 10000*10000 }
-  let(:data){ Quandl::Fabricate::Data.rand( rows: 10, columns: 2, nils: false ) }
-  let(:dataset){ Quandl::Cassandra::Dataset.create( id: id, data: data ) }
-  
-  describe ".read" do
-    before(:each){ Quandl::Cassandra::Column.write( id: id, data: data ); sleep(0.2) }
-    
-    subject{ Quandl::Cassandra::Column.read( id: id ) }
-    its(:count){ should eq 10 }
-    it{ should eq data }
-  end
-  
-end

data/spec/lib/quandl/cassandra_models/data_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-describe Quandl::Cassandra::Data do
-
-  let(:id){ rand(10000*10000) + 10000*10000 }
-  let(:data){ Quandl::Fabricate::Data.rand(rows: 10, columns: 2, nils: false) }
-  let(:dataset){ Quandl::Cassandra::Dataset.create( id: id, data: data ) }
-  subject{ Quandl::Cassandra::Data }
-  
-  [:row, :id, :limit, :offset, :column, :accuracy, :frequency, :column_ids,
-    :collapse, :transform, :order, :trim_start, :trim_end ].each do |name|
-    it{ should respond_to name }
-  end
-  
-  describe "#collapse" do
-    it "should become annual" do
-      scope = subject.collapse(:annual)
-      scope.attributes[:collapse].should eq :annual
-    end
-    it "should become annual given string" do
-      scope = subject.collapse('annual')
-      scope.attributes[:collapse].should eq :annual
-    end
-    it "should become monthly" do
-      scope = subject.collapse(:monthly)
-      scope.attributes[:collapse].should eq :monthly
-    end
-    it "should become weekly" do
-      scope = subject.collapse('weekly')
-      scope.attributes[:collapse].should eq :weekly
-    end
-  end
-    
-  describe "#trim_start" do
-    
-    subject{ dataset.data }
-    
-    context "given invalid date" do
-        
-      it "rejects string" do
-        subject.trim_start('invalid').attributes[:trim_start].should be_nil
-      end
-        
-    end
-      
-    context "given valid date" do
-        
-      it "accepts string" do
-        subject.trim_start('1980-01-01').attributes[:trim_start].should eq Date.parse('1980-01-01').jd
-      end
-        
-      it "accepts julian date" do
-        subject.trim_start( Date.today.jd ).attributes[:trim_start].should eq Date.today.jd
-      end
-        
-    end
-      
-  end
-    
-  describe "#trim_end" do
-    
-    subject{ dataset.data }
-    
-    context "given invalid date" do
-        
-      it "rejects string" do
-        subject.trim_end('invalid').attributes[:trim_end].should be_nil
-      end
-        
-    end
-    context "given valid date" do
-        
-      it "accepts string" do
-        subject.trim_end('1980-01-01').attributes[:trim_end].should eq Date.parse('1980-01-01').jd
-      end
-        
-      it "accepts julian date" do
-        subject.trim_end( Date.today.jd ).attributes[:trim_end].should eq Date.today.jd
-      end
-        
-    end
-  end
-    
-end

data/spec/lib/quandl/cassandra_models/dataset/collapse_spec.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Quandl::Cassandra::Dataset do
-  
-  let(:dataset){ create(:dataset) }
-  subject { dataset }
-  
-  it "should have columns" do
-    subject.columns.count.should eq 4
-  end
-  
-  describe "#data" do
-    
-    subject{ dataset.data }
-    
-    its(:class){ should eq Quandl::Cassandra::Data::ScopeScope }
-    
-    its(:to_date){ should be_present }
-    its(:to_h){ should be_present }
-    
-    it "should have data" do
-      subject.count.should eq 60
-    end
-  
-    it "should collapse to daily" do
-      subject.collapse(:daily).count.should eq 60
-    end
-  
-    it "should collapse to weekly" do
-      subject.collapse(:weekly).count.should be < 12
-    end
-  
-    it "should collapse to monthly" do
-      subject.collapse(:monthly).count.should be < 4
-    end
-
-    it "should collapse to annual" do
-      subject.collapse(:annual).count.should eq 1
-    end
-  
-  end
-
-end

data/spec/lib/quandl/cassandra_models/dataset/column_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Quandl::Cassandra::Dataset do
-  
-  context "column" do
-    
-    subject { create(:dataset) }
-    
-    it "should return first column" do
-      subject.data.column(1)[0][1].should eq subject.data.scoped.to_table[0][1]
-    end
-    
-    it "should return second column" do
-      subject.data.column(2)[0][1].should eq subject.data.scoped.to_table[0][2]
-    end
-    
-    it "should return third column" do
-      subject.data.column(2)[0][1].should eq subject.data.scoped.to_table[0][2]
-    end
-    
-  end
-  
-end

data/spec/lib/quandl/cassandra_models/dataset/persistence_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Quandl::Cassandra::Dataset do
-  
-  let(:data){ Quandl::Fabricate::Data.rand( rows: 4, columns: 4, nils: false ) }
-  let(:dataset){ create( :dataset, data: data ) }
-  
-  subject{ dataset }
-  
-  its(:dataset_attribute){ should be_a DatasetAttribute }
-  its(:trim_start){ should eq Date.jd(Dataset.find(dataset.id).data[-1][0]) }
-  its(:trim_end){ should eq Date.jd(Dataset.find(dataset.id).data[0][0]) }
-  its(:updated_at){ should_not be_nil }
-  
-  context "after save" do
-    before(:each){ 
-      @previously_updated_at = subject.updated_at
-      subject.save 
-    }
-    its(:updated_at){ should_not eq @previously_updated_at }
-  end
-  
-end

data/spec/lib/quandl/cassandra_models/dataset/row_spec.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Quandl::Cassandra::Dataset do
-  
-  let(:data){ Quandl::Fabricate::Data.rand( rows: 216, columns: 2, frequency: :weekly, nils: false ).to_csv }
-  let(:dataset){ create( :dataset, data: data ) }
-  subject { dataset }
-  
-  it "should be monthly" do
-    subject.frequency.should eq 'weekly'
-  end
-  
-  it "should pluck the second row" do
-    subject.data.scoped.collapse(:monthly).row(1).to_a.should eq [subject.data.scoped.collapse(:monthly)[1]]
-  end
-  
-  it "should collapse and pluck the second year" do
-    subject.data.scoped.collapse(:annual).row(2).to_a.should eq [subject.data.scoped.collapse(:annual)[2]]
-  end
-  
-  it "should collapse and pluck the second year with a transformation" do
-    subject.data.scoped.collapse(:annual).transform(:rdiff).row(2).to_a.should eq [subject.data.scoped.collapse(:annual).transform(:rdiff)[2]]
-  end
-  
-end

data/spec/lib/quandl/cassandra_models/dataset/transform_spec.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Dataset do
-  
-  let(:data){ Quandl::Data.new([ [1002, 10], [1001, 20], [1000, 30] ]) }
-  let(:dataset){ build(:dataset) }
-
-  it "should cumul data" do
-    dataset.data = data
-    dataset.save!
-    cumul_data = Dataset.find(dataset.id).data.transform(:cumul).to_table.data_array
-    cumul_data.should eq [ [1002, 60.0], [1001, 50.0], [1000, 30.0] ]
-  end
-  
-end