hookly 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8fa80ff4c39928e6d5e8a0a6f789c7346d0da23f
+  data.tar.gz: e751e4408f4e131e8a9856d2315b10ff21ba359f
+SHA512:
+  metadata.gz: 7bb848c28200fbfe0fc742091f34b8196dcfd2100189fa16c609e6dede135ae7295c15883c073861993b8e713e4b93680303d2c4f4671d6243ae53395e68aef5
+  data.tar.gz: cc8ae03b69889979098c526bce2da03b5f8c9164ef2f1646df0ad218085ae7ab235e8b4b69d11df3d88b007a2712e0179c07408fe689c895f3dfe153afbabfec

data/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+
+*.gem
+.bundle
+Gemfile.lock
+
+tmp
+.ruby-version
+.ruby-gemset

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Brian Norton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,75 @@
+#hookly-rails
+
+1. Ruby wrapper for the Hookly API
+2. hookly.js asset pipeline provider/wrapper
+
+Rails 3.1+ asset-pipeline gem to provide hookly.js
+
+#Setup
+
+Add to your Gemfile:
+
+```ruby
+gem 'hookly-rails'
+```
+
+###JS Setup
+Then add this to you application.js manifest:
+
+```javascript
+//= require hookly
+```
+
+Then check out the [hookly.js docs](https://github.com/bnorton/hookly.js) for usage and working examples
+
+###API Setup
+
+```ruby
+# config/initializers/hookly.rb
+Hookly.token = '{{token}}'
+Hookly.secret = '{{secret}}'
+```
+
+###Post a message to the #updates channel
+
+In the client javascript subscribe to '#updates'
+```javascript
+hookly.setup('{{token}}')
+hookly.on('#updates', function(options) {
+  // options == { model: 'Message', id: 5, text: 'Thanks for the info.' }
+});
+```
+
+The push a new message the updates channel
+```ruby
+Hookly::Channel.new('#updates').push(model: 'Message', id: 5, text: 'Thanks for the info.')
+ #=> #<Hookly::Message id: '44fjwq-djas' slug: '#updates', data: { model: 'Message', id: 5, text: 'Thanks for the info.' }>
+```
+
+###Post a **private** message
+
+Have information that only a certain user should see??
+
+Include a unique user id on the client and server
+
+```javascript
+hookly.setup('{{token}}', '{{uid}}')
+hookly.on('#updates', function(options) {
+  // options == { model: 'Message', id: 6, text: 'Thanks for the PRIVATE info.' }
+});
+```
+
+```ruby
+Hookly::Channel.new('#updates', uid: '{{uid}}').push(model: 'Message', id: 6, text: 'Thanks for the PRIVATE info.')
+ #=> #<Hookly::Message id: '44fjwq-djas' slug: '#updates', uid: '{{uid}}' data: { model: 'Message', id: 6, text: 'Thanks for the PRIVATE info.' }>
+```
+
+
+<!--- Not yet implemented
+###Message buffering / caching
+A channel can be setup to buffer messages and deliver them when a user comes online.
+Simply create a buffered channel, messages will be cached for 60 minutes following their receipt
+```ruby
+Hookly::Channel.create(buffer: 3600)
+```
+-->

data/hookly.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'hookly/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'hookly'
+  s.version     = Hookly::VERSION
+  s.authors     = ['Brian Norton']
+  s.email       = ['brian.nort@gmail.com']
+  s.homepage    = 'https://github.com/bnorton/hookly-rails'
+  s.summary     = %q{hookly.js asset pipeline provider/wrapper. Ruby wrapper for the Hookly API}
+  s.license     = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'rspec', '~> 3.2'
+  s.add_development_dependency 'webmock', '~> 1.21'
+
+  s.add_dependency 'typhoeus', '~> 0.7'
+end

data/lib/error.rb

@@ -0,0 +1 @@
+require 'errors/response_error'

data/lib/errors/response_error.rb

@@ -0,0 +1,7 @@
+module Hookly
+  class ResponseError < StandardError
+    def initialize(response)
+      super "The request failed with code: `#{response.response_code}`"
+    end
+  end
+end

data/lib/hookly/version.rb

@@ -0,0 +1,8 @@
+module Hookly
+  MAJOR = 0
+  MINOR = 9
+  PATCH = 0
+  PRE   = nil
+
+  VERSION = [MAJOR, MINOR, PATCH, PRE].map(&:freeze).compact.join('.').freeze
+end

data/lib/hookly.rb

@@ -0,0 +1,31 @@
+##
+# Dependencies
+#
+require 'json'
+require 'typhoeus'
+
+##
+# Project files
+#
+require 'request'
+require 'message'
+require 'error'
+
+module Hookly
+  %i(token secret url).each do |name|
+    define_singleton_method(name, &-> { instance_variable_get(:"@#{name}") })
+    define_singleton_method("#{name}=", &->(v) { instance_variable_set(:"@#{name}", v) })
+  end
+
+  module Rails
+    if defined?(::Rails)
+      class Rails::Engine < ::Rails::Engine
+        # this will enable the asset pipeline
+      end
+    end
+  end
+end
+
+require 'hookly/version'
+
+Hookly.url = 'https://hookly.herokuapp.com'

data/lib/message.rb

@@ -0,0 +1,18 @@
+module Hookly
+  class Message
+    attr_reader :id, :slug, :uid, :body
+
+    def self.create(slug, *args)
+      body = args.pop
+
+      new(Request.run(:post, :messages, { slug: slug, :uid => args.last }, body))
+    end
+
+    def initialize(options)
+      @id = options['id']
+      @slug = options['slug']
+      @uid = options['uid']
+      @body = options['body']
+    end
+  end
+end

data/lib/request.rb

@@ -0,0 +1,35 @@
+module Hookly
+  class Request
+    def self.run(name, path, options, body={})
+      request_options = {
+        method: name,
+        accept_encoding: :gzip,
+        headers: { 'Content-Type' => 'application/json', 'User-Agent' => user_agent }
+      }
+
+      request_options[body_param(name)] = processed_body(name, options.merge( secret: Hookly.secret, :body => body ))
+
+      response = Typhoeus::Request.new("#{Hookly.url}/#{path}", request_options).run
+
+      if response.success?
+        JSON.parse(response.response_body)['message']
+      else
+        raise ResponseError.new(response)
+      end
+    end
+
+    private
+
+    def self.user_agent
+      "hookly-rails [language(ruby), lib-version(#{Hookly::VERSION}), platform(#{RUBY_PLATFORM}), platform-version(#{RUBY_VERSION})]"
+    end
+
+    def self.body_param(name)
+      %w(get delete).include?(name.to_s) ? :params : :body
+    end
+
+    def self.processed_body(name, options)
+      %w(get delete).include?(name.to_s) ? options : JSON.dump(options)
+    end
+  end
+end

data/spec/helpers/response_helper.rb

@@ -0,0 +1,3 @@
+def run_response(options)
+  JSON.parse(options.to_json)
+end

data/spec/helpers/tokens_helper.rb

@@ -0,0 +1,3 @@
+Hookly.token = 'test-config-token'
+Hookly.secret = 'test-config-secret'
+Hookly.url = 'http://test.host:1234'

data/spec/lib/message_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Hookly::Message do
+  describe '.create' do
+    let(:options) { { id: 5, text: 'Thanks for the information!' } }
+    let(:create) { described_class.create('#updates', options) }
+
+    let!(:response) { run_response(id: 1440, slug: '#updates', body: options) }
+
+    before do
+      allow(Hookly::Request).to receive(:run).and_return(response)
+    end
+
+    it 'should post to messages' do
+      expect(Hookly::Request).to receive(:run).with(:post, :messages, anything, anything).and_return(response)
+
+      create
+    end
+
+    it 'should specify the slug' do
+      expect(Hookly::Request).to receive(:run).with(anything, anything, hash_including(slug: '#updates'), anything).and_return(response)
+
+      create
+    end
+
+    it 'should send the body' do
+      expect(Hookly::Request).to receive(:run).with(anything, anything, anything, id: 5, text: 'Thanks for the information!').and_return(response)
+
+      create
+    end
+
+    it 'should return the message' do
+      expect(create).to be_a(Hookly::Message)
+      expect(create.id).to eq(1440)
+      expect(create.slug).to eq('#updates')
+      expect(create.uid).to eq(nil)
+      expect(create.body).to eq('id' => 5, 'text' => 'Thanks for the information!')
+    end
+
+    describe 'when given a user identifier' do
+      let(:create) { described_class.create('#updates', '5a17b-124f5', id: 5, text: 'Thanks for the information!' ) }
+
+      it 'should specify the uid' do
+        expect(Hookly::Request).to receive(:run).with(anything, anything, hash_including(uid: '5a17b-124f5'), anything).and_return(response)
+
+        create
+      end
+    end
+  end
+end

data/spec/lib/request_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Hookly::Request do
+  describe '.run' do
+    let(:method) { %w(get post patch delete).sample }
+    let(:options) { { option1: 1, option2: 2  } }
+    let(:body) { double('Hash[body]') }
+    let(:run) { described_class.run(method, 'pathname', options, body) }
+
+    let!(:request) { double(:request, :run => response) }
+    let!(:response) { double(:response, :success? => true, :response_body => { response: 'body' }.to_json, :response_code => 900) }
+
+    before do
+      allow(Typhoeus::Request).to receive(:new).and_return(request)
+    end
+
+    it 'should send the url + path' do
+      expect(Typhoeus::Request).to receive(:new).with('http://test.host:1234/pathname', anything).and_return(request)
+
+      run
+    end
+
+    it 'should send the method' do
+      expect(Typhoeus::Request).to receive(:new).with(anything, hash_including(method: method)).and_return(request)
+
+      run
+    end
+
+    it 'should be json' do
+      expect(Typhoeus::Request).to receive(:new).with(anything, hash_including(headers: { 'Content-Type' => 'application/json', 'User-Agent' => "hookly-rails [language(ruby), lib-version(#{Hookly::VERSION}), platform(#{RUBY_PLATFORM}), platform-version(#{RUBY_VERSION})]" })).and_return(request)
+
+      run
+    end
+
+    it 'should run the request' do
+      expect(request).to receive(:run)
+
+      run
+    end
+
+    it 'should return the response body' do
+      expect(run).to eq({ 'response' => 'body' })
+    end
+
+    describe 'with a body' do
+      let(:method) { %w(post patch).sample }
+
+      it 'should send the auth + options + body' do
+        expected_body = { option1: 1, option2: 2, secret: 'test-config-secret', body: body }.to_json
+        expect(Typhoeus::Request).to receive(:new).with(anything, hash_including(body: expected_body)).and_return(request)
+
+        run
+      end
+    end
+
+    describe 'with url parameters' do
+      let(:method) { %w(get delete).sample }
+
+      it 'should send the auth + options + body' do
+        expected_params = { secret: 'test-config-secret', option1: 1, option2: 2, body: body }
+        expect(Typhoeus::Request).to receive(:new).with(anything, hash_including(params: expected_params)).and_return(request)
+
+        run
+      end
+
+      describe 'without a body' do
+        let(:run) { described_class.run(method, 'pathname', options) }
+
+        it 'should send the auth + options' do
+          expected_params = { secret: 'test-config-secret', option1: 1, option2: 2, body: {} }
+          expect(Typhoeus::Request).to receive(:new).with(anything, hash_including(params: expected_params)).and_return(request)
+
+          run
+        end
+      end
+    end
+
+    describe 'on error' do
+      before do
+        allow(response).to receive(:success?).and_return(false)
+      end
+
+      it 'should error' do
+        expect {
+          run
+        }.to raise_error(Hookly::ResponseError, /failed with code: `900`/)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rspec'
+require 'webmock/rspec'
+
+require 'hookly'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+
+  config.run_all_when_everything_filtered = true
+  config.profile_examples = 10
+  config.order = :defined
+  config.warnings = true
+
+  config.default_formatter = 'doc' if config.files_to_run.one? # More verbose when focused on one file
+end
+
+WebMock.disable_net_connect!
+
+Dir[File.dirname(__FILE__) + '/helpers/*.rb'].each do |file|
+  require file
+end