pushpop 0.1.0

data/Rakefile

@@ -0,0 +1,48 @@
+$stdout.sync = true
+
+$: << File.join(File.dirname(__FILE__), './lib')
+
+begin
+  require 'rspec/core/rake_task'
+  desc 'Run Rspec unit tests'
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.pattern = 'spec/**/*_spec.rb'
+  end
+
+  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/jobs/example_job.rb

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

data/lib/plugins/keen.rb

@@ -0,0 +1,78 @@
+require 'keen'
+
+module Pushpop
+
+  class Keen < Step
+
+    PLUGIN_NAME = 'keen'
+
+    attr_accessor :_event_collection
+    attr_accessor :_analysis_type
+    attr_accessor :_timeframe
+    attr_accessor :_target_property
+    attr_accessor :_group_by
+    attr_accessor :_interval
+    attr_accessor :_filters
+    attr_accessor :_steps
+    attr_accessor :_analyses
+
+    def run(last_response=nil, step_responses=nil)
+      self.configure(last_response, step_responses)
+      ::Keen.send(self._analysis_type, self._event_collection, self.to_analysis_options)
+    end
+
+    def configure(last_response=nil, step_responses=nil)
+      self.instance_exec(last_response, step_responses, &block)
+    end
+
+    def to_analysis_options
+      { timeframe: self._timeframe,
+        target_property: self._target_property,
+        group_by: self._group_by,
+        interval: self._interval,
+        filters: self._filters,
+        analyses: self._analyses,
+        steps: self._steps
+      }.delete_if { |_, v| v.nil? }
+    end
+
+    def event_collection(event_collection)
+      self._event_collection = event_collection
+    end
+
+    def analysis_type(analysis_type)
+      self._analysis_type = analysis_type
+    end
+
+    def timeframe(timeframe)
+      self._timeframe = timeframe
+    end
+
+    def target_property(target_property)
+      self._target_property = target_property
+    end
+
+    def group_by(group_by)
+      self._group_by = group_by
+    end
+
+    def interval(interval)
+      self._interval = interval
+    end
+
+    def filters(filters)
+      self._filters = filters
+    end
+
+    def steps(steps)
+      self._steps = steps
+    end
+
+    def analyses(analyses)
+      self._analyses = analyses
+    end
+
+  end
+
+  Pushpop::Job.register_plugin(Keen::PLUGIN_NAME, Keen)
+end

data/lib/plugins/sendgrid.rb

@@ -0,0 +1,94 @@
+require 'mail'
+
+Mail.defaults do
+  delivery_method :smtp, { address:   'smtp.sendgrid.net',
+                           port:      587,
+                           domain:    ENV['SENDGRID_DOMAIN'],
+                           user_name: ENV['SENDGRID_USERNAME'],
+                           password:  ENV['SENDGRID_PASSWORD'],
+                           authentication: 'plain',
+                           enable_starttls_auto: true }
+end
+
+module Pushpop
+
+  class Sendgrid < Step
+
+    PLUGIN_NAME = 'sendgrid'
+
+    attr_accessor :_from
+    attr_accessor :_to
+    attr_accessor :_subject
+    attr_accessor :_body
+    attr_accessor :_preview
+
+    def run(last_response=nil, step_responses=nil)
+
+      self.configure(last_response, step_responses)
+
+      # print the message if its just a preview
+      return print_preview if self._preview
+
+      _to = self._to
+      _from = self._from
+      _subject = self._subject
+      _body = self._body
+
+      Mail.deliver do
+        to _to
+        from _from
+        subject _subject
+        text_part do
+          body _body
+        end
+        html_part do
+          content_type 'text/html; charset=UTF-8'
+          body _body
+        end
+      end
+    end
+
+    def configure(last_response=nil, step_responses=nil)
+      self.instance_exec(last_response, step_responses, &block)
+    end
+
+    def from(from)
+      self._from = from
+    end
+
+    def to(to)
+      self._to = to
+    end
+
+    def subject(subject)
+      self._subject = subject
+    end
+
+    def preview(preview)
+      self._preview = preview
+    end
+
+    def body(*args)
+      if args.length == 1
+        self._body = args.first
+      else
+        self._body = template *args
+      end
+    end
+
+    private
+
+    def print_preview
+      puts <<MESSAGE
+To: #{self._to}
+From: #{self._from}
+Subject: #{self._subject}
+
+      #{self._body}
+MESSAGE
+    end
+
+  end
+
+  Pushpop::Job.register_plugin(Sendgrid::PLUGIN_NAME, Sendgrid)
+end

data/lib/plugins/twilio.rb

@@ -0,0 +1,52 @@
+require 'twilio-ruby'
+
+TWILIO_SID = ENV['TWILIO_SID']
+TWILIO_AUTH_TOKEN = ENV['TWILIO_AUTH_TOKEN']
+TWILIO_FROM = ENV['TWILIO_FROM']
+
+module Pushpop
+
+  class Twilio < Step
+
+    PLUGIN_NAME = 'twilio'
+
+    attr_accessor :_from
+    attr_accessor :_to
+    attr_accessor :_body
+
+    def run(last_response=nil, step_responses=nil)
+
+      self.configure(last_response, step_responses)
+
+      _to = self._to
+      _from = self._from || TWILIO_FROM
+      _body = self._body
+
+      client = ::Twilio::REST::Client.new(TWILIO_SID, TWILIO_AUTH_TOKEN)
+
+      client.account.messages.create(
+          from: _from,
+          to: _to,
+          body: _body )
+    end
+
+    def configure(last_response=nil, step_responses=nil)
+      self.instance_exec(last_response, step_responses, &block)
+    end
+
+    def from(from)
+      self._from = from
+    end
+
+    def to(to)
+      self._to = to
+    end
+
+    def body(body)
+      self._body = body
+    end
+
+  end
+
+  Pushpop::Job.register_plugin(Twilio::PLUGIN_NAME, Twilio)
+end

data/lib/pushpop.rb

@@ -0,0 +1,55 @@
+require 'logger'
+require 'clockwork'
+require 'pushpop/version'
+require 'pushpop/job'
+require 'pushpop/step'
+
+# require all plugins
+Dir["#{File.expand_path('../plugins/*', __FILE__)}.rb"].each { |file|
+  require file
+}
+
+module Pushpop
+  class << self
+    cattr_accessor :logger
+    cattr_accessor :jobs
+
+    # for jobs and steps
+    def random_name
+      (0...8).map { (65 + rand(26)).chr }.join
+    end
+
+    self.jobs = []
+
+    def add_job(name=nil, &block)
+      self.jobs.push(Job.new(name, &block))
+      self.jobs.last
+    end
+
+    def run
+      self.jobs.map &:run
+    end
+
+    def schedule
+      self.jobs.map &:schedule
+    end
+  end
+end
+
+# add into main
+def job(name=nil, &block)
+  Pushpop.add_job(name, &block)
+end
+
+Pushpop.logger = lambda {
+  logger = Logger.new($stdout)
+  if ENV['DEBUG']
+    logger.level = Logger::DEBUG
+  elsif ENV['RACK_ENV'] == 'test'
+    logger.level = Logger::FATAL
+  else
+    logger.level = Logger::INFO
+  end
+  logger
+}.call
+

data/lib/pushpop/job.rb

@@ -0,0 +1,95 @@
+module Pushpop
+
+  class Job
+
+    class << self
+
+      cattr_accessor :plugins
+      self.plugins = {}
+
+      def register_plugin(name, klass)
+        self.plugins ||= {}
+        self.plugins[name.to_s] = klass
+      end
+
+    end
+
+    attr_accessor :name
+    attr_accessor :every_duration
+    attr_accessor :every_options
+    attr_accessor :steps
+
+    def initialize(name=nil, &block)
+      self.name = name || Pushpop.random_name
+      self.steps = []
+      self.every_options = {}
+      self.instance_eval(&block)
+    end
+
+    def every(duration, options={})
+      self.every_duration = duration
+      self.every_options = options
+    end
+
+    def step(name=nil, plugin=nil, &block)
+      if plugin
+
+        plugin_klass = self.class.plugins[plugin]
+        raise "No plugin configured for #{plugin}" unless plugin_klass
+
+        self.add_step(plugin_klass.new(name, plugin, &block))
+      else
+        self.add_step(Step.new(name, plugin, &block))
+      end
+    end
+
+    def add_step(step)
+      self.steps.push(step)
+    end
+
+    def schedule
+      Clockwork.manager.every(every_duration, name, every_options) do
+        run
+      end
+    end
+
+    def run
+
+      # track the last response, and all responses
+      last_response = nil
+      step_responses = {}
+
+      self.steps.each do |step|
+
+        # track the last_response and all responses
+        last_response = step.run(last_response, step_responses)
+        step_responses[step.name] = last_response
+
+        # abort unless this step returned truthily
+        return unless last_response
+      end
+
+      # log responses in debug
+      Pushpop.logger.info("#{name}: #{step_responses}")
+
+      # return the last response and all responses
+      [last_response, step_responses]
+    end
+
+    def method_missing(method, *args, &block)
+      plugin_class = self.class.plugins[method.to_s]
+
+      name = args[0]
+      plugin = method.to_s
+
+      if plugin_class
+        step(name, plugin, &block)
+      else
+        super
+      end
+    end
+
+  end
+
+end
+