quandl 0.4.4 → 1.0.0.rc1

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

@@ -1,37 +0,0 @@
-module Quandl
-module Command
-class Task
-
-module Inputable
-  
-  extend ActiveSupport::Concern
-
-  included do
-  end
-
-  module ClassMethods
-  end
-  
-  def each_line_in_background(args, &block)
-    args.each_line do |arg|
-      background_job do
-        block.call( arg )
-      end
-    end
-  end
-  
-  def args_or_stdin
-    return args.join("\n") if args.first.present?
-    $stdin
-  end
-  
-  def file_or_stdin
-    return File.open( args.first, 'r' ) if args.first.present?
-    $stdin
-  end
-
-end
-
-end
-end
-end

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

@@ -1,83 +0,0 @@
-module Quandl
-module Command
-class Task
-
-module Logging
-  
-  extend ActiveSupport::Concern
-
-  included do
-    before_call :start_request_timer
-    before_execute :configure_logger
-    after_call :log_request_time
-    
-    attr_accessor :request_timer
-    
-  end
-  
-  def start_request_timer
-    self.request_timer = Time.now
-  end
-  
-  def configure_logger
-    @stderr_logger = initialize_logger(config.stderr) if config.stderr.present?
-    @stdout_logger = initialize_logger(config.stdout) if config.stdout.present?
-  end
-  
-  def initialize_logger(path)
-    l = ::Logger.new( path, 2, 52428800 )
-    l.formatter = proc do |severity, datetime, progname, msg|
-      "# [#{datetime.strftime("%Y-%m-%d %H:%M:%S")}]\n#{msg}"
-    end
-    l
-  end
-  
-  def log_request_time
-    debug("Started: #{request_timer}. Finished: #{Time.now}. Elapsed: #{request_timer.elapsed_ms}")
-  end
-  
-  def summarize(item)
-    return summarize_hash(item) if item.kind_of?(Hash)
-    item
-  end
-  
-  def summarize_hash(item)
-    item.collect do |k,v|
-      next "#{k}: '#{v}'" if v.kind_of?(String)
-      "#{k}: #{v}"
-    end.join(', ')
-  end
-  
-  def table(*args)
-    Array(args).flatten.join(" | ")
-  end
-  
-  def info(*args)
-    logger.info(*args)
-  end
-
-  def debug(*args)
-    args.each{|a| logger.debug("# #{a}") } if verbose?
-  end
-
-  def error(*args)
-    stderr_logger.error(*args)
-  end
-
-  def fatal(*args)
-    stderr_logger.fatal("FATAL: #{args.join(" ")}")
-  end
-
-  def logger
-    @stdout_logger ||= Quandl::Logger
-  end
-  
-  def stderr_logger
-    @stderr_logger ||= Quandl::Logger
-  end
-  
-end
-
-end
-end
-end

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

@@ -1,36 +0,0 @@
-module Quandl
-module Command
-class Task
-
-module Presentation
-  
-  extend ActiveSupport::Concern
-  
-  def present(object, opts={})
-    opts = opts.symbolize_keys!
-    opts.reverse_merge!(options.to_h) if options.to_h.present?
-    presenters = Quandl::Command::Presenter.new( object, opts )
-    # format order of importance
-    format = get_output_format( opts )
-    # convert each object to_format and write to stdout
-    presenters.each do |presenter|
-      # write requested format to stdout
-      info( presenter.to_format(format) )
-      # write errors to stderr
-      error( presenter.to_stderr ) unless presenter.valid?
-    end
-  end
-  
-  private
-  
-  def get_output_format(override={})
-    format = options.output_format || config.output_format || override[:output_format] || 'pipes'
-    format = 'pipes' unless %w{ pipes json qdf }.include?(format.to_s)
-    format
-  end
-  
-end
-
-end
-end
-end

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

@@ -1,35 +0,0 @@
-module Quandl
-module Command
-class Task
-
-module Reportable
-  
-  extend ActiveSupport::Concern
-  
-  included do
-    before_execute :ask_to_send_crash_reports
-  end
-  
-  def ask_to_send_crash_reports
-    if config.send_crash_reports.nil?
-      status = ['y','yes'].include? ask("Do you want to send crash reports if toolbelt fails? (y/n)").to_s.strip.rstrip.downcase
-      config.send_crash_reports = status
-    end
-  end
-  
-  def call
-    begin
-      super
-    rescue Exception => err
-      if config.send_crash_reports == true
-        Quandl::Client::Report.create( message: err.to_s, full_message: err.backtrace ) rescue nil
-      end
-      raise $!, "#{$!}", $!.backtrace
-    end
-  end
-  
-end
-
-end
-end
-end

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

@@ -1,123 +0,0 @@
-module Quandl
-module Command
-class Task
-
-module Threading
-  
-  extend ActiveSupport::Concern
-
-  included do
-    
-    before_execute :force_load_json_support
-    before_execute :shutdown_thread_pool_on_sigint
-    
-    after_execute :shutdown_thread_pool_uninterruptedly!
-    
-  end
-
-  module ClassMethods
-  end
-  
-  def shutdown_thread_pool_on_sigint
-    debug("starting up with #{threads} threads")
-    return unless threads?
-    trap('SIGINT') do
-      debug "exit signal received"
-      unless thread_pool.shutdown?
-        debug "waiting for executing jobs to finish"
-        thread_pool.shutdown
-      end
-      debug "exiting now"
-      exit
-    end
-  end
-  
-  def background_job(*args, &block)
-    # dont execute jobs when shutdown signaled
-    return false if exiting?
-    # options
-    opts = args.extract_options!.symbolize_keys!
-    key = opts[:lock]
-    # without threads process in foreground
-    return block.call unless threads?
-    # process with pool
-    job = thread_pool.process do
-      # wait for lock
-      await_thread_pool_lock!(key) if key.present?
-      # if this key is locked
-      block.call
-      # unlock
-      release_thread_pool_lock(key) if key.present?
-    end
-    # onwards
-    job
-  end
-  
-  def mutex
-    @mutex ||= Mutex.new
-  end
-  
-  def await_thread_pool_lock!(key)
-    got_lock = false
-    # try to get a lock
-    mutex.synchronize do
-      unless thread_pool_locked?(key)
-        obtain_thread_pool_lock(key)
-        got_lock = true
-      end
-    end
-    # try again unless lock was obtained
-    if !got_lock
-      sleep(0.05)
-      await_thread_pool_lock!(key)
-    end
-  end
-  
-  def thread_pool
-    @thread_pool ||= Thread.pool( threads )
-  end
-  
-  def obtain_thread_pool_lock(key)
-    thread_pool_locks[key] = true
-  end
-  
-  def release_thread_pool_lock(key)
-    thread_pool_locks.delete(key)
-  end
-  
-  def thread_pool_locked?(key)
-    thread_pool_locks[key] == true
-  end
-  
-  def thread_pool_locks
-    @thread_pool_locks ||= {}
-  end
-  
-  def threads?
-    threads > 1
-  end
-  
-  def threads
-    @threads ||= options.threads.present? ? options.threads.to_i : 10
-  end
-  
-  def exiting?
-    threads? && thread_pool.shutdown?
-  end
-  
-  def force_load_json_support
-    { force_load: true }.to_json rescue nil
-  end
-  
-  protected
-  
-  def shutdown_thread_pool_uninterruptedly!
-    return false unless Thread.respond_to?(:pool)
-    thread_pool.shutdown unless exiting?
-  end
-  
-end
-
-end
-end
-end

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

@@ -1,37 +0,0 @@
-module Quandl
-module Command
-class Task
-
-module Translations
-  
-  extend ActiveSupport::Concern
-
-  included do
-    
-  end
-
-  module ClassMethods
-    
-    def t(key)
-      key = key.to_s
-      translation = lang
-      key.split('.').each{|m| translation = translation.respond_to?(m) ? translation.send(m) : nil }
-      translation
-    end
-    
-    def lang
-      @lang ||= Quandl::Lang.send(language).quandl.command.tasks.send(command_name)
-    end
-    
-    def language
-      # stub
-      'en'
-    end
-    
-  end
-  
-end
-
-end
-end
-end

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

@@ -1,80 +0,0 @@
-module Quandl
-module Command
-class Task
-
-module Updatable
-  
-  extend ActiveSupport::Concern
-  
-  VERSION_URL="https://s3.amazonaws.com/quandl-command/VERSION"
-  
-  included do
-    before_execute :check_for_update_once_daily
-  end
-  
-  def check_for_update_once_daily
-    # short circuit
-    return if options.sandbox
-    # onwards
-    check_time = config.last_checked_for_update
-    # check time present?
-    if check_time.present? && check_time.is_a?(Time)
-      # has it been more than one day?  
-      check_for_update if Time.now - 1.day > check_time || check_time > Time.now
-    else
-      check_for_update
-    end
-  end
-  
-  def check_for_update
-    # notify user of impending update check
-    print("# Checking for updates ... ")
-    # lazy load dependencies since this happens infrequently
-    require_check_for_update_dependencies
-    # build request
-    http, request = prepare_update_request
-    # send request
-    response = send_update_request(http, request)
-    # handle output
-    handle_update_response(response)
-  rescue => err
-    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
-  
-  private
-  
-  def require_check_for_update_dependencies
-    require 'uri'
-    require 'net/http'
-    require 'open-uri'
-  end
-  
-  def prepare_update_request
-    uri = URI.parse( VERSION_URL )
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.use_ssl = true
-    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    [ http, Net::HTTP::Get.new(uri.request_uri) ]
-  end
-  
-  def send_update_request(http, request)
-    # send request
-    response = http.request(request)
-    # fetch version number
-    response.body.strip.rstrip
-  end
-  
-  def handle_update_response(response)
-    return info(" you are up to date! #{response}") if Quandl::Command::VERSION == response
-    # otherwise they are out of sync
-    info(" A new version of quandl toolbelt has been released. #{response}. Please run 'quandl update'")
-  end
-  
-end
-
-end
-end
-end

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

@@ -1,25 +0,0 @@
-module Quandl
-module Command
-class Task
-
-module Validations
-  
-  extend ActiveSupport::Concern
-
-  included do
-    before_execute :run_task_validations!
-  end
-
-  def run_task_validations!
-    unless valid?
-      debug("run_task_validations! valid? false")
-      error( table(errors.full_messages) )
-      false
-    end
-  end
-  
-end
-
-end
-end
-end