quandl 0.3.7 → 0.4.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZDJmODE5YjMxZDJlNjFiNTZiN2I0NmVhMGYzMTIwZjU2YWFjZDIyYQ==
+    MWZhODVmN2E1YzI4MTVhNDdlZDBjNmExOWUzNDYzMDM3M2IwNTNhMw==
   data.tar.gz: !binary |-
-    NDEwZmVhNGQ2YWE1YmYwYzM5ODZhY2I5MDI4N2Y5YjU1MmMyOWU0Mw==
+    ZTNhZmQ0OGI3MmNiNzQyZTQxYTA5YzYzMjQzMzcyN2QxNDVmMWNiOA==
 SHA512:
   metadata.gz: !binary |-
-    ZDE4YjcyM2Y0MTExMDE1MTYzZmY5ZDE1YzAzMTU1NmNhNzY0YTdiMmUwZjdj
-    NzhiMjVjYmI4MWY5YzU5Y2U1NjE1MzRlZDU3ZDc5NmIwNDRlZTczNWQ4ODE5
-    ODBlMDg1MzYzM2EyYmFlMzA5NmIzN2M5ZDJiZDNjOTUyZGI1YWE=
+    MDI5MjJhNDQwZjU5YTE1MmU0YTJjN2FiNDAwYWFkNmY2YTA2NTk3YzQ4ZTM5
+    OTIyYzAzZjhmNjYyNjJiYWNiYzBjOTgwMzA2OTkzZGIxMzkwOGVhODU0MGY1
+    MmEzNmZmZGZjZjJhZTA1ZmFhZGU2MjhhZTcwYzM1YmUwMDhkMDc=
   data.tar.gz: !binary |-
-    YWYzYTViMWEzZjIxMTMzYzJhOWJjMDY3NDQ3NjdlYzhkMzAxMGJmZGFiNTkw
-    MGRmM2Y3ODk4NzZlYjJiNDA0YmM4MzM5ODU2MTUwMTc0MWZiMTI0MDBiNjEw
-    ZWZjNWNhN2UxN2ZiYzhmZWYwYjQxYTI5YzEzYjFkNTdjYTNmMTg=
+    MDM2MDRhOTRlMTkzN2I4ZTJlZGI0MGEwNGExMjVmNGE5MzdkMzYzOWRmN2Uy
+    Zjk1MDRlOTJkNmZjZTVjYmJmODRiNTE5MzczNDhlMGE4OTExMjI1NTQ0OGI4
+    ODBiMzA4ZjNjOTFjOWEzNTllMTU1ZTc2YzVhZDU0Zjc2YzRhMDY=

data/Rakefile

@@ -12,10 +12,6 @@ Dir[File.expand_path("../tasks/*.rake", __FILE__)].each do |task|
   load task
 end
 
-task :console do |t,args|
-  binding.pry
-end
-
 desc "Run all specs"
 RSpec::Core::RakeTask.new(:spec) do |task|
   task.pattern = "spec/**/*_spec.rb"

data/UPGRADE.md

@@ -1,3 +1,11 @@
+## 0.4.0 
+
+* QUGC-166 fix quandl schedule list --token incorrect_token
+* QUGC-182. OK -> Updated
+* QUGC-164 fixes the issue
+
+
+
 ## 0.3.7 
 
 * add production flag

data/VERSION

@@ -1 +1 @@
-0.3.7
+0.4.0

data/dist/resources/pkg/Distribution.erb

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <installer-script minSpecVersion="1.000000" authoringTool="org.ruby-lang.rake" authoringToolVersion="10.1.1">
-  <title>Quandl Toolbelt <%= version %></title>
+  <title>Quandl Toolbelt <%= version %> <%= prerelease_information %></title>
   <options customize="allow" allow-external-scripts="no"/>
   <domains enable_localSystem="true"/>
   <choices-outline>

data/dist/resources/pkg/{postinstall → postinstall.erb}

@@ -42,4 +42,6 @@ case $(which quandl) in
 esac
 
 # symlink binary to /usr/bin/quandl
-ln -sf /usr/local/quandl/bin/quandl /usr/bin/quandl
+ln -sf /usr/local/quandl/releases/<%= timestamp %> /usr/local/quandl/current
+chown -h $USER /usr/local/quandl/current
+ln -sf /usr/local/quandl/bin/quandl /usr/bin/quandl

data/dist/resources/pkg/quandl

@@ -5,7 +5,7 @@ require "pathname"
 bin_file = Pathname.new(__FILE__).realpath
 
 # vendored gems path
-gem_dir = File.expand_path("../../vendor/gems", bin_file)
+gem_dir = File.expand_path("../../current/vendor/gems", bin_file)
 # vendored gems?
 if Dir.exists?(gem_dir)
   Dir["#{gem_dir}/**/lib"].each do |libdir|
@@ -16,7 +16,7 @@ else
 end
 
 # add self to libpath
-$:.unshift File.expand_path("../../lib", bin_file)
+$:.unshift File.expand_path("../../current/lib", bin_file)
 
 require 'quandl/command'
 require 'commander/import'

data/dist/resources/windows/quandl

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require "pathname"
+bin_file = Pathname.new(__FILE__).realpath
+
+# vendored gems path
+gem_dir = File.expand_path("../../current/vendor/gems", bin_file)
+# vendored gems?
+if Dir.exists?(gem_dir)
+  Dir["#{gem_dir}/**/lib"].each do |libdir|
+    $:.unshift libdir
+  end
+else
+  require 'rubygems'
+end
+
+# add self to libpath
+$:.unshift File.expand_path("../../current/lib", bin_file)
+
+require 'quandl/command'
+require 'commander/import'
+require 'commander/command/quandl_ext'
+
+include Quandl::Command

data/lib/quandl/command.rb

@@ -38,7 +38,7 @@ module Quandl::Command
     global_option '--stdout STRING', 'where to redirect stdout'
     global_option '--stderr STRING', 'where to redirect stderr'
     global_option '--force-yes', 'force y/n with yes'
-    global_option '--production', 'skip extra output'
+    global_option '--sandbox', 'sandbox specific default options'
     
     Tasks.each{|t| t.configure(self) }
     

data/lib/quandl/command/config.rb

@@ -44,6 +44,10 @@ class Config
     @auth_token = read_attribute(:token) if @auth_token.blank?
     @auth_token
   end
+
+  def request_platform
+    'sandbox' if options[:sandbox].present?
+  end
   
   def file_path
     options[:file_path]

data/lib/quandl/command/task/configurable.rb

@@ -7,7 +7,7 @@ module Configurable
   extend ActiveSupport::Concern
 
   included do
-    delegate :auth_token, :quandl_url, to: :config
+    delegate :auth_token, :request_platform, :quandl_url, to: :config
   end
 
   module ClassMethods

data/lib/quandl/command/task/dependable.rb

@@ -61,6 +61,7 @@ module Dependable
     Quandl::Client.token = auth_token
     Quandl::Client.request_source = 'quandl_command'
     Quandl::Client.request_version = Quandl::Command::VERSION
+    Quandl::Client.request_platform = request_platform
   end
   
 end

data/lib/quandl/command/task/updatable.rb

@@ -6,7 +6,7 @@ module Updatable
   
   extend ActiveSupport::Concern
   
-  VERSION_URL="https://raw.github.com/quandl/quandl_command/master/lib/quandl/command/version.rb"
+  VERSION_URL="https://s3.amazonaws.com/quandl-command/VERSION"
   
   included do
     before_execute :check_for_update_once_daily
@@ -14,7 +14,7 @@ module Updatable
   
   def check_for_update_once_daily
     # short circuit
-    return if options.production
+    return if options.sandbox
     # onwards
     check_time = config.last_checked_for_update
     # check time present?
@@ -38,8 +38,8 @@ module Updatable
     # handle output
     handle_update_response(response)
   rescue => err
-    error("An unexpected error occured while checking for updates ... #{err}")
-    error err.backtrace.join("\n") if trace?
+    info("An unexpected error occured while checking for updates ... #{err}")
+    info err.backtrace.join("\n") if trace?
   ensure
     config.last_checked_for_update = Time.now
   end
@@ -64,7 +64,7 @@ module Updatable
     # send request
     response = http.request(request)
     # fetch version number
-    response.body.split("\n").detect{|r| r =~ /VERSION/ }.split("'").last
+    response.body.strip.rstrip
   end
   
   def handle_update_response(response)

data/lib/quandl/command/tasks/schedule.rb

@@ -1,34 +1,30 @@
 class Quandl::Command::Tasks::Schedule < Quandl::Command::Task
 
-  depends 'chronic', 'whedon', 'open-uri'
+  depends 'chronic', 'whedon', 'open-uri', 'zlib', 'archive/tar/minitar'
   
   autoload_quandl_client
   authenticated_users_only!
   
   description "Schedule a script to be run in the quandl cloud."
-  syntax %{quandl schedule command [file]
+  syntax %{quandl schedule command [file(s)]
 
   COMMANDS:
   
-    schedule list      [file]
-    schedule add       file  [--at TIME]
-    schedule delete    file
-    schedule replace   file  [--at NEW_TIME]
-    
+    schedule list      [FILE]
+    schedule add       RUN_FILE [DEPENDENT_FILE1] [DEPENDENT_FILE2] [--at TIME]
+    schedule delete    FILE
+
   EXAMPLES:
   
     $ quandl schedule add scraper.rb
     You have successfully scheduled scraper.rb.
 
-    $ quandl schedule add scraper.rb --remote-name scraper.rb --at "7pm Monday"
-    You have successfully scheduled scraper.rb. [weekly scraper]
-  
-    $ quandl schedule replace scraper.rb --at "13:00"
-    You have successfully replaced scraper.rb. [daily scraper]}
-    
+    $ quandl schedule add scraper.rb helper.txt helper2.txt --at "7pm Monday"
+    You have successfully scheduled scraper.rb to run alongside helper.txt, helper2.txt. [weekly scraper]
+  }
+
   options({
     String => {
-      :'remote-name' =>            "The name used to reference your scraper in the quandl cloud.",
       at:              "Time to run your script in UTC timezone. e.g. '14:30','7pm Monday', 'friday 13:00'"
     }
   })
@@ -41,7 +37,7 @@ class Quandl::Command::Tasks::Schedule < Quandl::Command::Task
     # fire a subcommand if specified
     return self.send(args.shift) if args.first.present? && self.respond_to?(args.first)
     # otherwise fire add
-    return add if args.first.present?
+    return add if args.first.present? && args.first.downcase != "help"
     # otherwise display syntax
     info(syntax)
   end
@@ -56,18 +52,24 @@ class Quandl::Command::Tasks::Schedule < Quandl::Command::Task
   end
 
   def add
-    result=Quandl::Client::Scraper.create( name: name, scraper: args.first, schedule_at: cron_at_utc)
-    if result.valid?
-      info("You have successfully scheduled '#{scraper.name}'.")
-      info("#{schedule_message}")
-    else
-      error "#{Quandl::Command::Presenter.pretty_errors(result.errors.messages).to_s.gsub("\n", ' ')}"
+    upload_file = Tempfile.new('temp')
+    begin
+      result=Quandl::Client::Scraper.create( name: name, scraper: file_to_send(args, upload_file), schedule_at: cron_at_utc)
+      if result.valid?
+        info("You have successfully scheduled '#{scraper.name}'.")
+        info("#{schedule_message}")
+      else
+        error "#{Quandl::Command::Presenter.pretty_errors(result.errors.messages).to_s.gsub("\n", ' ')}"
+      end
+    ensure
+      upload_file.close!
     end
   end
   
   def download
     begin
-      $stdout << open(scraper.scraper_url, {ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE}).read
+      $stdout.binmode
+      $stdout << open(scraper.scraper_url, "rb", {ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE}).read
     rescue => err
       present err
     end
@@ -87,44 +89,41 @@ class Quandl::Command::Tasks::Schedule < Quandl::Command::Task
   end
 
 
+  #not supported for now
+=begin
   def replace
-    (info("'#{name}' does not exist "); return;) if scraper.blank?
-    info("You are about to replace '#{scraper.name}'")
-    return unless confirmed?
-    scraper.scraper = args.first
-    scraper.schedule_at = cron_at_utc
-    scraper.save
-    if scraper.valid?
-      info("You have successfully replaced '#{scraper.name}'.")
-      info("#{schedule_message}") if cron_at
-    else
-      error "#{Quandl::Command::Presenter.pretty_errors(scraper.errors.messages).to_s.gsub("\n", ' ')}"
+    upload_file = Tempfile.new('temp')
+    begin
+      (info("'#{name}' does not exist "); return;) if scraper.blank?
+      info("You are about to replace '#{scraper.name}'")
+      return unless confirmed?
+      scraper.scraper = file_to_send(args, upload_file)
+      scraper.schedule_at = cron_at_utc
+      scraper.save
+      if scraper.valid?
+        info("You have successfully replaced '#{scraper.name}'.")
+        info("#{schedule_message}") if cron_at
+      else
+        error "#{Quandl::Command::Presenter.pretty_errors(scraper.errors.messages).to_s.gsub("\n", ' ')}"
+      end
+    ensure
+      upload_file.close!
     end
   end
+=end
   
   private
 
   def script_info(script)
-    unless script.schedule_at.empty?
-      info("#{(script.name+'.').ljust(20)} Scheduled: #{script_run_time(script.schedule_at)}")
-    else
-      info("#{(script.name+'.').ljust(20)} Scheduled: 3 times a day")
-    end
-  end
-
-  
-  def script_run_time(cron_time)
-    "every #{cron_time.ends_with?('*') ? 'day' : DAYS_OF_THE_WEEK[cron_time[-1].to_i]} at #{script_next_run(cron_time).strftime("%H:%M (UTC)")}"
-  end
-
-  def script_next_run(cron_time)
-    Whedon::Schedule.new(cron_time).next
+    message = script.name.to_s.ljust(20)
+    message += " Scheduled: #{script.schedule_run_time.to_s.ljust(30)}"
+    message += " Next: in #{script.schedule_next}" if script.schedule_next.present?
+    info message
   end
 
-
   def schedule_message
     if options.at
-      "Your script first run will happen #{script_next_run(cron_at).strftime("on %d %B at %H:%M")}. It will continue to run #{script_run_time(cron_at_utc)}
+      "Your script first run will happen in #{scraper.schedule_next}. It will continue to run #{scraper.schedule_run_time}
 Check your scrapers run status at #{quandl_url.gsub(/\/api\/?/,'')}/scrapers"
     else
       "It will run 3 times a day starting immediately.\nCheck your scrapers run status at #{quandl_url.gsub(/\/api\/?/,'')}/scrapers"
@@ -159,11 +158,10 @@ Check your scrapers run status at #{quandl_url.gsub(/\/api\/?/,'')}/scrapers"
 
   def time_to_cron(time_value)
     day_of_the_week = options.at =~ (/Mon|Tue|Wed|Thu|Fri|Sat|Sun/i) ? time_value.wday : '*'
-    "#{time_value.min} #{time_value.hour} * * #{day_of_the_week}"
+    "* #{time_value.min} #{time_value.hour} * * #{day_of_the_week}"
   end
 
   def name
-    return options.remote_name if options.remote_name.present?
     return File.basename(args.first) if args.first.present?
   end
 
@@ -175,5 +173,15 @@ Check your scrapers run status at #{quandl_url.gsub(/\/api\/?/,'')}/scrapers"
     true
   end
 
+  def file_to_send(values, upload_file)
+    if [*values].count > 1
+      file = upload_file
+      Archive::Tar::Minitar.pack( values, Zlib::GzipWriter.new( File.new( file, 'wb' ) ) )
+    else
+      file = [*values].first
+    end
+    file
+  end
+
 
 end

data/lib/quandl/command/tasks/update.rb

@@ -1,8 +1,6 @@
 class Quandl::Command::Tasks::Update < Quandl::Command::Task
     
   depends 'uri', 'net/http', 'quandl/utility/config', 'zlib', 'archive/tar/minitar'
-    
-  # curl -s https://s3.amazonaws.com/quandl-command/install.sh | bash
   
   description "Update Quandl Toolbelt to the latest version."
   syntax %Q{quandl update [revision]
@@ -10,12 +8,12 @@ class Quandl::Command::Tasks::Update < Quandl::Command::Task
     EXAMPLES:
 
       $ quandl update
-      Updating from 0.2.18 ...
-      You are up to date! ( 0.3.1 )
+      Updating from a.b.c ...
+      You are up to date! ( x.y.z )
 
-      $ quandl update beta1
-      Updating from 0.3.1 ...
-      You are up to date! ( 0.3.1-beta1 )}
+      $ quandl update prerelease
+      Updating from x.y.z ...
+      You are up to date! ( x.y.z-prerelease )}
       
   PACKAGE_URL = 'http://s3.amazonaws.com/quandl-command/'
   
@@ -33,6 +31,22 @@ class Quandl::Command::Tasks::Update < Quandl::Command::Task
   end
   
   def execute
+    if args[0] == 'rollback'
+      execute_rollback
+    else
+      execute_update
+    end
+  rescue => err
+    # log error
+    error(err)
+    debug(err.backtrace.join("\n"))
+    # report failure and rollback
+    error("----\nAn error has occured! Rolling back to previous version ... ")
+    error("If the problem persists reinstall with: #{installer_url}")
+    rollback_update
+  end
+  
+  def execute_update
     info "Updating from #{Quandl::Command::VERSION} ... "
     # wipe update/ and backup/ folders
     prepare_for_update
@@ -41,22 +55,26 @@ class Quandl::Command::Tasks::Update < Quandl::Command::Task
     return error("'#{package_url}' not found") unless File.exists?(tarball_path)
     # install
     extract_tarball
-    copy_windows_specific_files if Quandl::Utility::Config.windows?
     install_update
-    configure_update
-    ensure_correct_permissions
+    install_executable
     # success
     version = %x{quandl -v}.to_s.strip.rstrip
-    info "You are up to date! ( #{version} )"
+    cleanup_releases
     
-  rescue => err
-    # log error
-    info(err)
-    debug(err.backtrace.join("\n"))
-    # report failure and rollback
-    info("----\nAn error has occured! Rolling back to previous version ... ")
-    info("If the problem persists reinstall with: #{installer_url}")
-    rollback_update
+    info "You are up to date! ( #{version} )"
+  end
+  
+  def execute_rollback
+    info "Rolling back from #{current_timestamp} ... "
+    previous_timestamp = find_timestamp_before(current_timestamp)
+    if previous_timestamp.blank?
+      info("nothing to rollback to!")
+      return false 
+    end
+    info "to: #{previous_timestamp}"
+    install_timestamp( previous_timestamp )
+    version = %x{quandl -v}.to_s.strip.rstrip
+    info "You have rolled back! ( #{version} )"
   end
   
   def installer_url
@@ -64,40 +82,12 @@ class Quandl::Command::Tasks::Update < Quandl::Command::Task
     return File.join(PACKAGE_URL, "quandl-toolbelt.pkg") if Quandl::Utility::Config.macosx?
   end
   
-  def package_path
-    @package_path ||= File.join(update_path, "quandl-command")
-  end
-  
-  def tarball_path
-    @tarball_path ||= File.join(update_path, "update.tar.gz")
-  end
-  
-  def package_url
-    @package_url ||= self.class.package_url(args.first)
-  end
-  
-  def update_path
-    @update_path ||= File.join( root_path, 'update' )
-  end
-  
-  def backup_path
-    @backup_path ||= File.join( root_path, 'backup' )
-  end
-  
-  def root_path
-    Quandl::Command::Tasks.root
-  end
+  private
   
+  delegate :chmod, :cp, :ln_sf, :mv, :rm_rf, :rm, :mkdir_p, :cp_r, to: :qu
   
-  private
-
   def prepare_for_update
-    [backup_path, update_path].each do |path|
-      # remove previous directory if present
-      rm_rf(path) if Dir.exists?(path)
-      # create new directory
-      mkdir_p(path) unless Dir.exists?(path)
-    end
+    FileUtils.mkdir_p(releases_path) unless Dir.exists?(releases_path)
   end
   
   def download_tarball
@@ -114,82 +104,146 @@ class Quandl::Command::Tasks::Update < Quandl::Command::Task
   end
   
   def extract_tarball
-    debug "Archive::Tar::Minitar.unpack( '#{tarball_path}', '#{update_path}' )"
-    # extract into update_path
-    Archive::Tar::Minitar.unpack( Zlib::GzipReader.open(tarball_path), update_path )
+    debug "Archive::Tar::Minitar.unpack( '#{tarball_path}', '#{releases_path}' )"
+    # extract into releases_path
+    Archive::Tar::Minitar.unpack( Zlib::GzipReader.open(tarball_path), releases_path )
+    # rename quandl-command to release name
+    mv( package_path, timestamp_path )
   end
   
-  def copy_windows_specific_files
-    files = ['bin/quandl.bat']
-    files.each do |file|
-      source_path = File.join(root_path, file)
-      cp source_path, File.join(package_path, file) if File.exists?(source_path)
-    end
+  def install_update
+    install_timestamp(new_timestamp)
   end
   
-  def install_update
-    debug "Installing '#{update_path}' to '#{root_path}'"
-    # install each folder into the live directory
-    Dir.glob(File.join(package_path, "/*")) do |update_dir|
-      # current folder
-      folder_name = File.basename(update_dir)
-      # get live dir
-      live_dir = File.join(root_path, folder_name )
-      # move live to backup (skip this step if it doesn't exist since it might be a new folder)
-      mv live_dir, File.join(backup_path, folder_name) if File.exists?(live_dir)
-      # move update to live
-      mv update_dir, live_dir
+  def rollback_update
+    # remove the failed release
+    rm_rf(timestamp_path) if Dir.exists?(timestamp_path)
+    # install previous release
+    install_timestamp(current_timestamp)
+  end
+  
+  def install_executable
+    new_executable = File.join(timestamp_path, 'pkg', 'quandl')
+    return unless File.exists?(new_executable)
+    rm executable_path if File.exists?(executable_path)
+    cp new_executable, executable_path
+  end
+  
+  def install_timestamp(stamp)
+    # remove previous
+    rm_rf(current_path) if File.exists?(current_path)
+    # install timestamp
+    path = File.join( releases_path, stamp.to_s )
+    # copy or link
+    if Quandl::Utility::Config.windows?
+      cp_r(path, current_path)
+      
+    else
+      ln_sf(path, current_path)
+      
     end
+    update_current_timestamp(stamp)
   end
   
-  def configure_update
-    if Dir.exists?("#{root_path}/ruby")
-      bin_file = File.read("#{root_path}/bin/quandl")
-      bin_file.gsub!("#!/usr/bin/env ruby", "#!/#{root_path}/ruby/bin/ruby")
-      File.write("#{root_path}/bin/quandl", bin_file)
-    end 
+  def update_current_timestamp(stamp)
+    File.open( timestamp_release_path, 'wb' ){|f| f.write(stamp.to_s) }
   end
   
-  def rollback_update
-    Dir.glob(File.join(backup_path, "/*")) do |backup_dir|
-      # current folder
-      folder_name = File.basename(backup_dir)
-      # get live dir
-      live_dir = File.join(root_path, folder_name )
-      # move live to update
-      mv live_dir, File.join(package_path, folder_name)
-      # move backup to live
-      mv backup_dir, live_dir
-    end
+  def delete_timestamp(stamp)
+    path = File.join(releases_path, stamp.to_s)
+    rm_rf(path) if Dir.exists?(path)
+  end
+  
+  def cleanup_releases
+    return unless release_timestamps.count > 5
+    release_timestamps.reverse[5..-1].each{|stamp| delete_timestamp(stamp) }
+  end
+  
+  def executable_path
+    @executable_path ||= File.join(root_path, 'bin', 'quandl')
   end
   
-  def ensure_correct_permissions
-    chmod("+x", File.join(root_path, 'bin/quandl'))
+  def timestamp_release_path
+    @timestamp_release_path ||= File.join(root_path, '.timestamp')
   end
   
-  def chmod(*args)
-    debug("FileUtils.chmod #{args.to_a.join(' ')}")
-    FileUtils.chmod(*args)
+  def timestamp_path
+    @timestamp_path ||= File.join( releases_path, new_timestamp )
+  end
+  
+  def tarball_path
+    @tarball_path ||= File.join(releases_path, "update.tar.gz")
+  end
+  
+  def package_path
+    @package_path ||= File.join(releases_path, "quandl-command")
+  end
+  
+  def releases_path
+    @releases_path ||= File.expand_path(File.join( root_path, 'releases' ))
+  end
+  
+  def package_url
+    @package_url ||= self.class.package_url(args.first)
+  end
+  
+  def current_path
+    @current_path ||= File.join(root_path, 'current')
+  end
+  
+  def root_path
+    return @root_path if defined?(@root_path)
+    parent_root = File.expand_path(File.join(Quandl::Command::Tasks.root, '../'))
+    if Dir.exists?(File.join(parent_root, 'releases')) && Dir.exists?(File.join(parent_root, 'bin'))
+      @root_path = parent_root
+    else
+      @root_path = Quandl::Command::Tasks.root
+    end
+    @root_path
   end
 
-  def cp(old_path, new_path)
-    debug("FileUtils.cp #{old_path} #{new_path}")
-    FileUtils.cp( old_path, new_path )
+  def new_timestamp
+    @new_timestamp ||= (Time.now.getutc.to_f * 10000).to_i.to_s.gsub('.','')
+  end
+  
+  def find_timestamp_before(stamp)
+    release_timestamps.sort.each do |rstamp|
+      return rstamp if rstamp.to_i < stamp.to_i
+    end
+    nil
+  end
+  
+  def current_timestamp
+    # largest to smallest
+    @current_timestamp ||= File.read(timestamp_release_path).strip.rstrip.to_i if File.exists?(timestamp_release_path)
+    @current_timestamp ||= release_timestamps.sort.reverse.detect{|t| t < new_timestamp.to_i }
   end
   
-  def mv(old_path, new_path)
-    debug("FileUtils.mv #{old_path} #{new_path}")
-    FileUtils.mv( old_path, new_path )
+  def release_timestamps
+    @release_timestamps ||= Dir["#{releases_path}/*"].select{|f| File.directory?(f) }.collect{|f| File.basename(f).to_i }
   end
   
-  def rm_rf(*args)
-    debug( "FileUtils.rm_rf #{args.to_a.join(" ")}")
-    FileUtils.rm_rf(*args)
+  def qu
+    @qu ||= QuandlUtils.new(self)
   end
   
-  def mkdir_p(*args)
-    debug( "FileUtils.mkdir_p #{args.to_a.join(" ")}")
-    FileUtils.mkdir_p(*args)
+  class QuandlUtils
+    attr_accessor :task
+    
+    def initialize(task=nil)
+      self.task = task
+    end
+    
+    def method_missing(method_name, *args, &block)
+      fu(method_name, *args, &block)
+    end
+    
+    private
+    
+    def fu(method_name, *args, &block)
+      task.debug("#{method_name} #{args}") unless task.nil?
+      FileUtils.send(method_name, *args, &block)
+    end
   end
   
 end