quandl 0.2.27 → 0.3.0

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

@@ -0,0 +1,104 @@
+module Quandl
+module Command
+class Task
+
+module Commandable
+  
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :args, :options
+  end
+
+  module ClassMethods
+    
+    def inherited(klass)
+      Quandl::Command::Tasks.tasks << klass unless Quandl::Command::Tasks.tasks.include?(klass)
+      klass.options(@options)
+    end
+    
+    def configure(app)
+      return if disabled?
+      app.command(command_name) do |c|
+        c.syntax = syntax
+        c.description = description
+        c.action{|a,o| call(a,o) }
+        configure_options(c)
+      end
+    end
+    
+    def disabled?
+      @disabled == true
+    end
+    
+    def disable!
+      @disabled = true
+    end
+    
+    def syntax(value=nil)
+      @syntax = value if value.present?
+      @syntax ||= "quandl #{command_name}"
+    end
+    
+    def command_name(value=nil)
+      @command_name = value if value.present?
+      @command_name ||= name.to_s.split("::").last.downcase
+    end
+    
+    def description(value=nil)
+      @description = value if value.present?
+      @description ||= "No description."
+    end
+    
+    def options(value=nil)
+      @options = value if value.present?
+      @options ||= {}
+    end
+    
+    def call(args=[], options={})
+      args = Array(args)
+      options = ensure_options_are_command_options!(options)
+      self.new( args, options ).call
+    end
+    
+    protected
+    
+    def ensure_options_are_command_options!(options)
+      return options if options.class == Commander::Command::Options
+      OpenStruct.new(options)
+    end
+    
+    def configure_options(c)
+      options.each do |class_type, options|
+        options.each do |name, desc|
+          c.option "--#{name} #{class_type.to_s.upcase}", class_type, desc
+        end
+      end
+    end
+    
+  end
+  
+  def call
+    run_callbacks(:execute) do
+      execute
+    end
+  end
+
+  def execute
+    # fire a subcommand if specified
+    return self.send(args.shift) if args.first.present? && self.respond_to?(args.first)
+    # otherwise show syntax
+    puts "  SYNTAX\n\n    #{self.class.syntax}"
+  end
+  
+  def initialize(args, options)
+    self.args = args
+    self.options = options
+  end
+  
+  
+end
+
+end
+end
+end

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

@@ -0,0 +1,79 @@
+module Quandl
+module Command
+class Task
+
+module Configurable
+  
+  extend ActiveSupport::Concern
+
+  included do
+    delegate :auth_token, :quandl_url, to: :config
+  end
+
+  module ClassMethods
+  end
+
+  def declared_params
+    params = {}
+    self.class.options.each do |class_type, opts|
+      opts.each do |name, desc|
+        if options.is_a?(OpenStruct)
+          params[name] = self.options.send(name)
+        else
+          params[name] = self.options[name] if self.options[name].present?
+        end
+      end
+    end
+    params
+  end
+  
+  def verbose?
+    options.verbose == true
+  end
+  
+  def trace?
+    options.trace == true
+  end
+  
+  def confirmed?
+    return true if force_yes?
+    ask_for_confirmation!
+  end
+  
+  def force_yes?
+    options.force_yes == true
+  end
+  
+  def ask_for_confirmation!
+    ['y','yes'].include?( ask("Are you sure? (y/n)") )
+  end
+  
+  def page
+    @page ||= options.page.to_i || 1
+  end
+  
+  def config
+    @config ||= Quandl::Command::Config.new( config_options )
+  end
+  
+  protected
+  
+  def config_options
+    opts = { file_path: config_file_path }
+    opts.merge!(options.to_h) if options.to_h.present?
+    opts
+  end
+  
+  def config_file_path
+    File.join( ENV['HOME'], '.quandl', config_profile )
+  end
+  
+  def config_profile
+    options.environment || 'config'
+  end
+
+end
+
+end
+end
+end

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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,83 @@
+module Quandl
+module Command
+class Task
+
+module Logging
+  
+  extend ActiveSupport::Concern
+
+  included do
+    before_execute :start_request_timer
+    before_execute :configure_logger
+    after_execute :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

@@ -0,0 +1,37 @@
+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)
+    debug("output_format: #{format}")
+    format
+  end
+  
+end
+
+end
+end
+end

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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,117 @@
+module Quandl
+module Command
+class Task
+
+module Threading
+  
+  extend ActiveSupport::Concern
+
+  included do
+    
+    before_execute :shutdown_thread_pool_on_sigint
+    
+    after_execute :shutdown_thread_pool_uninterruptedly!
+    
+  end
+
+  module ClassMethods
+  end
+  
+  def shutdown_thread_pool_on_sigint
+    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
+    options.threads.to_i || 1
+  end
+  
+  def exiting?
+    threads? && thread_pool.shutdown?
+  end
+  
+  protected
+  
+  def shutdown_thread_pool_uninterruptedly!
+    return false unless Thread.respond_to?(:pool)
+    thread_pool.shutdown unless exiting?
+  end
+  
+end
+
+end
+end
+end