birdwatcher 0.1.0

data/lib/birdwatcher/commands/resource.rb

@@ -0,0 +1,45 @@
+module Birdwatcher
+  module Commands
+    class Resource < Birdwatcher::Command
+      self.meta = {
+        :description => "Execute commands from a resource file",
+        :names       => %w(resource),
+        :usage       => "resource FILE"
+      }
+
+      def self.detailed_usage
+<<-USAGE
+The #{'resource'.bold} command can be used to execute commands from a file on disk.
+Resource files are simple text-based files containing one command per line. They
+can be very convenient for common or repetitive workflows.
+
+#{'USAGE:'.bold}
+
+#{'Execute commands from a resource file:'.bold}
+  resource <FILE>
+USAGE
+      end
+
+      def run
+        if !arguments?
+          error("You must provide a path to a resource file")
+          return false
+        end
+        filepath = File.expand_path(arguments.join(" "))
+        if !File.exists?(filepath)
+          error("File #{filepath.bold} does not exist")
+          return false
+        end
+        if !File.readable?(filepath)
+          error("File #{filepath} is not readable")
+          return false
+        end
+        File.read(filepath).each_line do |command|
+          command.strip!
+          next if command.empty? || command.start_with?("#") || command.start_with?("//")
+          console.handle_input(command.strip)
+        end
+      end
+    end
+  end
+end

data/lib/birdwatcher/commands/run.rb

@@ -0,0 +1,19 @@
+module Birdwatcher
+  module Commands
+    class Run < Birdwatcher::Command
+      self.meta = {
+        :description => "Run current module",
+        :names       => %w(run execute),
+        :usage       => "run"
+      }
+
+      def run
+        if !console.current_module
+          error("No module loaded")
+          return false
+        end
+        console.current_module.new.execute
+      end
+    end
+  end
+end

data/lib/birdwatcher/commands/schema.rb

@@ -0,0 +1,116 @@
+module Birdwatcher
+  module Commands
+    class Schema < Birdwatcher::Command
+      self.meta = {
+        :description => "Show schema for database table",
+        :names       => %w(schema table),
+        :usage       => "schema [TABLE_NAME]"
+      }
+
+      def self.detailed_usage
+<<-USAGE
+The #{'schema'.bold} command can be used to get schema information on tables in
+the database.
+
+#{'USAGE:'.bold}
+
+#{'List all available tables:'.bold}
+  schema
+
+#{'See columns, indexes and foreign keys on a table:'.bold}
+  schema statuses
+USAGE
+      end
+
+      def run
+        if !arguments?
+          tables = database.tables.sort
+          output_available_tables(tables)
+          return
+        end
+        table  = arguments.first.strip
+        tables = database.tables.sort.map(&:to_s)
+        if !tables.include?(table)
+          error("Unknown table: #{table.bold}")
+          newline
+          output_available_tables(tables)
+          return false
+        end
+        schema       = database.schema(table.to_sym)
+        indexes      = database.indexes(table.to_sym)
+        foreign_keys = database.foreign_key_list(table.to_sym)
+        info("Schema information for table #{table.bold}:")
+        newline
+        output_schema_table(schema)
+        newline
+        info("Indexes on table #{table.bold}:")
+        newline
+        output_index_table(indexes)
+        newline
+        info("Foreign keys on table #{table.bold}:")
+        newline
+        output_foreign_key_table(foreign_keys)
+        newline
+      end
+
+      private
+
+      def output_available_tables(tables)
+        info("Available tables:")
+        newline
+        tables.each do |table|
+          output " * #{table.to_s.bold}"
+        end
+        newline
+      end
+
+      def output_schema_table(schema)
+        table_rows = []
+        schema.each do |column|
+          name, attr = column
+          table_rows << [
+            name,
+            attr[:db_type],
+            (attr[:default] ? attr[:default] : "NULL"),
+            (attr[:allow_null] ? "Yes" : "No"),
+            (attr[:primary_key] ? "Yes" : "No"),
+          ]
+        end
+        output Terminal::Table.new(
+          :headings => ["Column Name", "Type", "Default", "Allow NULL", "Primary Key"].map(&:bold),
+          :rows     => table_rows
+        )
+      end
+
+      def output_index_table(indexes)
+        table_rows = []
+        indexes.each_pair do |name, index|
+          table_rows << [
+            name.to_s,
+            index[:columns].map(&:to_s).join(", "),
+            (index[:unique] ? "Yes" : "No")
+          ]
+        end
+        output Terminal::Table.new(
+          :headings => ["Index Name", "Column(s)", "Unique"].map(&:bold),
+          :rows     => table_rows
+        )
+      end
+
+      def output_foreign_key_table(foreign_keys)
+        table_rows = []
+        foreign_keys.each do |foreign_key|
+          table_rows << [
+            foreign_key[:columns].map(&:to_s).join(", "),
+            foreign_key[:table].to_s,
+            foreign_key[:key].map(&:to_s).join(", ")
+          ]
+        end
+        output Terminal::Table.new(
+          :headings => ["Column(s)", "Referenced Table", "Referenced Column(s)"].map(&:bold),
+          :rows     => table_rows
+        )
+      end
+    end
+  end
+end

data/lib/birdwatcher/commands/set.rb

@@ -0,0 +1,56 @@
+module Birdwatcher
+  module Commands
+    class Set < Birdwatcher::Command
+      self.meta = {
+        :description => "Set module option",
+        :names       => %w(set),
+        :usage       => "set OPTION VALUE"
+      }
+
+      TRUTHY_VALUES = %w(1 true yes on).freeze
+      FALSY_VALUES  = %w(0 false no off).freeze
+
+      def run
+        if arguments.count < 2
+          error("You must provide an option name and value")
+          return false
+        end
+
+        if !current_module
+          error("No module loaded")
+          return false
+        end
+
+        option, value = arguments.first.upcase, arguments[1..-1].join(" ")
+        if !current_module.meta[:options].keys.include?(option)
+          error("Unknown option: #{option.bold}")
+          return false
+        end
+
+        if current_module.meta[:options][option][:boolean]
+          if truthy?(value)
+            value = true
+          elsif falsy?(value)
+            value = false
+          end
+        end
+
+        current_module.meta[:options][option][:value] = value
+      end
+
+      private
+
+      def truthy?(value)
+        TRUTHY_VALUES.include?(value.downcase)
+      end
+
+      def falsy?(value)
+        FALSY_VALUES.include?(value.downcase)
+      end
+
+      def current_module
+        console.current_module
+      end
+    end
+  end
+end

data/lib/birdwatcher/commands/shell.rb

@@ -0,0 +1,21 @@
+module Birdwatcher
+  module Commands
+    class Shell < Birdwatcher::Command
+      self.meta = {
+        :description => "Execute shell command",
+        :names       => %w(shell),
+        :usage       => "shell COMMAND"
+      }
+
+      def run
+        if !arguments?
+          error("You must provide a shell command to execute")
+          return false
+        end
+
+        command = arguments.join(" ")
+        output `#{command}`
+      end
+    end
+  end
+end

data/lib/birdwatcher/commands/show.rb

@@ -0,0 +1,86 @@
+module Birdwatcher
+  module Commands
+    class Show < Birdwatcher::Command
+      self.meta = {
+        :description => "Show module details and options",
+        :names       => %w(show),
+        :usage       => "show DETAILS"
+      }
+
+      def self.detailed_usage
+<<-USAGE
+The #{'show'.bold} command shows information and options on Birdwatcher
+modules.
+
+#{'USAGE:'.bold}
+
+#{'See available module options:'.bold}
+  show options
+
+#{'See additional module information:'.bold}
+  show info
+USAGE
+      end
+
+      def run
+        if !arguments?
+          error("You must specify what to see")
+          return false
+        end
+
+        if !current_module
+          error("No module loaded")
+          return false
+        end
+
+        case arguments.first
+        when "info", "description", "details"
+          output_info
+        when "options", "opts"
+          output_options
+        else
+          error("Don't know how to show #{arguments.first.bold}")
+          return false
+        end
+      end
+
+      private
+
+      def output_info
+        newline
+        output "       Name: ".bold + current_module.meta[:name]
+        output "Description: ".bold + current_module.meta[:description]
+        output "     Author: ".bold + current_module.meta[:author]
+        output "       Path: ".bold + current_module.path
+        newline
+        line_separator
+        newline
+        if current_module.info
+          output current_module.info
+        else
+          info("No further information has been provided for this module")
+        end
+        newline
+      end
+
+      def output_options
+        if current_module.meta[:options].empty?
+          info("This module has no options")
+          return
+        end
+        table = Terminal::Table.new(:headings => ["Name", "Current Setting", "Required", "Description"].map(&:bold))
+        table.style = { :border_y => "", :border_i => "" }
+        current_module.meta[:options].each_pair do |key, value|
+          table.add_row([key, value[:value], (value[:required] ? 'yes' : 'no'), value[:description]])
+        end
+        newline
+        output table
+        newline
+      end
+
+      def current_module
+        console.current_module
+      end
+    end
+  end
+end

data/lib/birdwatcher/commands/status.rb

@@ -0,0 +1,114 @@
+module Birdwatcher
+  module Commands
+    class Status < Birdwatcher::Command
+      self.meta = {
+        :description => "Manage statuses",
+        :names       => %w(status statuses tweet tweets),
+        :usage       => "status [ACTION]"
+      }
+
+      def self.detailed_usage
+<<-USAGE
+The #{'status'.bold} command manipulates statuses in the current workspace.
+
+#{'USAGE:'.bold}
+
+#{'List the last 1000 statuses from all users:'.bold}
+  status list
+
+#{'List the last 1000 statuses from specific users:'.bold}
+  status list [USER1[ USER2 ... USERN]]
+
+#{'Fetch and process new statuses from all users:'.bold}
+  status fetch
+
+#{'Search all statuses for a specific word:'.bold}
+  status search SEARCHTERM
+USAGE
+      end
+
+      def run
+        if !arguments?
+          error("You must provide an action")
+          return false
+        end
+        action = arguments.first.downcase
+        case action
+        when "list", "-l", "show", "-s"
+          list_statuses(arguments[1..-1])
+        when "search", "-s", "find"
+          search_statuses
+        when "fetch", "-f", "update", "-u"
+          fetch_statuses
+        else
+          list_statuses(arguments)
+        end
+      end
+
+      private
+
+      def fetch_statuses
+        current_workspace.users_dataset.order(:screen_name).each do |user|
+          statuses = []
+          task("Fetching statuses for #{user.screen_name.bold}...") do
+            statuses = get_statuses_for_user(user)
+          end
+          task("Processing #{Birdwatcher::Util.pluralize(statuses.count, 'status', 'statuses')}...") do
+            threads = thread_pool
+            statuses.each do |status|
+              threads.process do
+                save_status(status, user)
+              end
+            end
+            threads.shutdown
+          end
+        end
+      end
+
+      def search_statuses
+        search_term = arguments[1..-1].join(" ")
+        if search_term.empty?
+          error("You must provide a search term")
+          return false
+        end
+        statuses = current_workspace.statuses_dataset
+          .where("text LIKE ?", "%#{search_term}%")
+          .order(Sequel.desc(:posted_at))
+          .eager(:user)
+          .limit(1000)
+        texts = statuses.map { |s| make_status_summary_output(s) }.join("\n#{Birdwatcher::Console::LINE_SEPARATOR}\n\n")
+        page_text(texts)
+      end
+
+      def list_statuses(screen_names = nil)
+        if screen_names.nil? || screen_names.empty?
+          statuses = current_workspace.statuses_dataset.order(Sequel.desc(:posted_at)).eager(:user).limit(1000)
+        else
+          user_ids = current_workspace.users_dataset.where("screen_name IN ?", screen_names).map(:id)
+          statuses = current_workspace.statuses_dataset.where("user_id IN ?", user_ids).order(Sequel.desc(:posted_at)).eager(:user).limit(1000)
+        end
+        texts = statuses.map { |s| make_status_summary_output(s) }.join("\n#{Birdwatcher::Console::LINE_SEPARATOR}\n\n")
+        page_text(texts)
+      end
+
+      def collect_with_max_id(collection = [], max_id = nil, pages = 5, &block)
+        return collection.flatten if pages.zero?
+        response = yield(max_id)
+        collection += response
+        response.empty? ? collection.flatten : collect_with_max_id(collection, response.last.id - 1, pages - 1, &block)
+      end
+
+      def get_statuses_for_user(user)
+        if last_status = user.statuses_dataset.order(Sequel.desc(:posted_at)).first
+          since_id = last_status.twitter_id
+        end
+        collect_with_max_id do |max_id|
+          options = {:count => 200, :include_rts => true}
+          options[:since_id] = since_id unless since_id.nil?
+          options[:max_id]   = max_id unless max_id.nil?
+          twitter_client.user_timeline(user.screen_name, options)
+        end
+      end
+    end
+  end
+end

data/lib/birdwatcher/commands/unset.rb

@@ -0,0 +1,37 @@
+module Birdwatcher
+  module Commands
+    class Unset < Birdwatcher::Command
+      self.meta = {
+        :description => "Unset module option",
+        :names       => %w(unset),
+        :usage       => "unset OPTION"
+      }
+
+      def run
+        if !arguments?
+          error("You must provide an option name")
+          return false
+        end
+
+        if !current_module
+          error("No module loaded")
+          return false
+        end
+
+        option = arguments.first.upcase
+        if !current_module.meta[:options].keys.include?(option)
+          error("Unknown option: #{option.bold}")
+          return false
+        end
+
+        current_module.meta[:options][option][:value] = nil
+      end
+
+      private
+
+      def current_module
+        console.current_module
+      end
+    end
+  end
+end

data/lib/birdwatcher/commands/use.rb

@@ -0,0 +1,25 @@
+module Birdwatcher
+  module Commands
+    class Use < Birdwatcher::Command
+      self.meta = {
+        :description => "Load specified module",
+        :names       => %w(use load),
+        :usage       => "use MODULE_PATH"
+      }
+
+      def run
+        if !arguments?
+          error("You must provide a module path")
+          return false
+        end
+
+        if !_module = Birdwatcher::Module.module_by_path(arguments.first)
+          error("Unknown module: #{arguments.first.bold}")
+          return false
+        end
+
+        console.current_module = _module
+      end
+    end
+  end
+end

data/lib/birdwatcher/commands/user.rb

@@ -0,0 +1,155 @@
+module Birdwatcher
+  module Commands
+    class User < Birdwatcher::Command
+      self.meta = {
+        :description => "Manage users",
+        :names       => %w(user users),
+        :usage       => "user [ACTION]"
+      }
+
+      def self.detailed_usage
+<<-USAGE
+The #{'user'.bold} command manipulates users in the current workspace.
+
+#{'USAGE:'.bold}
+
+#{'List all users in the workspace:'.bold}
+  user list
+
+#{'Add one or more users to the workspace:'.bold}
+  user create [USER1[ USER2 ... USERN]]
+
+#{'Update information on one or more users:'.bold}
+  user update [USER1[ USER2 ... USERN]]
+
+#{'Delete one or more users from the workspace:'.bold}
+  user delete [USER1[ USER2 ... USERN]]
+USAGE
+      end
+
+      def run
+        if !arguments?
+          error("You must provide an action")
+          return false
+        end
+        action = arguments.first.downcase
+        case action
+        when "list"
+          list_users
+        when "create", "add", "-a"
+          create_users
+        when "update", "-u"
+          update_users
+        when "delete", "destroy", "rm", "-d"
+          delete_users
+        else
+          list_user
+        end
+      end
+
+      private
+
+      def list_users
+        if current_workspace.users.count.zero?
+          info("There are currently no users in this workspace")
+          return true
+        end
+        newline
+        users = current_workspace.users_dataset.order(:screen_name).map do |u|
+          make_user_summary_output(u)
+        end.join("\n#{Birdwatcher::Console::LINE_SEPARATOR}\n\n")
+        page_text(users)
+      end
+
+      def list_user
+        if !user = current_workspace.users_dataset.first(:screen_name => arguments.first)
+          error("User #{screen_name.bold} was not found in workspace")
+          return false
+        end
+        newline
+        output_user_details(user)
+        newline
+      end
+
+      def create_users
+        screen_names = arguments[1..-1].uniq
+        if screen_names.empty?
+          error("You must provide at least one screen name")
+          return false
+        end
+        screen_names.each do |screen_name|
+          begin
+            if current_workspace.users_dataset.first(:screen_name => screen_name)
+              error("User #{screen_name.bold} is already in the workspace")
+              next
+            end
+            api_user = twitter_client.user(screen_name)
+            save_user(api_user)
+            info("Added #{screen_name.bold} to workspace")
+          rescue Twitter::Error::NotFound
+            error("There is no user with screen name: #{screen_name.bold}")
+          end
+        end
+      end
+
+      def update_users
+        screen_names = arguments[1..-1].uniq
+        if screen_names.empty?
+          db_users = current_workspace.users
+        else
+          db_users = current_workspace.users_dataset.where("screen_name IN ?", screen_names)
+        end
+        threads = thread_pool
+        db_users.each do |db_user|
+          threads.process do
+            begin
+              api_user = twitter_client.user(db_user.screen_name)
+              db_user.update(
+                :name              => api_user.name,
+                :location          => api_user.location,
+                :description       => api_user.description,
+                :url               => (api_user.website_urls.first ? api_user.website_urls.first.expanded_url.to_s : nil),
+                :profile_image_url => api_user.profile_image_url_https.to_s,
+                :followers_count   => api_user.followers_count,
+                :friends_count     => api_user.friends_count,
+                :listed_count      => api_user.listed_count,
+                :favorites_count   => api_user.favorites_count,
+                :statuses_count    => api_user.statuses_count,
+                :utc_offset        => api_user.utc_offset,
+                :timezone          => api_user.time_zone,
+                :geo_enabled       => api_user.geo_enabled?,
+                :verified          => api_user.verified?,
+                :lang              => api_user.lang
+              )
+              info("Updated information for #{db_user.screen_name.bold}")
+            rescue Twitter::Error::NotFound
+              error("There is no user with screen name: #{db_user.screen_name.bold}")
+            end
+          end
+        end
+        threads.shutdown
+      end
+
+      def delete_users
+        screen_names = arguments[1..-1].uniq
+        if screen_names.empty?
+          error("You must provide at least one screen name")
+          return false
+        end
+        return unless confirm("Are you sure you want to delete #{screen_names.map(&:bold).join(', ')} and all associated data?")
+        screen_names.each do |screen_name|
+          begin
+            if !db_user = current_workspace.users_dataset.first(:screen_name => screen_name)
+              error("User #{screen_name.bold} was not found in workspace")
+              next
+            end
+            db_user.destroy
+            info("Deleted #{screen_name.bold} from workspace")
+          rescue Twitter::Error::NotFound
+            error("There is no user with screen name: #{screen_name.bold}")
+          end
+        end
+      end
+    end
+  end
+end