birdwatcher 0.1.0

data/lib/birdwatcher/concerns/util.rb

@@ -0,0 +1,138 @@
+module Birdwatcher
+  module Concerns
+    module Util
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+      end
+
+      # Get the relative time for a timestamp
+      #
+      # @param time [Time] Timestamp to be converted
+      #
+      # @example getting relative time of a status
+      #     status = current_workspace.statuses.last
+      #     output time_ago_in_words(status.posted_at)
+      #     #=> "1 day and 15 hours ago"
+      #
+      # @return [String] relative time in words
+      def time_ago_in_words(time)
+        Birdwatcher::Util.time_ago_in_words(time)
+      end
+
+      # Natural language parsing of time
+      #
+      # @param time [String] A string representing a time (e.g. "yesterday at 4:00")
+      #
+      # Uses the Chronic gem to perform natural language parsing of time.
+      # See the examples in Chronic's documentation for strings that can be parsed.
+      #
+      # All modules that can be configured with times, should perform natural
+      # language parsing on the option setting for better user experience.
+      #
+      # @return [Time]
+      # @see https://github.com/mojombo/chronic
+      # @see https://github.com/mojombo/chronic#examples
+      def parse_time(time)
+        Birdwatcher::Util.parse_time(time)
+      end
+
+      # Correct pluralization of word depending on count
+      #
+      # @param count [Integer] The amount
+      # @param singular [String] The singular word
+      # @param plural [String] The plural word
+      #
+      # pluralizes the singular word unless count is 1.
+      #
+      # @example
+      #     pluralize(1, "user", "users")
+      #     #=> "1 user"
+      #
+      #     pluralize(5, "user", "users")
+      #     #=> "5 users"
+      #
+      #     pluralize(0, "user", "users")
+      #     #=> "0 users"
+      def pluralize(count, singular, plural)
+        Birdwatcher::Util.pluralize(count, singular, plural)
+      end
+
+      # Strip out HTML tags from a string
+      #
+      # @param string [String] String to strip HTML tags from
+      #
+      # @return [String] HTML stripped string
+      def strip_html(string)
+        Birdwatcher::Util.strip_html(string)
+      end
+
+      # Strip out control characters and color codes from a string
+      #
+      # @param string [String] String to strip control characters from
+      #
+      # @return [String] String without control characters
+      def strip_control_characters(string)
+        Birdwatcher::Util.strip_control_characters(string)
+      end
+
+      # Escape special HTML characters with HTML entities
+      #
+      # @param string [String] String to HTML escape
+      #
+      # @return [String] HTML escaped string
+      def escape_html(string)
+        Birdwatcher::Util.escape_html(string)
+      end
+
+      # Unescape special HTML characters in a string
+      #
+      # @param string [String] String to unescape
+      #
+      # @return [String] string with escaped special HTML characters unescaped
+      def unescape_html(string)
+        Birdwatcher::Util.unescape_html(string)
+      end
+
+      # Create an excerpt of potentially long text at a fixed length
+      #
+      # @param text [String] Text to excerpt
+      # @param max_length [Integer] Maximum length of text before being excerpted
+      # @param omission [String] OPTIONAL: String to append to text if excerpted
+      #
+      # @example
+      #     excerpt("The quick brown fox jumps over the lazy dog", 80)
+      #     #=> "The quick brown fox jumps over the lazy dog"
+      #
+      #     excerpt("The quick brown fox jumps over the lazy dog", 40)
+      #     #=> "The quick brown fox jumps over the lazy d..."
+      #
+      # @return [String] excerpted text
+      def excerpt(text, max_length, omission = "...")
+        Birdwatcher::Util.excerpt(text, max_length, omission)
+      end
+
+      # Suppress any potential output to STDOUT
+      #
+      # Used in cases where certain libraries or methods might output unwanted
+      # text to +STDOUT+ without any possibility of disabling it.
+      #
+      # @param block code block to run with output suppression
+      def suppress_output(&block)
+        Birdwatcher::Util.suppress_output(&block)
+      end
+
+      # Suppress any warning messages to STDOUT
+      #
+      # Used in cases where certain libraries or methods might output unwanted
+      # warning messages to +STDOUT+.
+      #
+      # @param block code block to run with warning suppression
+      def suppress_warnings(&block)
+        Birdwatcher::Util.suppress_warnings(&block)
+      end
+    end
+  end
+end

data/lib/birdwatcher/configuration.rb

@@ -0,0 +1,63 @@
+module Birdwatcher
+  class Configuration
+    include Singleton
+
+    CONFIGURATION_FILE_NAME     = ".birdwatcherrc".freeze
+    CONFIGURATION_FILE_LOCATION = File.join(Dir.home, CONFIGURATION_FILE_NAME).freeze
+
+    class Error < StandardError; end
+    class ConfigurationFileNotFound < Error; end
+    class ConfigurationFileNotReadable < Error; end
+    class ConfigurationFileCorrupt < Error; end
+    class UnknownKey < Error; end
+
+    def self.get!(key)
+      self.instance.get!(key)
+    end
+
+    def self.get(key)
+      self.instance.get!(key)
+    rescue Birdwatcher::Configuration::UnknownKey
+      nil
+    end
+
+    def self.configured?
+      File.exist?(CONFIGURATION_FILE_LOCATION)
+    end
+
+    def self.save!(configuration)
+      File.open(CONFIGURATION_FILE_LOCATION, "w") do |f|
+        f.write(YAML.dump(configuration))
+      end
+    end
+
+    def self.load!
+      self.instance.load_configuration!
+    end
+
+    def load_configuration!
+      if !File.exist?(CONFIGURATION_FILE_LOCATION)
+        fail ConfigurationFileNotFound, "Configuration file does not exist"
+      end
+      if !File.readable?(CONFIGURATION_FILE_LOCATION)
+        fail ConfigurationFileNotReadable, "Configuration file is not readable"
+      end
+      @configuration = YAML.load_file(CONFIGURATION_FILE_LOCATION).inject({}) { |memo, (k,v)| memo[k.to_sym] = v; memo }
+    rescue ::Psych::SyntaxError => e
+      raise ConfigurationFileCorrupt, "Configuration file contains invalid YAML"
+    end
+
+    def get!(key)
+      key = key.to_sym
+      fail(UnknownKey, "Unknown configuration key: #{key}") unless configuration.key?(key)
+      configuration[key.to_sym]
+    end
+
+    private
+
+    def configuration
+      load_configuration! unless @configuration
+      @configuration
+    end
+  end
+end

data/lib/birdwatcher/configuration_wizard.rb

@@ -0,0 +1,65 @@
+module Birdwatcher
+  class ConfigurationWizard
+    def start!
+      configuration = gather_configuration
+    end
+
+    private
+
+    def gather_configuration
+      Birdwatcher::Console.instance.info("Starting configuration wizard.\n")
+      configuration = {
+        "database_connection_uri" => gather_database_connection_uri,
+        "twitter"                 => gather_twitter_keys,
+        "klout"                   => gather_klout_keys
+      }
+      Birdwatcher::Configuration.save!(configuration)
+      Birdwatcher::Console.instance.newline
+      Birdwatcher::Console.instance.info("Configuration saved to #{Birdwatcher::Configuration::CONFIGURATION_FILE_LOCATION.bold}")
+    end
+
+    def gather_database_connection_uri
+      hostname = HighLine.ask("Enter PostgreSQL hostname: ") do |q|
+        q.default = "localhost"
+      end
+      port = HighLine.ask("Enter PostgreSQL port: |5432| ", Integer) do |q|
+        q.default = 5432
+        q.in = 1..65_535
+      end
+      username = HighLine.ask("Enter PostgreSQL username: ") do |q|
+        q.default = "birdwatcher"
+      end
+      password = HighLine.ask("Enter PostgreSQL password (masked): ") do |q|
+        q.echo = "x"
+      end
+      database = HighLine.ask("Enter PostgreSQL database name: ") do |q|
+        q.default = "birdwatcher"
+      end
+      "postgres://#{username}:#{password}@#{hostname}:#{port}/#{database}"
+    end
+
+    def gather_twitter_keys
+      keys = []
+      begin
+        consumer_key    = HighLine.ask("Enter Twitter consumer key: ")
+        consumer_secret = HighLine.ask("Enter Twitter consumer secret: ")
+        keys << {
+          "consumer_key"    => consumer_key,
+          "consumer_secret" => consumer_secret
+        }
+      end while HighLine.agree("Enter another Twitter keypair? (y/n) ")
+      keys
+    end
+
+    def gather_klout_keys
+      keys = []
+      puts "\nKlout access tokens can be used by modules to gather additional information on Twitter users."
+      if HighLine.agree("Do you want to enter Klout access tokens? (y/n) ")
+        begin
+          keys << HighLine.ask("Enter Klout access token: ")
+        end while HighLine.agree("Enter another Klout access token? (y/n) ")
+      end
+      keys
+    end
+  end
+end

data/lib/birdwatcher/console.rb

@@ -0,0 +1,201 @@
+module Birdwatcher
+  class Console
+    include Singleton
+
+    DEFAULT_AUTO_COMPLETION_STRINGS = [].freeze
+    DB_MIGRATIONS_PATH = File.expand_path("../../../db/migrations", __FILE__).freeze
+    LINE_SEPARATOR = ("=" * 80).freeze
+
+    attr_accessor :current_workspace, :current_module
+    attr_reader :database
+
+    def initialize
+      @output_mutex = Mutex.new
+    end
+
+    def start!
+      print_banner
+      bootstrap!
+      Readline.completion_proc = proc do |s|
+        expanded_s = File.expand_path(s)
+        Birdwatcher::Console.instance.auto_completion_strings.grep(/\A#{Regexp.escape(s)}/) + Dir["#{expanded_s}*"].grep(/^#{Regexp.escape(expanded_s)}/)
+      end
+      Readline.completion_append_character = ""
+      while input = Readline.readline(prompt_line, true)
+        input = input.to_s.strip
+        handle_input(input) unless input.empty?
+      end
+    end
+
+    def handle_input(input)
+      input.strip!
+      command_name, argument_line = input.split(" ", 2).map(&:strip)
+      command_name.downcase
+      commands.each do |command|
+        next unless command.has_name?(command_name)
+        command.new.execute(argument_line)
+        return true
+      end
+      error("Unknown command: #{command_name.bold}")
+      false
+    end
+
+    def auto_completion_strings
+      if !@auto_completion_strings
+        @auto_completion_strings = DEFAULT_AUTO_COMPLETION_STRINGS
+        commands.each { |c| @auto_completion_strings += c.auto_completion_strings }
+        @auto_completion_strings += Birdwatcher::Module.module_paths
+      end
+      @auto_completion_strings
+    end
+
+    def output(data, newline = true)
+      data = "#{data}\n" if newline
+      with_output_mutex { print data }
+    end
+
+    def output_formatted(*args)
+      with_output_mutex { printf(*args) }
+    end
+
+    def newline
+      with_output_mutex { puts }
+    end
+
+    def line_separator
+      output LINE_SEPARATOR
+    end
+
+    def info(message)
+      output "[+] ".bold.light_blue + message
+    end
+
+    def task(message, fatal = false, &block)
+      output("[+] ".bold.light_blue + message, false)
+      yield block
+      output " done".bold.light_green
+    rescue => e
+      output " failed".bold.light_red
+      error "#{e.class}: ".bold + e.message
+      exit(1) if fatal
+    end
+
+    def error(message)
+      output "[-] ".bold.light_red + message
+    end
+
+    def warn(message)
+      output "[!] ".bold.light_yellow + message
+    end
+
+    def fatal(message)
+      output "[-]".white.bold.on_red + " #{message}"
+    end
+
+    def twitter_client
+      if !@twitter_clients
+        @twitter_clients = create_twitter_clients!
+      end
+      @twitter_clients.sample
+    end
+
+    def klout_client
+      if !@klout_clients
+        @klout_clients = create_klout_clients!
+      end
+      @klout_clients.sample
+    end
+
+    private
+
+    def print_banner
+      output " ___ _        _             _      _\n" \
+             "| _ |_)_ _ __| |_ __ ____ _| |_ __| |_  ___ _ _\n" \
+             "| _ \\ | '_/ _` \\ V  V / _` |  _/ _| ' \\/ -_) '_|\n" \
+             "|___/_|_| \\__,_|\\_/\\_/\\__,_|\\__\\__|_||_\\___|_|\n".bold.light_blue +
+             "                       v#{Birdwatcher::VERSION} by " + "@michenriksen\n".bold
+    end
+
+    def bootstrap!
+      bootstrap_configuration!
+      bootstrap_database!
+      newline
+    end
+
+    def bootstrap_configuration!
+      if !Birdwatcher::Configuration.configured?
+        Birdwatcher::ConfigurationWizard.new.start!
+      end
+      task "Loading configuration...", true do
+        Birdwatcher::Configuration.load!
+      end
+    end
+
+    def bootstrap_database!
+      task "Preparing database...", true do
+        Sequel.extension :migration, :core_extensions
+        @database = Sequel.connect(configuration.get!(:database_connection_uri))
+        Sequel::Migrator.run(@database, DB_MIGRATIONS_PATH)
+        Sequel::Model.db = @database
+        Sequel::Model.plugin :timestamps
+        bootstrap_models!
+        load_default_workspace!
+      end
+    end
+
+    def bootstrap_models!
+      Dir[File.join(File.dirname(__FILE__), "..", "..", "models", "*.rb")].each do |file|
+        require file
+      end
+    end
+
+    def prompt_line
+      prompt = "birdwatcher[".bold + "#{current_workspace.name}" + "]".bold
+      if current_module
+        prompt += "[".bold + current_module.path.light_red + "]> ".bold
+      else
+        prompt += "> ".bold
+      end
+      prompt
+    end
+
+    def load_default_workspace!
+      @current_workspace = Birdwatcher::Models::Workspace.find_or_create(
+        :name => Birdwatcher::Models::Workspace::DEFAULT_WORKSPACE_NAME
+      ) do |w|
+        w.description = Birdwatcher::Models::Workspace::DEFAULT_WORKSPACE_DESCRIPTION
+      end
+    end
+
+    def commands
+      @commands ||= Birdwatcher::Command.descendants
+    end
+
+    def configuration
+      Birdwatcher::Configuration
+    end
+
+    def with_output_mutex
+      @output_mutex.synchronize { yield }
+    end
+
+    def create_twitter_clients!
+      clients = []
+      configuration.get!(:twitter).each do |keypair|
+        clients << Twitter::REST::Client.new do |config|
+          config.consumer_key    = keypair["consumer_key"]
+          config.consumer_secret = keypair["consumer_secret"]
+        end
+      end
+      clients
+    end
+
+    def create_klout_clients!
+      clients = []
+      configuration.get(:klout).each do |key|
+        clients << Birdwatcher::KloutClient.new(key)
+      end
+      clients
+    end
+  end
+end

data/lib/birdwatcher/http_client.rb

@@ -0,0 +1,164 @@
+module Birdwatcher
+  class HttpClient
+    include HTTParty
+
+    # Default request timeout
+    DEFAULT_TIMEOUT = 15.freeze
+
+    # Default request retries
+    DEFAULT_RETRIES = 2.freeze
+
+    Response = Struct.new(:url, :status, :headers, :body)
+
+    # List of retriable exceptions
+    RETRIABLE_EXCEPTIONS = [
+      Errno::ETIMEDOUT,
+      Errno::ECONNRESET,
+      Errno::ECONNREFUSED,
+      Errno::ENETUNREACH,
+      Errno::EHOSTUNREACH,
+      Errno::EINVAL,
+      SocketError,
+      Net::OpenTimeout,
+      EOFError
+    ].freeze
+
+    # List of User-Agent strings to use for client spoofing
+    USER_AGENTS = [
+      "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36",
+      "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36",
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36",
+      "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36",
+      "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36",
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36",
+      "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:48.0) Gecko/20100101 Firefox/48.0",
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36",
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/601.7.8 (KHTML, like Gecko) Version/9.1.3 Safari/601.7.8",
+      "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:48.0) Gecko/20100101 Firefox/48.0",
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36",
+      "Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko",
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.11; rv:48.0) Gecko/20100101 Firefox/48.0",
+      "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:48.0) Gecko/20100101 Firefox/48.0",
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12) AppleWebKit/602.1.50 (KHTML, like Gecko) Version/10.0 Safari/602.1.50",
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/601.7.7 (KHTML, like Gecko) Version/9.1.2 Safari/601.7.7",
+      "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36",
+      "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36",
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36",
+      "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36"
+    ].freeze
+
+    # Class initializer
+    #
+    # @params options [Hash] client options
+    # @option options :timeout [Integer] request timeout
+    # @option options :retries [Integer] request retries
+    # @option options :user_agent [String] User-Agent to use (random if not set)
+    # @option options :retriable_exceptions [Array] exception classes to retry on
+    #
+    # @note The options list is incomplete; the class supports all options for the HTTParty gem
+    # @see http://www.rubydoc.info/github/jnunemaker/httparty/HTTParty/ClassMethods
+    def initialize(options = {})
+      @options = {
+        :timeout              => DEFAULT_TIMEOUT,
+        :retries              => DEFAULT_RETRIES,
+        :user_agent           => nil,
+        :retriable_exceptions => RETRIABLE_EXCEPTIONS
+      }.merge(options)
+    end
+
+    # Perform a GET request
+    #
+    # @param path [String] Path to request
+    # @param params [Hash] Request params
+    # @param options [Hash] Request options
+    # @return [Birdwatcher::HttpClient::Response]
+    def do_get(path, params=nil, options={})
+      do_request(:get, path, {:query => params}.merge(options))
+    end
+
+    # Perform a HEAD request
+    #
+    # @param path [String] Path to request
+    # @param params [Hash] Request params
+    # @param options [Hash] Request options
+    # @return [Birdwatcher::HttpClient::Response]
+    def do_head(path, params=nil, options={})
+      do_request(:head, path, {:query => params}.merge(options))
+    end
+
+    # Perform a POST request
+    #
+    # @param path [String] Path to request
+    # @param params [Hash] Request params
+    # @param options [Hash] Request options
+    # @return [Birdwatcher::HttpClient::Response]
+    def do_post(path, params=nil, options={})
+      do_request(:post, path, {:query => params}.merge(options))
+    end
+
+    # Perform a PUT request
+    #
+    # @param path [String] Path to request
+    # @param params [Hash] Request params
+    # @param options [Hash] Request options
+    # @return [Birdwatcher::HttpClient::Response]
+    def do_put(path, params=nil, options={})
+      do_request(:put, path, {:query => params}.merge(options))
+    end
+
+    # Perform a DELETE request
+    #
+    # @param path [String] Path to request
+    # @param params [Hash] Request params
+    # @param options [Hash] Request options
+    # @return [Birdwatcher::HttpClient::Response]
+    def do_delete(path, params=nil, options={})
+      do_request(:delete, path, {:query => params}.merge(options))
+    end
+
+    private
+
+    # Perform a request
+    # @private
+    #
+    # @param method [Symbol] Class method to call
+    # @param path [String] Request path
+    # @param options [Hash] Request options
+    #
+    # @return Birdwatcher::HttpClient::Response
+    def do_request(method, path, options)
+      opts = @options.merge({
+          :headers => {
+            "Accept"          => "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+            "Accept-Encoding" => "gzip",
+            "Accept-Language" => "en-US,en;q=0.8",
+            "Cache-Control"   => "max-age=0",
+            "Connection"      => "close",
+            "User-Agent"      => @options[:user_agent] || USER_AGENTS.sample
+          },
+          :verify => false
+        }).merge(options)
+      with_retries do
+        response = self.class.send(method, path, opts)
+        Response.new(response.request.last_uri.to_s, response.code, response.headers, response.body)
+      end
+    end
+
+    # Execute code block and retry if a retriable exception is raised
+    # @private
+    #
+    # @param &block Code block to run
+    def with_retries(&block)
+      tries = @options[:retries].to_i
+      yield
+    rescue *@options[:retriable_exceptions] => ex
+      tries -= 1
+      if tries > 0
+        sleep 0.2
+        retry
+      else
+        raise ex
+      end
+    end
+  end
+end