pushpop 0.1.1 → 0.1.2

data/.gitignore

@@ -1 +1,2 @@
 .env
+Gemfile.lock

data/Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
-gem 'clockwork'
+gemspec
 
 group :development, :test do
   gem 'rake'

data/README.md

@@ -4,7 +4,7 @@
 
 [![Build Status](https://travis-ci.org/pushpop-project/pushpop.svg)](https://travis-ci.org/pushpop-project/pushpop)
 
-### A framework for scheduled integrations
+### A framework for scheduled integrations between popular services
 
 <hr>
 <img src="http://f.cl.ly/items/1I421w263a10340a0u2q/Screen%20Shot%202014-04-16%20at%204.35.47%20PM.png" width="45%" alt="Pingpong Daily Response Time Report">
@@ -14,13 +14,15 @@
 
 ## Overview
 
-Pushpop is a simple but powerful Ruby gem that lets you share data between services at regular intervals.
-This can be used to do things like regular data collection as well as triggering alerts based on patterns in data.
+Pushpop is a powerful framework for taking actions and integrating services at regular intervals.
+This can be used to do anything from scheduled data collection to alerting based on patterns in data.
 
-Pushpop includes support for sending notifications and reports based on events captured with [Keen IO](https://keen.io).
+Pushpop began as a way to send notifications and reports based on events captured with [Keen IO](https://keen.io).
 See plugins for more services on the [Pushpop organization](https://github.com/pushpop-project) home page.
 
-#### Ways to use Pushpop
+Pushpop is packaged as a Ruby gem. It can be added to existing Ruby projects or used in new ones.
+
+#### Ideas for using Pushpop
 
 ##### Alerts
 
@@ -31,10 +33,15 @@ See plugins for more services on the [Pushpop organization](https://github.com/p
 
 + Send a sales report to your inbox every day at noon
 + Send analytics reports to your customers every week
+ 
+##### Monitoring
+
++ Track the performance of web services and APIs
++ Read sensor values for analysis and alerting
 
-#### An example Pushpop job
+#### Example Pushpop job
 
-This Pushpop job uses the `keen` and `sendgrid` plugins to send a nightly email containing the day's number of pageviews:
+Pushpop organizes work into jobs. Here's a Pushpop job that uses the `keen` and `sendgrid` plugins to send a nightly email. The email contains the day's number of pageviews:
 
 ``` ruby
 require 'pushpop-keen'
@@ -60,162 +67,92 @@ job do
 end
 ```
 
-The email is sent by [Sendgrid](https://sendgrid.com), made possible by the [sendgrid](https://github.com/pushpop-project/pushpop-sendgrid) Pushpop plugin.
-
-Pushpop syntax is short and sweet, but because Pushpop is just Ruby it's also quite powerful.
-
-### Get Started
-
-Excited to try out Pushpop with your Keen IO projects? Here's a few options to choose from:
-
-#### The Quickstart
-
-Setup Pushpop locally and run your first job in minutes.
-
-**[Go to the Quickstart](#quickstart)**
-
-#### Deploy a Pushpop Instance
-
-Ready to deploy a local Pushpop job? Detailed instructions for Heroku are provided as well as a basic guide for other platforms.
+Keen IO provides the analytics data behind the report. The email is sent by [Sendgrid](https://sendgrid.com) via the [sendgrid](https://github.com/pushpop-project/pushpop-sendgrid) Pushpop plugin.
 
-**[Go to the Deploy Guide](#deploy-guide)**
-
-#### Need help?
-
-Don't have a hacker on hand? The friendly folks at Keen IO can set a Pushpop up for you.
-
-**Email [team@keen.io](mailto:team@keen.io?subject=I want a Pushpop!)** with the subject "I want a Pushpop!". Include information about what queries you'd like to run (and when) and how you'd like the results communicated.
+Pushpop syntax is short and sweet, but because Pushpop is pure Ruby it's also quite powerful.
 
 ## Quickstart
 
-The goal of the Quickstart is to get a Pushpop instance running locally and write your first job. This should take less than 10 minutes.
-
-#### Prerequisites
-
-+ A working [Ruby installation](https://www.ruby-lang.org/en/installation/) (1.9+)
+Install Pushpop as a Ruby gem:
 
-#### Steps
-
-##### Clone the Pushpop starter project
-
-``` shell
-$ git clone git@github.com:pushpop-project/pushpop-starter.git
 ```
-
-Enter the `pushpop-starter` directory and install dependencies.
-
-``` shell
-$ cd pushpop-starter
-$ gem install bundler
-$ bundle install
+$ gem install pushpop
 ```
 
-##### Test the included job
-
-There is an example job in `jobs/example_job.rb` of the pushpop-starter repository. It simply prints output to the console. Run this job via a rake task to make sure your configuration is setup properly.
+You should now have a `pushpop` command available in your shell. Try it out with no arguments to see a list of possible commands:
 
-``` shell
-$ bundle exec rake jobs:run_once[jobs/example_job.rb]
 ```
-
-You should see the following output (followed by a logging statement):
-
-``` html
-Hey Pushpop, let's do a math!
-<pre>The number 30!</pre>
+$ pushpop
+Commands:
+  pushpop help [COMMAND]  # Describe available commands or one specific command
+  pushpop jobs:describe   # Describe jobs
+  pushpop jobs:run        # Run jobs ongoing
+  pushpop jobs:run_once   # Run jobs once
+  pushpop version         # Print the Pushpop version
 ```
 
-That's it. You're ready to add your own jobs to the jobs folder.
+##### Create a simple job
 
-##### Next steps
-
-+ Write and test more jobs. See the [Pushpop API Documentation](#pushpop-api-documentation) below for more examples of what you can do.
-+ See [pushpop-recipes](https://github.com/pushpop-project/pushpop-recipes) for reusable code and inspiration.
-+ Continue on to the [Deploy Guide](#deploy-guide) to deploy the job you just created.
+Copy the code below into a file called `example_job.rb`. This job simply prints output to the console:
 
-## Deploy Guide
-
-#### Heroku
-
-These instructions are for Heroku, but should be relevant to most environments.
-
-##### Prerequisites
-
-You'll need a [Heroku](https://heroku.com/) account, and the [Heroku toolbelt](https://toolbelt.heroku.com/) installed.
-
-##### Create a new Heroku app
-
-Make sure you're inside a Pushpop project directory (e.g. pushpop-starter), than create a new Heroku app.
-
-``` shell
-$ heroku create
-```
+``` ruby
+require 'pushpop'
 
-This will create a Heroku app and add a new git remote destination called `heroku` to your git configuration.
+job do
 
-##### Commit changes
+  every 1.seconds
 
-If you created a new job from the Quickstart guide, you'll want to commit that code before deploying.
+  step do
+    puts 'Hello World!'
+  end
 
-``` shell
-$ git commit -am 'Created my first Pushpop job'
+end
 ```
 
-##### Deploy code to Heroku
-
-Now that your code is commited and config variables pushed we can begin a deploy. We'll also need to scale the number of worker processes to 1.
+Run this job once via using the `jobs:run_once` command:
 
 ``` shell
-$ git push heroku master
-$ heroku scale worker=1
+$ pushpop jobs:run_once --file example_job.rb
 ```
 
-##### Tail logs to confirm it's working
-
-To see that jobs are running and that there are no errors, tail the logs on Heroku.
+You should see the following output:
 
-``` shell
-$ heroku logs --tail
+``` html
+Hello World!
 ```
 
-Note that if you have jobs that are set to run at specific times of day you might not see output for a while.
-
-Another note - by default this will run all jobs in the `jobs` folder. You might want to delete the `example_job.rb` file in a separate commit once you've got the hang of things. You can change this behavior by editing the Procfile.
-
-#### Other environments
-
-Pushpop is deployed as one long-running Ruby process. Anywhere you can run this process you can run Pushpop. Here's the command:
+That's all there is to it. To run the job repeatedly at the times specified by `every` just change `run_once` to `run`:
 
 ``` shell
-$ foreman run rake jobs:run
+$ pushpop jobs:run --file example_job.rb
 ```
 
-If you don't want to use foreman and prefer to set the environment variables yourself then all you need is this:
+Make sure to leave the process running in your terminal, or [send it to the background](http://stackoverflow.com/questions/625409/how-do-i-put-an-already-running-process-under-nohup), so that it keeps running.
 
-``` shell
-$ bundle exec rake jobs:run
-```
+##### Next steps
 
-Note: You probably want to monitor the process via something like [supervisord](http://supervisord.org/).
++ Write and test more jobs. See the [Pushpop API Documentation](#pushpop-api-documentation) below for more examples of what you can do.
++ See the [pushpop-project](https://github.com/pushpop-project) Github organization to find plugins and reusable code.
 
-## Rake Tasks
+## Pushpop Commands
 
-Pushpop comes with some rake tasks to make command line interaction and deployment easier.
+Pushpop comes with commands to describe and run jobs.
 
-All `jobs:*` rake tasks optionally take a single filename as a parameter. The file is meant to contain one or more Pushpop jobs. If no filename is specified, all jobs in the jobs folder are required.
+All `jobs:*` commands optionally take a filename or directory as a `--file` or `-f` parameter. The file/directory is meant to contain one or more Pushpop jobs.
 
 Specifying a specific file looks like this:
 
 ``` shell
-$ bundle exec rake jobs:run[jobs/just_this_job.rb]
+$ pushpop jobs:run --file jobs/just_this_job.rb
 ```
 
-Here's a list of the available rake tasks:
+Here's a list of the available commands:
 
 + `jobs:describe` - Print out the names of jobs in the jobs folder.
 + `jobs:run_once` - Run each job once, right now.
-+ `jobs:run` - Run jobs as scheduled in a long-running process. This is the task used when you deploy.
-+ `spec` - Run the specs.
++ `jobs:run` - Run jobs as scheduled in a long-running process. This is the command you should use for a deployed Pushpop.
+
+All `jobs:*` tasks also use [dotenv](https://github.com/bkeepers/dotenv) to load environment variables, often contained in a `.env` file.
 
 ## Pushpop API Documentation
 
@@ -226,8 +163,8 @@ Steps and jobs are the heart of the Pushpop workflow. Job files are written in p
 Jobs have the following attributes:
 
 + `name`: (optional) something that describe the job, useful in logs
-+ `period`: how frequently to run the job, first param to `every`
-+ `every_options` (optional): options related to when the job runs, second param to `every`
++ `period`: how frequently to run the job; the first param to `every`
++ `every_options` (optional): options related to when the job runs; the second param to `every`
 + `steps`: an ordered list of steps to run
 
 These attributes are easily specified using the DSL's block syntax. Here's an example:
@@ -244,9 +181,9 @@ end
 The name of this job is 'print job'. It runs every 5 minutes and it has 1 step.
 
 Inside of a `job` configuration block, steps are added by using the `step` method. They can also be
-added by using a method registered by a plugin, like `keen` or `twilio`. For more information on plugins see [Plugin Documentation](#plugin-documentation).
+added by using a method registered by a plugin, like `keen` or `twilio`. For more informatio on plugins see [Plugins](#plugins).
 
-The period of the job's execution is set via the `every` method. This is basically a passthrough to the [Clockwork](https://github.com/tomykaira/clockwork) long-running process scheduler. Here are some cool things you can do with regard to setting times and days:
+The period of the job's execution is set via the `every` method. This is a passthrough to the [Clockwork](https://github.com/tomykaira/clockwork) long-running process scheduler. Clockwork gives you a great deal of flexibility when it comes specifiying when jobs should run. Here are some examples:
 
 ``` ruby
 every 5.seconds
@@ -258,7 +195,7 @@ every 5.seconds, at: '10:**'
 every 1.week, at: 'Monday 12:30'
 ```
 
-See the full set of options on the [Clockwork README](https://github.com/tomykaira/clockwork#event-parameters).
+See the full range of possibilities on the [Clockwork README](https://github.com/tomykaira/clockwork#event-parameters).
 
 ##### Job workflow
 
@@ -269,6 +206,8 @@ The map is keyed by step name, which defaults to a plugin name if a plugin was u
 Here's an example that shows how the response chain works:
 
 ``` ruby
+require 'pushpop'
+
 job do
   every 5.minutes
   step 'one' do
@@ -278,7 +217,7 @@ job do
     5 + response
   end
   step 'add previous steps' do |response, step_responses|
-    puts response # prints 5
+    puts response # prints 6
     puts step_responses['one'] + step_responses['two'] # prints 6
   end
 end
@@ -287,6 +226,8 @@ end
 If a `step` returns false, subsequent steps **are not run**. Here's a simple example that illustrates this:
 
 ``` ruby
+require 'pushpop'
+
 job 'lame job' do
   every 5.minutes
   step 'one' do
@@ -302,6 +243,8 @@ This behavior is designed to make *conditional* alerting easy. Here's an example
 for certain query responses:
 
 ``` ruby
+require 'pushpop'
+
 job do
 
   every 1.minute
@@ -365,13 +308,15 @@ for doing common things with Pushpop. Check it out for some inspiration!
 
 ## Plugins
 
-Plugins are packaged as gems. See the [Pushpop organization](https://github.com/pushpop-project) page for a sampling of popular plugins.
+Plugins are packaged as gems. See the [pushpop-project](https://github.com/pushpop-project) github organization for a sampling of popular plugins.
 
-## Creating plugins
+### Creating plugins
 
 Plugins are just subclasses of `Pushpop::Step`. Plugins should implement a `run` method and register themselves. Here's a simple plugin that stops job execution if the input into the step is 0:
 
 ``` ruby
+require 'pushpop'
+
 module Pushpop
   class StopIfZero < Step
     PLUGIN_NAME = 'stop_if_zero'
@@ -392,41 +337,11 @@ job do
 end
 ```
 
-## Usage as a Ruby gem
-
-Pushpop can also be embedded in existing Ruby projects as a Ruby gem. Here's some steps on how to do that.
-
-##### Install the gem
-
-``` ruby
-# bundler
-gem 'pushpop'
-
-# not bundler
-gem install 'pushpop'
-```
-
-##### Require job files and run
-
-Once the gem is available you can load or require Pushpop job files. Once each file loads the jobs it contains are ready to be run or scheduled. Here's that sequence:
-
-``` ruby
-load 'some_job.rb'
-
-# you could run the jobs once
-Pushpop.run
-
-# or schedule and run the jobs with clockwork
-Pushpop.schedule
-Clockwork.manager.run
-```
-
-The `pushpop` gem does not declare dependencies other than `clockwork` and `keen`. If you're using
-Pushpop plugins like Sendgrid or Twilio you'll need to bundle and require those dependencies separately.
+See [pushpop-plugin](https://github.com/pushpop-project/pushpop-plugin) for a repository that you can clone to make creating and packaging plugins easier.
 
 ## Contributing
 
-Issues and pull requests are very welcome!
+Issues and pull requests are very welcome. One of the goals of the pushpop-project is to get as many unique contributors as possible. Beginners welcome too!
 
 ##### Wishlist
 
@@ -442,10 +357,3 @@ Please make sure the specs pass before you submit your pull request. Pushpop has
 ``` shell
 $ bundle exec rake spec
 ```
-
-## Inspirations
-
-> "Technology shouldn't require all of our attention, just some of it, and only when necessary."
-> [calmtechnology.com](http://calmtechnology.com/)
-
-Dashboards and reports are human presentation vehicles. They require our attention in order to gain meaning. That's great when we're actively seeking answers and want to explore. But as a means to become aware of interesting, timely events it's neither effective nor efficient. A tool like Pushpop works better in those cases. It's a calmer technology.

data/Rakefile

@@ -12,37 +12,3 @@ begin
   task default: :spec
 rescue LoadError
 end
-
-def require_jobfiles(args)
-  require 'pushpop'
-  if jobfile = args[:jobfile]
-    load "#{File.dirname(__FILE__)}/#{jobfile}"
-  else
-    Dir.glob("#{File.dirname(__FILE__)}/jobs/**/*.rb").each { |file|
-      require file
-    }
-  end
-end
-
-namespace :jobs do
-  desc 'Describe jobs'
-  task :describe, :jobfile do |_, args|
-    require_jobfiles(args)
-    Pushpop.jobs.each do |job|
-      puts job.name
-    end
-  end
-
-  desc 'Run each job once'
-  task :run_once, :jobfile do |_, args|
-    require_jobfiles(args)
-    Pushpop.run
-  end
-
-  desc 'Run jobs ongoing'
-  task :run, :jobfile do |_, args|
-    require_jobfiles(args)
-    Pushpop.schedule
-    Clockwork.manager.run
-  end
-end

data/bin/pushpop

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$stdout.sync = true
+
+require 'pushpop'
+require 'pushpop/cli'
+
+Pushpop::CLI.start

data/lib/pushpop.rb

@@ -3,6 +3,7 @@ require 'clockwork'
 require 'pushpop/version'
 require 'pushpop/job'
 require 'pushpop/step'
+require 'pushpop/cli'
 
 module Pushpop
   class << self

data/lib/pushpop/cli.rb

@@ -0,0 +1,77 @@
+require 'thor'
+require 'dotenv'
+require 'pushpop'
+
+module Pushpop
+  class CLI < Thor
+
+    def self.file_options
+      option :file, :aliases => '-f'
+    end
+
+    desc 'version', 'Print the Pushpop version'
+    map %w(-v --version) => :version
+
+    def version
+      "Pushpop version #{Pushpop::VERSION}".tap do |s|
+        puts s
+      end
+    end
+
+    desc 'jobs:describe', 'Describe jobs'
+    map 'jobs:describe' => 'describe_jobs'
+    file_options
+
+    def describe_jobs
+      Dotenv.load
+      require_file(options[:file])
+      Pushpop.jobs.tap do |jobs|
+        jobs.each do |job|
+          puts job.name
+        end
+      end
+    end
+
+    desc 'jobs:run_once', 'Run jobs once'
+    map 'jobs:run_once' => 'run_jobs_once'
+    file_options
+
+    def run_jobs_once
+      Dotenv.load
+      require_file(options[:file])
+      Pushpop.run
+    end
+
+    desc 'jobs:run', 'Run jobs ongoing'
+    map 'jobs:run' => 'run_jobs'
+    file_options
+
+    def run_jobs
+      Dotenv.load
+      require_file(options[:file])
+      Pushpop.schedule
+      Clockwork.manager.run
+    end
+
+    private
+
+    def require_file(file)
+      if file
+        if File.directory?(file)
+          Dir.glob("#{file}/**/*.rb").each { |file|
+            load "#{Dir.pwd}/#{file}"
+          }
+        else
+          load file
+        end
+      else
+        Dir.glob("#{Dir.pwd}/jobs/**/*.rb").each { |file|
+          load file
+        }
+      end
+    end
+
+  end
+end
+
+

data/lib/pushpop/job.rb

@@ -71,7 +71,7 @@ module Pushpop
       end
 
       # log responses in debug
-      Pushpop.logger.info("#{name}: #{step_responses}")
+      Pushpop.logger.debug("#{name}: #{step_responses}")
 
       # return the last response and all responses
       [last_response, step_responses]

data/lib/pushpop/version.rb

@@ -1,3 +1,3 @@
 module Pushpop
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/pushpop.gemspec

@@ -9,10 +9,12 @@ Gem::Specification.new do |s|
   s.authors     = ["Josh Dzielak"]
   s.email       = "josh@keen.io"
   s.homepage    = "https://github.com/pushpop-project/pushpop"
-  s.summary     = "Share data between services at regular intervals"
-  s.description = "Pushpop is a simple but powerful Ruby app that sends notifications about events captured with Keen IO."
+  s.summary     = "A framework for scheduled integrations between popular services"
+  s.description = "Pushpop is a powerful framework for taking actions and integrating services at regular intervals."
 
   s.add_dependency "clockwork"
+  s.add_dependency "thor"
+  s.add_dependency "dotenv"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/pushpop/cli_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Pushpop::CLI do
+
+  def start(str=nil)
+    Pushpop::CLI.start(str ? str.split(" ") : [])
+  end
+
+  it 'prints help by default' do
+    _, options = start
+    expect(_).to be_empty
+  end
+
+  describe 'with -v' do
+    it 'prints the version' do
+      _, options = start('-v')
+      expect(_).to match('Pushpop version')
+    end
+  end
+
+  describe 'jobs:describe' do
+    it 'prints job information' do
+      _, options = start('jobs:describe --file spec/jobs')
+      expect(_.name).to eq('Simple Math')
+    end
+  end
+
+  describe 'jobs:run_once' do
+    it 'runs jobs once' do
+      _, options = start('jobs:run_once --file spec/jobs')
+      expect(_.first).to equal(30)
+    end
+  end
+
+end

data/spec/pushpop/job_spec.rb

@@ -6,44 +6,44 @@ describe Pushpop::Job do
   let (:empty_step) { Pushpop::Step.new('bar') do end }
 
   describe '#register_plugins' do
-    it 'should register a plugin' do
+    it 'registers a plugin' do
       Pushpop::Job.register_plugin('blaz', Class)
-      Pushpop::Job.plugins['blaz'].should == Class
+      expect(Pushpop::Job.plugins['blaz']).to eq(Class)
     end
   end
 
   describe '#initialize' do
-    it 'should set a name and evaluate a block' do
+    it 'sets a name and evaluate a block' do
       block_ran = false
       job = Pushpop::Job.new('foo') do block_ran = true end
-      job.name.should == 'foo'
-      job.period.should be_nil
-      job.every_options.should == {}
-      block_ran.should be_true
+      expect(job.name).to eq('foo')
+      expect(job.period).to be_nil
+      expect(job.every_options).to eq({})
+      expect(block_ran).to be_truthy
     end
 
-    it 'should auto-generate a name' do
+    it 'auto-generates a name' do
       job = Pushpop::Job.new do end
-      job.name.should_not be_nil
+      expect(job.name).not_to be_nil
     end
   end
 
   describe '#every' do
-    it 'should set period and options' do
+    it 'sets period and options' do
       job = empty_job
       job.every(10.seconds, at: '01:02')
-      job.period.should == 10
-      job.every_options.should == { at: '01:02' }
+      expect(job.period).to eq(10)
+      expect(job.every_options).to eq({ at: '01:02' })
     end
   end
 
   describe '#step' do
-    it 'should add the step to the internal list of steps' do
+    it 'adds the step to the internal list of steps' do
       empty_proc = Proc.new {}
       job = empty_job
       job.step('blah', &empty_proc)
-      job.steps.first.name.should == 'blah'
-      job.steps.first.block.should == empty_proc
+      expect(job.steps.first.name).to eq('blah')
+      expect(job.steps.first.block).to eq(empty_proc)
     end
 
     context 'plugin specified' do
@@ -54,17 +54,17 @@ describe Pushpop::Job do
         Pushpop::Job.register_plugin('blaz', FakeStep)
       end
 
-      it 'should use the registered plugin to instantiate the class' do
+      it 'uses the registered plugin to instantiate the class' do
         empty_proc = Proc.new {}
         job = empty_job
         job.step('blah', 'blaz', &empty_proc)
-        job.steps.first.name.should == 'blah'
-        job.steps.first.plugin.should == 'blaz'
-        job.steps.first.class.should == FakeStep
-        job.steps.first.block.should == empty_proc
+        expect(job.steps.first.name).to eq('blah')
+        expect(job.steps.first.plugin).to eq('blaz')
+        expect(job.steps.first.class).to eq(FakeStep)
+        expect(job.steps.first.block).to eq(empty_proc)
       end
 
-      it 'should throw an exception for an unregistered plugin' do
+      it 'throws an exception for an unregistered plugin' do
         empty_proc = Proc.new {}
         job = empty_job
         expect {
@@ -75,7 +75,7 @@ describe Pushpop::Job do
   end
 
   describe '#run' do
-    it 'should call each step with the response to the previous' do
+    it 'calls each step with the response to the previous' do
       job = Pushpop::Job.new('foo') do
         step 'one' do
           10
@@ -85,12 +85,12 @@ describe Pushpop::Job do
           response + 20
         end
       end
-      job.run.should == [30, { 'one' => 10, 'two' => 30 }]
+      expect(job.run).to eq([30, { 'one' => 10, 'two' => 30 }])
     end
   end
 
   describe '#schedule' do
-    it 'should add the job to clockwork' do
+    it 'adds the job to clockwork' do
       period = 1.seconds
       simple_job = Pushpop::Job.new('foo') do
         every period
@@ -103,12 +103,12 @@ describe Pushpop::Job do
       simple_job.schedule
 
       Clockwork.manager.tick(Time.now)
-      simple_job.run.first.should == 2
+      expect(simple_job.run.first).to eq(2)
       Clockwork.manager.tick(Time.now + period)
-      simple_job.run.first.should == 4
+      expect(simple_job.run.first).to eq(4)
     end
 
-     it 'should fail if the period was not specified' do
+     it 'fails if the period was not specified' do
        simple_job = Pushpop::Job.new('foo') do end
        expect {
          simple_job.schedule
@@ -123,26 +123,26 @@ describe Pushpop::Job do
     before do
     end
 
-    it 'should assume its a registered plugin name and try to create a step' do
+    it 'assumes its a registered plugin name and try to create a step' do
       Pushpop::Job.register_plugin('blaz', FakeStep)
       simple_job = job do
         blaz 'hi' do end
       end
-      simple_job.steps.first.name.should == 'hi'
-      simple_job.steps.first.class.should == FakeStep
+      expect(simple_job.steps.first.name).to eq('hi')
+      expect(simple_job.steps.first.class).to eq(FakeStep)
     end
 
-    it 'should not assume a name' do
+    it 'does not assume a name' do
       Pushpop::Job.register_plugin('blaz', FakeStep)
       simple_job = job do
         blaz do end
       end
-      simple_job.steps.first.name.should_not be_nil
-      simple_job.steps.first.plugin.should == 'blaz'
-      simple_job.steps.first.class.should == FakeStep
+      expect(simple_job.steps.first.name).not_to be_nil
+      expect(simple_job.steps.first.plugin).to eq('blaz')
+      expect(simple_job.steps.first.class).to eq(FakeStep)
     end
 
-    it 'should raise an exception if there is no registered plugin' do
+    it 'raises an exception if there is no registered plugin' do
       expect {
         job do
           blaze do end

data/spec/pushpop/step_spec.rb

@@ -6,72 +6,72 @@ describe Pushpop::Step do
 
   describe 'initialize' do
 
-    it 'should set a name, a plugin, and a block' do
+    it 'sets a name, a plugin, and a block' do
       empty_proc = Proc.new {}
       step = Pushpop::Step.new('foo', 'foopie', &empty_proc)
-      step.name.should == 'foo'
-      step.plugin.should == 'foopie'
-      step.block.should == empty_proc
+      expect(step.name).to eq('foo')
+      expect(step.plugin).to eq('foopie')
+      expect(step.block).to eq(empty_proc)
     end
 
-    it 'should auto-generate a name if not given and plugin not given' do
+    it 'auto-generates a name if not given and plugin not given' do
       empty_proc = Proc.new {}
       step = Pushpop::Step.new(&empty_proc)
-      step.name.should_not be_nil
-      step.plugin.should be_nil
-      step.block.should == empty_proc
+      expect(step.name).not_to be_nil
+      expect(step.plugin).to be_nil
+      expect(step.block).to eq(empty_proc)
     end
 
-    it 'should set name to plugin name if not given' do
+    it 'sets name to plugin name if not given' do
       empty_proc = Proc.new {}
       step = Pushpop::Step.new(nil, 'whee', &empty_proc)
-      step.name.should == 'whee'
-      step.plugin.should == 'whee'
-      step.block.should == empty_proc
+      expect(step.name).to eq('whee')
+      expect(step.plugin).to eq('whee')
+      expect(step.block).to eq(empty_proc)
     end
 
-    it 'should not require a plugin' do
+    it 'does not require a plugin' do
       empty_proc = Proc.new {}
       step = Pushpop::Step.new('foo', &empty_proc)
-      step.name.should == 'foo'
-      step.block.should == empty_proc
+      expect(step.name).to eq('foo')
+      expect(step.block).to eq(empty_proc)
     end
 
   end
 
   describe 'run' do
 
-    it 'should call the block with the same args' do
+    it 'calls the block with the same args' do
       arg1, arg2 = nil
       times_run = 0
       empty_proc = Proc.new { |a1, a2| arg1 = a1; arg2 = a2; times_run += 1 }
       step = Pushpop::Step.new('foo', &empty_proc)
       step.run('foo', 'bar')
-      arg1.should == 'foo'
-      arg2.should == 'bar'
-      times_run.should == 1
+      expect(arg1).to eq('foo')
+      expect(arg2).to eq('bar')
+      expect(times_run).to eq(1)
     end
 
-    it 'should execute the block bound to the step' do
+    it 'executes the block bound to the step' do
       _self = nil
       step = Pushpop::Step.new(nil, nil) do
         _self = self
       end
       step.run
-      _self.should == step
+      expect(_self).to eq(step)
     end
 
   end
 
   describe 'template' do
-    it 'should render the named template with the response binding' do
+    it 'renders the named template with the response binding' do
       step = Pushpop::Step.new
-      step.template('spec.html.erb', 500, {}, SPEC_TEMPLATES_DIRECTORY).strip.should == '<pre>500</pre>'
+      expect(step.template('spec.html.erb', 500, {}, SPEC_TEMPLATES_DIRECTORY).strip).to eq('<pre>500</pre>')
     end
 
-    it 'should render the named template with the step_response binding' do
+    it 'renders the named template with the step_response binding' do
       step = Pushpop::Step.new
-      step.template('spec.html.erb', nil, { test: 600 }, SPEC_TEMPLATES_DIRECTORY).strip.should == '<pre>600</pre>'
+      expect(step.template('spec.html.erb', nil, { test: 600 }, SPEC_TEMPLATES_DIRECTORY).strip).to eq('<pre>600</pre>')
     end
   end
 

data/spec/pushpop_spec.rb

@@ -1,24 +1,26 @@
 require 'spec_helper'
 
 describe 'job' do
-  job 'foo-main' do end
-  Pushpop.jobs.first.name.should == 'foo-main'
+  it 'has a name' do
+    job 'foo-main' do end
+    expect(Pushpop.jobs.first.name).to eq('foo-main')
+  end
 end
 
 describe Pushpop do
 
   describe 'add_job' do
-    it 'should add a job to the list' do
+    it 'adds a job to the list' do
       empty_proc = Proc.new {}
       Pushpop.add_job('foo', &empty_proc)
-      Pushpop.jobs.first.name.should == 'foo'
+      expect(Pushpop.jobs.first.name).to eq('foo')
     end
   end
 
   describe 'random_name' do
-    it 'should be 8 characters and alphanumeric' do
-      Pushpop.random_name.should =~ /^\w{8}$/
+    it 'is 8 characters and alphanumeric' do
+      expect(Pushpop.random_name).to match(/^\w{8}$/)
     end
   end
 
-end
+end

data/spec/simple_job_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 describe 'run a job end to end' do
-  it 'should run and return template contents' do
+  it 'runs and return template contents' do
     require File.expand_path('../jobs/simple_job', __FILE__)
-    Pushpop.jobs.length.should == 1
-    Pushpop.jobs.first.run.should == [30, { "return 10" => 10, "increase by 20" => 30}]
+    expect(Pushpop.jobs.length).to eq(1)
+    expect(Pushpop.jobs.first.run).to eq([30, { "return 10" => 10, "increase by 20" => 30}])
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pushpop
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-16 00:00:00.000000000 Z
+date: 2014-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clockwork
@@ -27,28 +27,61 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Pushpop is a simple but powerful Ruby app that sends notifications about
-  events captured with Keen IO.
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Pushpop is a powerful framework for taking actions and integrating services
+  at regular intervals.
 email: josh@keen.io
-executables: []
+executables:
+- pushpop
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
 - Gemfile
-- Gemfile.lock
 - LICENSE
-- Procfile
 - README.md
 - Rakefile
-- jobs/example_job.rb
+- bin/pushpop
 - lib/pushpop.rb
+- lib/pushpop/cli.rb
 - lib/pushpop/job.rb
 - lib/pushpop/step.rb
 - lib/pushpop/version.rb
 - pushpop.gemspec
 - spec/jobs/simple_job.rb
+- spec/pushpop/cli_spec.rb
 - spec/pushpop/job_spec.rb
 - spec/pushpop/step_spec.rb
 - spec/pushpop_spec.rb
@@ -79,12 +112,14 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Share data between services at regular intervals
+summary: A framework for scheduled integrations between popular services
 test_files:
 - spec/jobs/simple_job.rb
+- spec/pushpop/cli_spec.rb
 - spec/pushpop/job_spec.rb
 - spec/pushpop/step_spec.rb
 - spec/pushpop_spec.rb
 - spec/simple_job_spec.rb
 - spec/spec_helper.rb
 - spec/templates/spec.html.erb
+has_rdoc: 

data/Gemfile.lock

@@ -1,36 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (4.1.0)
-      i18n (~> 0.6, >= 0.6.9)
-      json (~> 1.7, >= 1.7.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.1)
-      tzinfo (~> 1.1)
-    clockwork (0.7.4)
-      activesupport
-      tzinfo
-    diff-lcs (1.2.5)
-    i18n (0.6.9)
-    json (1.8.1)
-    minitest (5.3.3)
-    rake (10.3.1)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.8)
-    rspec-expectations (2.14.5)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.6)
-    thread_safe (0.3.3)
-    tzinfo (1.1.0)
-      thread_safe (~> 0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  clockwork
-  rake
-  rspec

data/Procfile

@@ -1 +0,0 @@
-worker: bundle exec rake jobs:run

data/jobs/example_job.rb

@@ -1,20 +0,0 @@
-require 'pushpop'
-
-job 'Simple Math' do
-
-  every 1.minutes
-
-  step 'return 10' do 10 end
-
-  step 'increase by 20' do |response|
-    20 + response
-  end
-
-  step 'print out via template' do |response|
-    html = template 'first_template.html.erb', response
-    puts 'Hey Pushpop, let\'s do a math!'
-    puts html
-    html
-  end
-
-end