quandl_operation 0.4.1 → 0.4.2.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 72987e8e8aaab8342e2311e9205cb7a3a933510e
+  data.tar.gz: b212ef085932a197ba784ef3e06a011bf4c4b49e
+SHA512:
+  metadata.gz: 415c5c15bd5232bb50866dcd9287fe2476f5d586e743e52d328c688cfd94b80c879019f840063f3c92a88dd89a8dfadc7885a44d7fabca1b5275b22b1f8694a6
+  data.tar.gz: f5a428b56387e30ba758eb0e28a8dc59dd967ef3141f7499d38a5deea63e1a2d76fb459d2d5d8c410b2b1658d45df5308f8e5b9ca8d5c7f5c5010dce2a9dcca3

data/.rubocop.yml

@@ -0,0 +1,19 @@
+AllCops:
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+LineLength:
+  Max: 120
+Style/Documentation:
+  Enabled: false
+Metrics/MethodLength:
+  Max: 40
+Metrics/PerceivedComplexity:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/MethodLength:
+  Max: 100
+Metrics/ClassLength:
+  Max: 180

data/Gemfile

@@ -1,2 +1,2 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 gemspec

data/Guardfile

@@ -1,8 +1,7 @@
 group :specs do
   guard :rspec, cmd: 'bundle exec rspec --fail-fast -f doc --color' do
-      watch(%r{^spec/.+_spec\.rb$})
-      watch(%r{^(lib/.+)\.rb$})                { |m| "spec/#{m[1]}_spec.rb" }
-      watch('spec/spec_helper.rb')             { 'spec' }
+    watch(%r{^spec/.+_spec\.rb$})
+    watch(%r{^(lib/.+)\.rb$})                { |m| "spec/#{m[1]}_spec.rb" }
+    watch('spec/spec_helper.rb')             { 'spec' }
   end
 end
-

data/Rakefile

@@ -1,13 +1,13 @@
-require "bundler"
-require "rake"
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler'
+require 'rake'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
-task :default => :spec
+task default: :spec
 
-desc "Run all specs"
+desc 'Run all specs'
 RSpec::Core::RakeTask.new(:spec) do |task|
-  task.pattern = "spec/**/*_spec.rb"
+  task.pattern = 'spec/**/*_spec.rb'
 end
 
 require 'quandl/utility/rake_tasks'
@@ -16,5 +16,5 @@ Quandl::Utility::Tasks.configure do |c|
   c.version_path      = 'VERSION'
   c.changelog_path    = 'UPGRADE.md'
   c.tag_prefix        = 'v'
-  c.changelog_matching  = ['^QUGC','^WIKI']
+  c.changelog_matching  = ['^QUGC', '^WIKI']
 end

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.4.2.rc1

data/lib/quandl/operation.rb

@@ -1,12 +1,12 @@
 require 'quandl/logger'
 
-require "quandl/operation/version"
+require 'quandl/operation/version'
 
 require 'csv'
 
-require "active_support"
-require "active_support/inflector"
-require "active_support/core_ext/hash"
+require 'active_support'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash'
 
 require 'quandl/operation/core_ext'
 require 'quandl/operation/collapse'
@@ -16,6 +16,6 @@ require 'quandl/operation/qdate'
 require 'quandl/operation/value'
 
 module Quandl
-module Operation
+  module Operation
+  end
 end
-end

data/lib/quandl/operation/collapse.rb

@@ -2,126 +2,130 @@
 require 'quandl/operation/collapse/guess'
 # collapse
 module Quandl
-module Operation
-
-class Collapse
-
-  class << self
-  
-    def perform(data, type)
-      assert_valid_arguments!(data, type)
-      # nothing to do with an empty array
-      return data unless data.compact.present?
-      # source order
-      order = Sort.order?(data)
-      # operations expect data in ascending order
-      data = Sort.asc(data)
-      # collapse
-      data = collapse(data, type)
-      # return to original order
-      data = Sort.desc(data) if order == :desc
-      # onwards
-      data
-    end
-    
-    def assert_valid_arguments!(data, type)
-      raise ArgumentError, "data must be an Array. Received: #{data.class}" unless data.is_a?(Array)
-      raise ArgumentError, "frequency must be one of #{valid_collapses}. Received: #{type}" unless valid?(type)
-    end
-    
-    def valid_collapse?(type)
-      valid?(type)
-    end
-    
-    def valid?(type)
-      valid_collapses.include?( type.try(:to_sym) )
-    end
-    
-    def valid_collapses
-      [ :daily, :weekly, :monthly, :quarterly, :annual ]
-    end
-  
-    def collapse(data, frequency)
-      return data unless valid_collapse?( frequency )
-      # store the new collapsed data
-      collapsed_data = {}
-      range = find_end_of_range( data[0][0], frequency )
-      # iterate over the data
-      data.each do |row|
-        # grab date and values
-        date, value = row[0], row[1..-1]
-        value = value.first if value.count == 1
-        # bump to the next range if it exceeds the current one
-        range = find_end_of_range(date, frequency) unless inside_range?(date, range)
-        # consider the value for the next range
-        if inside_range?(date, range) && value.present?
-          # merge this and previous row if nils are present
-          value = merge_row_values( value, collapsed_data[range] ) unless collapsed_data[range].nil?
-          # assign value
-          collapsed_data[range] = value
+  module Operation
+    class Collapse
+      class << self
+        def perform(data, type)
+          assert_valid_arguments!(data, type)
+          # nothing to do with an empty array
+          return data unless data.compact.present?
+          # source order
+          order = Sort.order?(data)
+          # operations expect data in ascending order
+          data = Sort.asc(data)
+          # collapse
+          data = collapse(data, type)
+          # return to original order
+          data = Sort.desc(data) if order == :desc
+          # onwards
+          data
         end
-      end
-      to_table(collapsed_data)
-    end
-    
-    def to_table(data)
-      data.collect do |date, values|
-        if values.is_a?(Array)
-          values.unshift(date)
-        else
-          [date, values]
+
+        def assert_valid_arguments!(data, type)
+          fail ArgumentError, "data must be an Array. Received: #{data.class}" unless data.is_a?(Array)
+          fail ArgumentError, "frequency must be one of #{valid_collapses}. Received: #{type}" unless valid?(type)
         end
-      end
-    end
-    
-    def merge_row_values(top_row, bottom_row)
-      # merge previous values when nils are present
-      if top_row.is_a?(Array) && top_row.include?(nil)
-        # find nil indexes
-        indexes = find_each_index(top_row, nil)
-        # merge nils with previous values
-        indexes.each{|index| top_row[index] = bottom_row[index] }
-      end
-      top_row
-    end
-    
-    def collapses_greater_than(freq)
-      return [] unless freq.respond_to?(:to_sym)
-      index = valid_collapses.index(freq.to_sym)
-      index.present? ? valid_collapses.slice( index + 1, valid_collapses.count ) : []
-    end
-    
-    def collapses_greater_than_or_equal_to(freq)
-      return [] unless freq.respond_to?(:to_sym)
-      valid_collapses.slice( valid_collapses.index(freq.to_sym), valid_collapses.count )
-    end
-    
-    def frequency?(data)
-      Guess.frequency(data)
-    end
-  
-    def inside_range?(date, range)
-      date <= range
-    end
-  
-    def find_end_of_range(date, frequency)
-      date.end_of_frequency(frequency)
-    end
-  
-    def find_each_index(array, find)
-      found, index, q = -1, -1, []
-      while found
-        found = array[index+1..-1].index(find)
-        if found
-          index = index + found + 1
-          q << index
+
+        def valid_collapse?(type)
+          valid?(type)
+        end
+
+        def valid?(type)
+          valid_collapses.include?(type.try(:to_sym))
+        end
+
+        def valid_collapses
+          [:daily, :weekly, :monthly, :quarterly, :annual]
+        end
+
+        def collapse(data, frequency)
+          return data unless valid_collapse?(frequency)
+
+          # Special scenario where we are only fetching the `date` column
+          date_column_only = data.count > 0 && data[0].count == 1
+
+          # store the new collapsed data
+          collapsed_data = {}
+          range = find_end_of_range(data[0][0], frequency)
+
+          # iterate over the data
+          data.each do |row|
+            # grab date and values
+            date = row[0]
+            value = row[1..-1]
+            value = value.first if value.count == 1
+
+            # bump to the next range if it exceeds the current one
+            range = find_end_of_range(date, frequency) unless inside_range?(date, range)
+
+            # consider the value for the next range
+            next unless inside_range?(date, range) && (value.present? || date_column_only)
+            value = merge_row_values(value, collapsed_data[range]) unless collapsed_data[range].nil?
+            # assign value
+            collapsed_data[range] = value
+          end
+
+          to_table(collapsed_data)
+        end
+
+        def to_table(data)
+          data.collect do |date, values|
+            if values.is_a?(Array)
+              values.unshift(date)
+            else
+              [date, values]
+            end
+          end
+        end
+
+        def merge_row_values(top_row, bottom_row)
+          # merge previous values when nils are present
+          if top_row.is_a?(Array) && top_row.include?(nil)
+            # find nil indexes
+            indexes = find_each_index(top_row, nil)
+            # merge nils with previous values
+            indexes.each { |index| top_row[index] = bottom_row[index] }
+          end
+          top_row
+        end
+
+        def collapses_greater_than(freq)
+          return [] unless freq.respond_to?(:to_sym)
+          index = valid_collapses.index(freq.to_sym)
+          index.present? ? valid_collapses.slice(index + 1, valid_collapses.count) : []
+        end
+
+        def collapses_greater_than_or_equal_to(freq)
+          return [] unless freq.respond_to?(:to_sym)
+          valid_collapses.slice(valid_collapses.index(freq.to_sym), valid_collapses.count)
+        end
+
+        def frequency?(data)
+          Guess.frequency(data)
+        end
+
+        def inside_range?(date, range)
+          date <= range
+        end
+
+        def find_end_of_range(date, frequency)
+          date.end_of_frequency(frequency)
+        end
+
+        def find_each_index(array, find)
+          found = -1
+          index = -1
+          q = []
+          while found
+            found = array[index + 1..-1].index(find)
+            if found
+              index = index + found + 1
+              q << index
+            end
+          end
+          q
         end
       end
-      q
     end
-  
   end
-
-end
 end
-end

data/lib/quandl/operation/collapse/guess.rb

@@ -1,90 +1,84 @@
 module Quandl
-module Operation
-class Collapse
+  module Operation
+    class Collapse
+      class Guess
+        class << self
+          def frequency(data)
+            return :annual unless data && data[0] && data[0][0]
+            # find the smallest point of difference between dates
+            gap = find_average_gap(data)
+            # ensure gap is not negative
+            gap = ensure_positive_gap(gap)
+            # determine the freq from the size of the smallest gap
+            frequency_from_gap(gap)
+          end
 
-class Guess
-  class << self
-  
-    def frequency(data)
-      return :annual unless data && data[0] && data[0][0]
-      # find the smallest point of difference between dates
-      gap = find_average_gap(data)
-      # ensure gap is not negative
-      gap = ensure_positive_gap(gap)
-      # determine the freq from the size of the smallest gap
-      frequency_from_gap(gap)
-    end
-  
-    def find_smallest_gap(data)
-      # init
-      gap = 100_000
-      pdate = nil
-      # find the smallest gap
-      data.each do |row|
-        # if the gap is 1, we're done
-        break if gap <= 1
-        # this row's date
-        date = row[0]
-        # only if pdate is present
-        if pdate
-          # calculate the gap
-          diff = (pdate - date).to_i
-          # replace the previous gap if it is smaller
-          gap = diff if diff < gap
-        end
-        # previous row's date
-        pdate = date
-      end
-      gap
-    end
-  
-    def find_average_gap(data)
-      # init
-      gap = 100_000
-      pdate = nil
-      row_count = data.count
-      majority_count = (row_count * 0.55).to_i
-      gaps = {}
-      # find the smallest gap
-      data.each do |row|
-        # this row's date
-        date = row[0]
-        # only if pdate is present
-        if pdate
-          # calculate the gap
-          diff = (pdate - date).to_i
-          # increment the gap counter
-          gaps[diff] ||= 0
-          gaps[diff] += 1
-          # if the diff count is greater than majority_count, we have a consensus
-          return diff if gaps[diff] > majority_count
-        end
-        # previous row's date
-        pdate = date
-      end
-      gaps.to_a.sort_by{|r| r[1] }.try(:last).try(:first)
-    end
+          def find_smallest_gap(data)
+            # init
+            gap = 100_000
+            pdate = nil
+            # find the smallest gap
+            data.each do |row|
+              # if the gap is 1, we're done
+              break if gap <= 1
+              # this row's date
+              date = row[0]
+              # only if pdate is present
+              if pdate
+                # calculate the gap
+                diff = (pdate - date).to_i
+                # replace the previous gap if it is smaller
+                gap = diff if diff < gap
+              end
+              # previous row's date
+              pdate = date
+            end
+            gap
+          end
 
-    def frequency_from_gap(gap)
-    
-      case 
-      when gap <= 1 then :daily
-      when gap <= 10 then :weekly
-      when gap <= 31 then :monthly
-      when gap <= 93 then :quarterly
-      else :annual
+          def find_average_gap(data)
+            # init
+            pdate = nil
+            row_count = data.count
+            majority_count = (row_count * 0.55).to_i
+            gaps = {}
+            # find the smallest gap
+            data.each do |row|
+              # this row's date
+              date = row[0]
+              # only if pdate is present
+              if pdate
+                # calculate the gap
+                diff = (pdate - date).to_i
+                # increment the gap counter
+                gaps[diff] ||= 0
+                gaps[diff] += 1
+                # if the diff count is greater than majority_count, we have a consensus
+                return diff if gaps[diff] > majority_count
+              end
+              # previous row's date
+              pdate = date
+            end
+            gaps.to_a.sort_by { |r| r[1] }.try(:last).try(:first)
+          end
+
+          def frequency_from_gap(gap)
+            case
+            when gap <= 1 then :daily
+            when gap <= 10 then :weekly
+            when gap <= 31 then :monthly
+            when gap <= 93 then :quarterly
+            else :annual
+            end
+          end
+
+          def ensure_positive_gap(gap)
+            gap = gap.to_i
+            gap *= -1 if gap < 0
+            gap
+          end
+        end
       end
     end
-  
-    def ensure_positive_gap(gap)
-      gap = gap.to_i
-      gap = gap * -1 if gap < 0
-      gap
-    end
-  
   end
-  
-end
-end
 end
-end