lazybird 0.1.0

data/README.md

@@ -0,0 +1,74 @@
+# Lazybird (Beta)
+
+[![Gem Version](https://img.shields.io/badge/lazybird-v0.1.0beta-orange.svg)][gem]
+
+[gem]: https://rubygems.org/gems/lazybird
+
+Twitter for busy people.
+
+## Installation
+
+Register at https://apps.twitter.com/app/new
+
+Example: 
+
+![](http://i.imgsafe.org/fbf19e8.png)
+
+Then click on keys and access tokens and generate an access token. You will need this for the setup.
+
+
+Install lazybird running:
+
+    $ gem install lazybird
+
+## Setup
+
+Once lazybird is installed you can run it with:
+
+`lazybird` 
+
+or
+
+`bundle exec lazybird`
+
+The CLI should appear:
+
+![](http://i.imgsafe.org/bdeff99.png)
+
+
+Typically you want to setup the database first running `setup`
+
+And run config to enter your twitter settings: `config consumer_key consumer_secret access_token access_token_secret`
+
+## Usage
+
+Run it with `lazybird` - you would need to keep the app running as long as you want to tweet automatically.
+
+Lazybird contains (at the moment) only two tasks that run at a certain configured time:
+
+
+_retweet_random_: Retweets a random tweet (latest) from a random friend
+
+_tweet_storm_: Tweets a random quote from the Storm API http://quotes.stormconsultancy.co.uk
+
+
+Add them both to your list of tasks (this will store them in an internal DB to resume later)
+
+ `add retweet_random`
+ 
+ `add tweet_storm`
+ 
+ Then you want to either randomly tweet something now with `run now` or schedule it to tweet every N minutes/hours/day:s `run 2h` or `run 30m` for example.
+ 
+ You will need to keep the command line open and you should see an update everytime something random gets tweeted.
+ 
+ Lazybird stores a DB/config file at ~/.twitter.db - make sure it's safe.
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/bluegod/lazybird.
+
+## License
+
+GPL v2

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lazybird"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/lazybird

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lazybird"
+require "lazybird/cli/command_line"
+
+Lazybird::Cli::CommandLine.new

data/bin/setup

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+

data/lazybird.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lazybird/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lazybird'
+  spec.version       = Lazybird::VERSION
+  spec.authors       = ['James Lopez']
+  spec.email         = ['james@jameslopez.es']
+  spec.license       = 'GPL-2.0'
+
+  spec.summary       = %q{Twitter for lazy people. Automatically tweets/retweets random stuff. }
+  spec.description   = %q{Provides a command line interface to interact with twitter and automatically tweets/retweets some predefined (or API based tweets) at a specified frequency. }
+  spec.homepage      = "https://github.com/bluegod/lazybird"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = ['lazybird']
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.3"
+  spec.add_dependency 'twitter', '~> 5.15'
+  spec.add_dependency 'rufus-scheduler', '~> 3.1'
+  spec.add_dependency 'amalgalite', '~> 1.4'
+  spec.add_dependency 'sequel', '~> 4.27'
+  spec.add_dependency 'colorize', '~> 0.7'
+end

data/lib/config/tasks.yml

@@ -0,0 +1,6 @@
+retweet_random:
+  desc: 'Retweets a random tweet (latest) from a random friend'
+  class: Lazybird::Tasks::RetweetRandomTask
+tweet_storm:
+  desc: 'Tweets a random quote from the Storm API http://quotes.stormconsultancy.co.uk'
+  class: Lazybird::Tasks::StormQuoteTask

data/lib/lazybird.rb

@@ -0,0 +1,5 @@
+require 'lazybird/version'
+require 'lazybird/config'
+module Lazybird
+
+end

data/lib/lazybird/cli/command_line.rb

@@ -0,0 +1,64 @@
+require 'colorize'
+require 'lazybird/version'
+require 'lazybird/lazybird_facade'
+require 'lazybird/cli/commands'
+require 'rbconfig'
+
+module Lazybird
+  module Cli
+    class CommandLine
+      include Lazybird::Cli::Commands
+
+      def initialize
+        @facade = Lazybird::LazybirdFacade.new
+        intro.display
+        setup_check
+        run_main_loop
+      end
+
+      private
+
+      def setup_check
+        if Lazybird::Config.db_file_exists?
+          @facade.load_default_tasks
+        else
+          puts 'Type: '.bold + "setup \u{23ce}".red.bold + " as this is the first time running the app.\n".bold
+        end
+      end
+
+      def run_main_loop
+        loop do
+          display_prompt
+          command, *params = gets.chomp.split /\s/
+          process_command(command, params) if command
+        end
+      end
+
+      def newline
+        puts
+      end
+
+      def process_command(command, params)
+        command.downcase!
+        if respond_to?(command)
+          send(command, params)
+        else
+          puts 'Invalid command'.light_red
+        end
+      end
+
+      def display_prompt
+        prompt.yellow.display
+      end
+
+      def prompt
+        @_prompt ||=
+          begin
+            os = RbConfig::CONFIG['host_os']
+            icon = os.start_with?('darwin') ? "\u{1F425}" : ')<'
+            "#{icon} Lazybird> "
+          end
+      end
+    end
+  end
+end

data/lib/lazybird/cli/commands.rb

@@ -0,0 +1,88 @@
+module Lazybird
+  module Cli
+    module Commands
+
+      def config(params)
+        @facade.config(params)
+        display_done
+      end
+
+      def setup(params)
+        @facade.init
+        display_done
+      end
+
+      def add(params)
+        @facade.add_task params.first
+        display_done
+      end
+
+      def my_tasks(params)
+        @facade.current_tasks.join("\n").green.display
+        newline
+      end
+
+      def rem(params)
+        @facade.rem_task(params.first)
+        display_done
+      end
+
+      def run(params)
+        cursor = -> () do
+          display_prompt
+        end
+        @facade.run_tasks(params, &cursor)
+      end
+
+      def my_run(params)
+        @facade.run_info.green.display
+        newline
+      end
+
+      def exit(params)
+        Kernel.exit(true)
+      end
+
+      def intro
+        "Lazybird v#{Lazybird.version}\n".light_yellow +
+          "by James Lopez <http://jameslopez.net> <https://github.com/bluegod/lazybird>\n".blue +
+          'Type: ' + "help \u{23ce}".bold + " for a list of commands.\n"
+      end
+
+      def help(params)
+        begin
+          "List of available commands: \n".yellow +
+            "config ".bold + "consumer_key consumer_secret access_token access_token_secret".green + " \u{23ce} \n".white +
+            "Configures twitter account (Should be the first step!)\n" +
+            "tasks  \u{23ce} \n".bold +
+            "Displays a list of available tasks \n" +
+            "my_tasks".bold + "  \u{23ce} \n" +
+            "Displays a list of your selected tasks \n" +
+            "add ".bold + "task".green + " \u{23ce} \n".white +
+            "Adds a task to be randomly tweeted\n" +
+            "rem ".bold + "task".green + " \u{23ce} \n".white +
+            "Removes a task from your list\n" +
+            "run ".bold + "time".green + " \u{23ce} \n".white +
+            "Sets how frequent we tweet (Ex: run 3h or run 1d or run 30m)\n" +
+            "my_run ".bold + "  \u{23ce} \n" +
+            "Displays the current frequency of tweets \n" +
+            "setup  \u{23ce} \n".bold +
+            "setups the app for the first time \n" +
+            "exit  \u{23ce} \n".bold +
+            "Exits the app \n"
+        end.display
+      end
+
+      def tasks(params)
+        @facade.tasks.each do |k, v|
+          puts "#{k}:".bold + " #{v['desc']}".green
+        end
+      end
+
+      def display_done
+        'done!'.green.display
+        newline
+      end
+    end
+  end
+end

data/lib/lazybird/config.rb

@@ -0,0 +1,37 @@
+require 'twitter'
+require 'yaml'
+require 'lazybird/db'
+
+module Lazybird
+  module Config
+    extend self
+
+    def client
+      @_client ||= Twitter::REST::Client.new do |config|
+        config.consumer_key = db_config[:consumer_key]
+        config.consumer_secret = db_config[:consumer_secret]
+        config.access_token = db_config[:access_token]
+        config.access_token_secret = db_config[:access_token_secret]
+      end
+    end
+
+    def tasks
+      @_tasks ||= YAML::load_file('./lib/config/tasks.yml')
+    end
+
+    def db_file
+      "#{Dir.home}/.twitter.db"
+    end
+
+    def db_file_exists?
+      File.file? db_file
+    end
+
+    private
+
+    def db_config
+      #TODO: nice to have - this should go to the DB if a new config is saved.
+      @_config ||= Lazybird::Db.config
+    end
+  end
+end

data/lib/lazybird/db.rb

@@ -0,0 +1,84 @@
+require 'sequel'
+require 'lazybird/tasks/task'
+require 'lazybird/utils'
+require 'lazybird/config'
+module Lazybird
+  module Db
+    extend self
+
+    #TODO: refactor this. This is a quick & dirty way to create the DB
+    def self.init
+      db.transaction do
+        db.create_table :config do
+          primary_key :id
+          String :name, :unique => true, :null => false
+          String :consumer_key, :null => false
+          String :consumer_secret, :null => false
+          String :access_token, :null => false
+          String :access_token_secret, :null => false
+        end
+
+        db.create_table :tweets do
+          primary_key :id
+          String :text, :unique => true, :null => false
+          DateTime :created_at
+        end
+
+        db.create_table :tasks do
+          primary_key :id
+          String :command, :unique => true, :null => false
+          String :options
+          DateTime :created_at
+        end
+      end
+    end
+
+    def save_tweet!(text:)
+      db[:tweets].insert(text: text, created_at: DateTime.now)
+    end
+
+    # TODO: Ideally we should have different configs, perhaps per twitter user
+    # for now, let's just delete every time we save a new one.
+    def save_config!(config)
+      db[:config].delete
+      db[:config].insert(config.merge(name: 'default'))
+    end
+
+    def config
+      db[:config].first
+    end
+
+    def save_task!(task)
+      task_hash = {command: task.command,
+                   created_at: DateTime.now}
+      task_hash.merge!(options: task.opts) if !task.opts.empty?
+      db[:tasks].insert(Lazybird::Utils::Hash.compact(task_hash))
+    end
+
+    def rem_task!(task_command)
+      db[:tasks].where('command = ?', task_command).delete
+    end
+
+    def list_tasks
+      db[:tasks].select(:command)
+    end
+
+    def tasks
+      db[:tasks].all.map do |task|
+        found = Lazybird::Utils::Hash.find_by_key(Lazybird::Config.tasks, task[:command])
+        unless found.empty?
+          task_found(task[:command], found).new(command: task[:command],
+                                                options: found[:options])
+        end
+      end
+    end
+
+    def task_found(task_name, found)
+      Object.const_get(found[task_name]['class'])
+    end
+
+    def db
+      @_db ||= Sequel.amalgalite(Lazybird::Config.db_file)
+    end
+  end
+end

data/lib/lazybird/lazybird_facade.rb

@@ -0,0 +1,86 @@
+require 'lazybird/config'
+require 'lazybird/db'
+require 'lazybird/utils'
+require 'lazybird/tasks/storm_quote_task'
+require 'lazybird/tasks/retweet_random_task'
+require 'lazybird/tasks/task_scheduler'
+
+module Lazybird
+  #TODO: split this file
+  class LazybirdFacade
+
+    attr_reader :tasks
+
+    def initialize
+      @current_tasks = Set.new
+      @tasks = Lazybird::Config.tasks
+    end
+
+    def add_task(task_name)
+      # TODO refactor this method
+      found = Lazybird::Utils::Hash.find_by_key(@tasks, task_name)
+      if found
+        task = Object.const_get(found[task_name]['class']).new(command: task_name)
+        begin
+          Lazybird::Db.save_task!(task)
+        rescue Sequel::UniqueConstraintViolation
+          puts 'Task added already'.light_red
+        end
+        @current_tasks << task
+      end
+    end
+
+    def rem_task(task_name)
+      Lazybird::Db.rem_task!(task_name)
+      @current_tasks.delete_if { |t| t.command == task_name }
+    end
+
+    def current_tasks
+      @current_tasks.map { |t| t.command }
+    end
+
+    def load_default_tasks
+      @current_tasks.merge(Lazybird::Db.tasks)
+    end
+
+    def init
+      Lazybird::Db.init
+    end
+
+    def config(params)
+      config = Lazybird::Utils::Hash.array_to_hash([:consumer_key,
+                                                    :consumer_secret,
+                                                    :access_token,
+                                                    :access_token_secret], params)
+      Lazybird::Db.save_config! config
+    end
+
+    def run_tasks(params, &block)
+      if params.first == 'now'
+        run_random_task
+      else
+        Lazybird::Tasks::TaskScheduler.schedule(frequency: params.first) do
+          run_random_task(&block)
+        end
+      end
+    end
+
+    def run_info
+      Lazybird::Tasks::TaskScheduler.job_info
+    end
+
+    private
+
+    def run_random_task(&block)
+      puts 'Twitting something random...'.yellow
+      text = @current_tasks.to_a.sample.run
+      if text.nil?
+        puts "Sorry! We couldn't tweet :(".light_red
+      else
+        puts "<<#{text.magenta}>>"
+      end
+      yield if block
+      text
+    end
+  end
+end