pushover 1.0.4 → 2.0.0

data/lib/pushover/mixins.rb

@@ -1,7 +0,0 @@
-class Hash
-  def first_pair
-    self.each do |k,v|
-    	return {k => v}
-    end
-  end
-end

data/lib/pushover/priority.rb

@@ -1,63 +0,0 @@
-module Pushover
-  module Priority
-    extend self
-
-    # A sash for our receipts.
-    Receipts = Bini::Sash.new options:{
-      file:"#{Bini.cache_dir}/receipts.yaml", auto_load:true, auto_save:true
-    }
-    LEVELS = {
-      low:-1,
-      normal:0,
-      high:1,
-      emergency:2
-    }
-
-    def priority=(level)
-      @priority = parse level
-    end
-
-    def parse(level)
-      return level if level.class == Fixnum
-      if level.class == String
-        LEVELS.each { |k,v| return v if k.to_s.start_with? level.downcase }
-      end
-
-      return 0
-    end
-
-    # Pull one from cache, or fetch one if not available.
-    def find_receipt(prefix)
-      results = Receipts.select { |k,v| k =~ /^#{prefix}/ }
-      return nil if results.empty?
-      return results.first_pair
-    end
-
-    def update_receipts
-      updates = Receipts.select {|k,v| v["acknowledged"] == 0 && v["expired"] == 0}
-      updates.keys.each do |key|
-        process_receipt key
-      end
-    end
-
-    def process_receipt(receipt)
-      r = fetch_receipt(receipt)
-
-      return nil if !r
-      Receipts[receipt] = r.to_h
-
-      return Receipts[receipt]
-    end
-
-    def is_emergency?(priority)
-      return true if priority && Pushover::Priority.parse(priority) == LEVELS[:emergency]
-      return false
-    end
-
-    private
-    def fetch_receipt(receipt)
-      HTTParty.get("https://api.pushover.net/1/receipts/#{receipt}.json",
-        body:{token:Pushover::App.current_app})
-    end
-  end
-end

data/lib/pushover/user.rb

@@ -1,68 +0,0 @@
-module Pushover
-	# The user module, saves any user information provided.
-	module User
-		# The User class, for a single instance of it.
-		# @!attribute name
-		# 	@return [String] the name of the user.
-		# @!attribute token
-		#   @return [String] the token of the user.
-		class User
-			attr_accessor :name
-			attr_accessor :token
-
-			def initialize(name, token)
-				@name = name
-				@token = token
-				Bini::Config[:users] = {} if !Bini::Config[:users]
-				Bini::Config[:users][name] = token
-			end
-
-		end
-
-		extend self
-
-		# Find the token in the users, or pass on the word to try direct access.
-		# @param [String] word the search token, can be an apikey or appname.
-		# @return [String] return the apikey (if it can find one) or the word itself.
-		def find(word)
-			return Bini::Config[:users][word] if Bini::Config[:users] && Bini::Config[:users][word]
-			word
-		end
-
-		# Add an application to the config file and save it.
-		# @param [String] token is the token to be used.
-		# @param [String] name is the short name that can be referenced later.
-		# @return [Boolean] return the results of the save attempt.
-		def add(name, token)
-			User.new name, token
-			Bini::Config.save
-		end
-
-		def remove(name)
-			Bini::Config[:users].delete name if Bini::Config[:users]
-		end
-
-		# Return the current user selected, or the first one saved.
-		def current_user
-			# did something get supplied on the cli? try to find it.
-			if Bini::Options[:user]
-				@current_user = Bini::Options[:user]
-			elsif !@current_user
-				@current_user = find Bini::Config[:users].values.first if Bini::Config[:users]
-			end
-
-			@current_user
-		end
-
-		# Set the current_user to whatever you want it to be.
-		def current_user=(user)
-			@current_user = user
-		end
-
-		# Will return true if it can find a user either via the cli or save file.
-		def current_user?
-			return true if current_user
-			return nil
-		end
-	end
-end

data/spec/bin/pushover_spec.rb

@@ -1,108 +0,0 @@
-# Since this testing requires an actual account, and a working internet, we don't
-# run it as part of the standard suite.
-# If you want to run these tests, add ENV["TEST_CLI"]
-# If you have a credentials file already, you might find it beeps you.
-
-# this should be a working cred file that can send messages for proper end to end testing.
-CRED_FILE = "#{Dir.home}/.config/pushover/credentials.yaml"
-FAKE_CRED_FILE = 'tmp/fake_credentials.yaml'
-CMD = 'bundle exec bin/pushover'
-
-require 'spec_helper.rb'
-require 'cli_spec_helper.rb'
-
-if ENV["TEST_CLI"] =~ /^t/
-  describe "CLI Interface" do
-    describe 'help' do
-      it 'has options' do
-        p = CLIProcess.new "#{CMD} --help"
-        p.run!
-        words = /user|app|title|priority|url|url_title|save-app|save-user|time|version/
-        p.stdout.should =~ words
-      end
-    end
-
-    describe "send" do
-      it "sends messages" do
-          p = CLIProcess.new "#{CMD} --config_file #{CRED_FILE} a message", 3, 3
-          p.run!
-          p.stdout.should include("success"), "#{p.stderr}"
-      end
-
-      it "sends messages (no credentials file)" do
-          # for this trick, lets extract our creds from the cred file manually.
-          # store them locally,then pass them back as app/user arguments.
-          creds = YAML.load open(CRED_FILE).read
-
-          app =  creds[:applications].first.values.first
-          user = creds[:users].first.values.first
-          p = CLIProcess.new "#{CMD} -a #{app} -u #{user} a message", 3, 3
-          p.run!
-          p.stdout.should include("success"), "#{p.stderr}"
-      end
-
-      it "lets me know when a message fails" do
-        p = CLIProcess.new "#{CMD} --app fail --user now message goes here", 3, 3
-        p.run!
-        p.stdout.should include "ErrorCode"
-      end
-    end
-
-    describe "saving" do
-      it "saves app:key pairs" do
-        p = CLIProcess.new "#{CMD} --config_file #{FAKE_CRED_FILE} --save-app saveapp --app application"
-        p.run!
-        p.stdout.should include 'Saved'
-        output = YAML.load open(FAKE_CRED_FILE).read
-        output[:applications]["saveapp"].should eq 'application'
-      end
-      it "saves user:token pairs" do
-        p = CLIProcess.new "#{CMD} --config_file #{FAKE_CRED_FILE} --save-user saveuser --user user"
-        p.run!
-        p.stdout.should include 'Saved'
-        output = YAML.load open(FAKE_CRED_FILE).read
-        output[:users]["saveuser"].should eq 'user'
-      end
-    end
-    describe "sounds" do
-      it "will list sounds" do
-        p = CLIProcess.new "#{CMD} --config_file #{CRED_FILE} --sound_list", 3, 3
-        p.run!
-        p.stdout.should include "Current Sound"
-        p.stdout.should include "Pushover (default)"
-        p.stdout.should include "None (silent)"
-      end
-      it "will play a sound (based on partial string)" do
-        p = CLIProcess.new "#{CMD} --config_file #{CRED_FILE} a message --sound none", 3, 3
-        p.run!
-        p.stdout.should include "success"
-      end
-      it "will fail if the sound is unavailble" do
-        p = CLIProcess.new "#{CMD} --config_file #{CRED_FILE} a message --sound slkdjg", 3, 3
-        p.run!
-        p.stdout.should include "No such sound"
-      end
-    end
-    describe "emergency notifications" do
-      it "will respond to emergency parameters" do
-        p = CLIProcess.new "#{CMD} --config_file #{CRED_FILE} an emergency message retry test --priority em --emergency_retry 180", 3, 3
-        p.run!
-        p.stdout.should include "success"
-
-        p = CLIProcess.new "#{CMD} --config_file #{CRED_FILE} an emergency message expires test --priority em --emergency_expire 7200", 3, 3
-        p.run!
-        p.stdout.should include "success"
-      end
-
-      it "will print the receipt" do
-        p = CLIProcess.new "#{CMD} --config_file #{CRED_FILE} an emergency message --priority em", 3, 3
-        p.run!
-        p.stdout.should include "receipt"
-      end
-
-      it "will accept a callback url"
-    end
-  end
-end
-
-

data/spec/cli_spec_helper.rb

@@ -1,99 +0,0 @@
-# Ripped without remorse from: https://github.com/cucumber/aruba/blob/master/lib/aruba/process.rb
-# slightly modified for my purposes.
-require 'childprocess'
-require 'tempfile'
-require 'shellwords'
-
-class CLIProcess
-  include Shellwords
-
-  def initialize(cmd, exit_timeout = 0, io_wait = 1)
-    @exit_timeout = exit_timeout
-    @io_wait = io_wait
-    @io_waited = false
-
-    @cmd = cmd
-    @process = nil
-    @exit_code = nil
-  end
-
-  def run!(&block)
-    @process = ChildProcess.build(*shellwords(@cmd))
-    @out = Tempfile.new("binary-out")
-    @err = Tempfile.new("binary-err")
-    @process.io.stdout = @out
-    @process.io.stderr = @err
-    @process.duplex = true
-    @exit_code = nil
-    begin
-      @process.start
-    rescue ChildProcess::LaunchError => e
-      raise LaunchError.new(e.message)
-    end
-    yield self if block_given?
-  end
-
-  def stdin
-    @process.io.stdin
-  end
-
-  def output(keep_ansi = false)
-    stdout(keep_ansi) + stderr(keep_ansi)
-  end
-
-  def stdout(keep_ansi = false)
-    wait_for_io do
-      @out.rewind
-      filter_ansi(@out.read, keep_ansi)
-    end
-  end
-
-  def stderr(keep_ansi = false)
-    wait_for_io do
-      @err.rewind
-      filter_ansi(@err.read, keep_ansi)
-    end
-  end
-
-  def read_stdout(keep_ansi = false)
-    wait_for_io do
-      @process.io.stdout.flush
-      content = filter_ansi(open(@out.path).read, keep_ansi)
-    end
-  end
-
-  def stop(reader, keep_ansi)
-    return @exit_code unless @process
-    unless @process.exited?
-      @process.poll_for_exit(@exit_timeout)
-    end
-    reader.stdout stdout(keep_ansi)
-    reader.stderr stderr(keep_ansi)
-    @exit_code = @process.exit_code
-    @process = nil
-    @exit_code
-  end
-
-  def terminate(keep_ansi = false)
-    if @process
-      stdout(keep_ansi = false) && stderr(keep_ansi) # flush output
-      @process.stop
-      stdout(keep_ansi) && stderr(keep_ansi) # flush output
-    end
-  end
-
-  private
-
-  def wait_for_io(&block)
-    if @process && !@io_waited
-      sleep @io_wait
-      @io_waited = true
-    end
-    yield
-  end
-
-  def filter_ansi(string, keep_ansi)
-    keep_ansi ? string : string.gsub(/\e\[\d+(?>(;\d+)*)m/, '')
-  end
-
-end

data/spec/lib/pushover/app_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-describe "application" do
-	before(:each) do
-		Bini::Config.clear
-		Bini::Options.clear
-		App.current_app = nil
-	end
-
-	it "can add a application to the Config[:application] hash." do
-		App.add "foo", "bar"
-		Bini::Config[:applications]["foo"].should eq("bar")
-	end
-
-	it "can remove a application from the hash." do
-		App.add "foo", "bar"
-		App.remove "foo"
-		Bini::Config[:applications]["foo"].should be_nil
-	end
-
-	describe "#find" do
-		it "can find the apikey from the name" do
-			App.add "foo", "bar"
-			App.find("foo").should eq("bar")
-		end
-		it "If it can't find the apikey, it will still try whatever was passed" do
-			App.find("tryme").should eq "tryme"
-		end
-	end
-
-	describe "#current_app" do
-		it "will look on the cli first" do
-			Bini::Options[:token] = 'anapikey'
-			App.current_app.should eq "anapikey"
-		end
-		it "will grab the first app in the config as a last resort" do
-			App.add "foo", "bar2"
-			Bini::Config.save
-			Bini::Options[:token] = nil
-			App.current_app.should eq "bar2"
-		end
-	end
-
-	describe "#current_app?" do
-		it "Will return true if we have a current_app" do
-			Bini::Options[:token] = 'somethingsilly'
-			App.current_app.should eq 'somethingsilly'
-		end
-		it "Will return nil otherwise" do
-			App.current_app?.should be_nil
-		end
-	end
-end
-

data/spec/lib/pushover/user_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe "user" do
-	before(:each) do
-		Bini::Config.clear
-		Bini::Options.clear
-		User.current_user = nil
-	end
-
-	it "can add a user to the Config[:users] hash." do
-		User.add "foo", "bar"
-		Bini::Config[:users]["foo"].should eq("bar")
-	end
-
-	it "can remove a user from the hash." do
-		User.add "foo", "bar"
-		User.remove "foo"
-		Bini::Config[:users]["foo"].should be_nil
-	end
-
-	describe "#find" do
-		it "can find the token from the name" do
-			User.add "foo", "bar"
-			User.find("foo").should eq("bar")
-		end
-		it "If it can't find the token, it will still try whatever was passed" do
-			User.find("tryme").should eq "tryme"
-		end
-	end
-
-	describe "#current_user" do
-		it "will look on the cli first" do
-			Bini::Options[:user] = 'atoken'
-			User.current_user.should eq "atoken"
-		end
-		it "will grab the first user in the config as a last resort" do
-			User.add "foo", "bar2"
-			Bini::Config.save
-			Bini::Options[:user] = nil
-			User.current_user.should eq "bar2"
-		end
-	end
-
-	describe "#current_user?" do
-		it "Will return true if we have a current_user" do
-			Bini::Options[:user] = 'somethingsilly'
-			User.current_user?.should be_true
-		end
-		it "Will return nil otherwise" do
-			User.current_user?.should be_nil
-		end
-	end
-end