hook-client 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c369258ba544d32bf8658fec16b773009810d138
+  data.tar.gz: cf1eda4213eda65e81875dd4ef2cb219b6160ee7
+SHA512:
+  metadata.gz: f069f6984f0d0f27cac78b0dfaa723ae9964786f048f1904a5b989121df2e4e6b9b31ad87f61846e7231b17ff9a4423dcef71a8b4edc724bb43f37b577208e2b
+  data.tar.gz: c2457a562ca1575585b8dc47baaaab14171722d67b1084d46708359b5423ed3e260deb31c40a4dd32322bcf15cc58be6379c07c21d3d54440cf40a1c98ed8ad2

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Doubleleft
+
+MIT License
+
+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,64 @@
+hook-ruby client ![Build status](https://travis-ci.org/doubleleft/hook-ruby.svg?branch=master)
+===
+
+ruby client for [hook](github.com/doubleleft/hook/).
+
+- [API Reference](http://doubleleft.github.io/hook-ruby).
+- [RubyGem](http://rubygems.org/gems/hook-client)
+
+Getting started:
+---
+
+```ruby
+# Gemfile
+gem 'hook-client'
+```
+
+Basic usage:
+
+```ruby
+require 'hook-client'
+client = Hook::Client(:app_id => 1, :key => "something", :endpoint => "https://dl-api.heroku.com")
+client.collection(:posts).create(:title => "Getting Started", :description => "Getting started with dl-api-ruby.")
+puts client.collection(:posts).where(:title => "Getting Started").count
+```
+
+For more examples, please see [our tests](spec).
+
+Using it with Rails
+---
+
+Set-up with your credentials:
+
+```ruby
+Hook::Client.configure(
+  :app_id => 1,
+  :key => "1f143fde82d14643099ae45e6c98c8e1",
+  :endpoint => "https://dl-api.heroku.com"
+)
+```
+
+Define your models:
+
+```ruby
+class Post
+  include Hook::Model
+
+  field :title
+  field :description
+
+  validates_presence_of :title
+end
+```
+
+Hook::Model's uses almost the same syntax as ActiveRecord, which you're already
+familiar with.
+
+You will be able to use any
+[ActiveModel](https://github.com/rails/rails/tree/master/activemodel) goodies,
+such as validation, serialization and dirty methods.
+
+License
+---
+
+MIT

data/lib/hook-client.rb

@@ -0,0 +1,11 @@
+module Hook
+  autoload :VERSION, 'hook-client/version'
+  autoload :Client, 'hook-client/client'
+
+  autoload :Keys, 'hook-client/keys'
+  autoload :Collection, 'hook-client/collection'
+  autoload :Channel, 'hook-client/channel'
+  autoload :Model, 'hook-client/model'
+
+  autoload :Extensions, 'hook-client/extensions'
+end

data/lib/hook-client/auth.rb

@@ -0,0 +1,4 @@
+module Hook
+  class Auth
+  end
+end

data/lib/hook-client/channel.rb

@@ -0,0 +1,13 @@
+module Hook
+  module Channel
+    autoload :SSE, 'hook-client/channel/sse'
+    autoload :WEBSOCKET, 'hook-client/channel/websocket'
+
+    def self.create(client, name, options = {})
+      channel_klass = (options.delete(:transport) || 'sse').upcase
+      collection = Collection.new(name, :channel => true)
+      self.const_get(channel_klass).new(client, collection, options)
+    end
+
+  end
+end

data/lib/hook-client/channel/sse.rb

@@ -0,0 +1,9 @@
+module Hook
+  class SSE
+
+    def initialize
+    end
+
+  end
+end
+

data/lib/hook-client/channel/websocket.rb

@@ -0,0 +1,4 @@
+module Hook
+  class WEBSOCKET
+  end
+end

data/lib/hook-client/client.rb

@@ -0,0 +1,93 @@
+require 'http'
+require 'uri'
+
+module Hook
+  class Client
+    class << self
+      attr_reader :instance
+      def configure(options = {})
+        @instance = self.new(options)
+      end
+    end
+
+    def initialize options = {}
+      @app_id = options.delete(:app_id)
+      @key = options.delete(:key)
+      @endpoint = options.delete(:endpoint) || options.delete(:url)
+      @endpoint = "#{@endpoint}/" unless @endpoint.end_with? "/"
+
+      @logger = options.delete(:logger)
+    end
+
+    def keys
+      Keys.new
+    end
+
+    def auth
+      Auth.new
+    end
+
+    def files
+      Files.new
+    end
+
+    def collection(name)
+      Collection.new(:name => name, :client => self)
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def channel(name, options = {})
+      throw NotImplementedError.new("channels not implemented")
+      Channel.create(self, name, options)
+    end
+
+    def post segments, data
+      request :post, segments, data
+    end
+
+    def get segments, data = {}
+      request :get, segments, data
+    end
+
+    def put segments, data
+      request :put, segments, data
+    end
+
+    def remove segments, data = {}
+      request :delete, segments, data
+    end
+    alias_method :delete, :remove
+
+    protected
+    def request method, segments, data = {}
+      response = nil, headers = {
+        :accept => 'application/json',
+        'X-App-Id' => @app_id,
+        'X-App-Key' => @key,
+        'User-Agent' => "hook-ruby"
+      }
+
+      if method == :get
+        segments = "#{segments}?#{URI::escape(data.to_json)}"
+        data = nil
+      end
+
+      if @logger
+        start_time = Time.now
+      end
+
+      response = HTTP.with(headers).send(method, "#{@endpoint}#{segments}", :json => data).to_s
+
+      if @logger
+        @logger.info "#{self.class.name} - #{(Time.now - start_time).round(3)}s - #{method.upcase} #{@endpoint}#{segments}"
+      end
+
+      # If JSON.parse don't suceed, return response as integer
+      JSON.parse(response) rescue JSON.parse("{\"value\":#{response}}")['value'] rescue response.to_i
+    end
+
+  end
+end

data/lib/hook-client/collection.rb

@@ -0,0 +1,285 @@
+module Hook
+  class Collection
+
+    def initialize options = {}
+      @name = options.delete(:name)
+      @client = options.delete(:client) || Hook::Client.instance
+
+      segment = options.delete(:channel) ? "channel" : "collection"
+      @segments = "#{segment}/#{@name}"
+      reset!
+    end
+
+    # Find item by _id.
+    #
+    # @param _id [String]
+    # @return [Hash]
+    def find _id
+      if _id.kind_of?(Array)
+        self.where(:_id.in => _id).all
+      else
+        @client.get "#{@segments}/#{_id}"
+      end
+    end
+
+    # Return only the first result from the database
+    def first
+      @options[:first] = 1
+      self.query!
+    end
+
+    # Create an item into the collection
+    #
+    # @param data [Hash, Array] item or array of items
+    # @return [Hash, Array]
+    def create data
+      if data.kind_of?(Array)
+        # TODO: server should accept multiple items to create,
+        # instead of making multiple requests.
+        data.map {|item| self.create(item) }
+      else
+        @client.post @segments, data
+      end
+    end
+
+    # Retrieve the first item with the given params in the database,
+    # if not found this will create one.
+    #
+    # @param data [Hash] query and data to store
+    # @return [Hash]
+    def first_or_create data
+      @options[:first] = 1
+      @options[:data] = data
+      @client.post(@segments, self.build_query)
+    end
+
+    # Remove items by id, or by query
+    #
+    # @param _id [String, nil] _id
+    # @return [Hash] status of the operation (ex: {success: true, affected_rows: 7})
+    def remove _id = nil
+      path = @segments
+      path = "#{path}/#{_id}" if _id
+      @client.remove(path, build_query)
+    end
+
+    # Remove items by query. This is the same as calling `remove` without `_id` param.
+    # @see remove
+    def delete_all
+      self.remove(nil)
+    end
+
+    # Add where clause to the current query.
+    #
+    # Supported modifiers on fields: .gt, .gte, .lt, .lte, .ne, .in, .not_in, .nin, .like, .between, .not_between
+    #
+    # @param fields [Hash] fields and values to filter
+    # @param [String] operation (and, or)
+    #
+    # @example
+    #     hook.collection(:movies).where({
+    #       :name => "Hook",
+    #       :year.gt => 1990
+    #     })
+    #
+    # @example Using Range
+    #     hook.collection(:movies).where({
+    #       :name.like => "%panic%",
+    #       :year.between => 1990..2014
+    #     })
+    #
+    # @return [Collection] self
+    def where fields = {}, operation = 'and'
+      fields.each_pair do |k, value|
+        field = (k.respond_to?(:field) ? k.field : k).to_s
+        comparation = k.respond_to?(:comparation) ? k.comparation : '='
+
+        # Range syntatic sugar
+        value = [ value.first, value.last ] if value.kind_of?(Range)
+
+        @wheres << [field, comparation, value, operation]
+      end
+      self
+    end
+
+    # Add where clause with 'OR' operation to the current query.
+    # @param fields [Hash] fields and values to filter
+    # @return [Collection] self
+    def or_where fields = {}
+      self.where(fields, 'or')
+    end
+
+    # Add order clause to the query.
+    #
+    # @param fields [String] ...
+    # @return [Collection] self
+    def order fields
+      by_num = { 1 => 'asc', -1 => 'desc' }
+      ordering = []
+      fields.each_pair do |key, value|
+        ordering << [key.to_s, by_num[value] || value]
+      end
+      @ordering = ordering
+      self
+    end
+    alias_method :sort, :order
+
+    # Limit the number of results to retrieve.
+    #
+    # @param int [Integer]
+    # @return [Collection] self
+    def limit int
+      @limit = int
+      self
+    end
+
+    # @param int [Integer]
+    # @return [Collection] self
+    def offset int
+      @offset = int
+      self
+    end
+
+    # Run the query, and return all it's results.
+    # @yield You may use a block with all returned results
+    # @return [Array]
+    def all(&block)
+      rows = query!
+      yield rows if block_given?
+      rows
+    end
+
+    def query!
+      @client.get @segments, build_query
+    end
+
+    def method_missing method, *args, &block
+      if Enumerator.method_defined? method
+        Enumerator.new(self.all).send(method, args, block)
+      end
+
+      throw NoMethodError.new("#{self.class.name}: method '#{method}' not found")
+    end
+
+    # Specify the target field names to retrieve
+    #
+    # @param fields [String] ...
+    # @return [Collection] self
+    def select *fields
+      @options[:select] = fields
+    end
+
+    # Return related collection's data
+    #
+    # @param relationships [String] ...
+    #
+    # @example Retrieving a single relation
+    #     hook.collection(:books).with(:publisher).each do |book|
+    #       puts book[:name]
+    #       puts book[:publisher][:name]
+    #     end
+    #
+    # @example Retrieving multiple relations
+    #     hook.collection(:books).with(:publisher, :author).each do |book|
+    #       puts book[:name]
+    #       puts book[:publisher][:name]
+    #       puts book[:author][:name]
+    #     end
+    #
+    # @return [Collection] self
+    def with *relationships
+      @options[:with] = relationships
+      self
+    end
+
+    # Group query results
+    # @param fields [String] ...
+    # @return [Collection] self
+    def group *fields
+      @group = fields
+      self
+    end
+
+    def count field = '*'
+      @options[:aggregation] = { :method => 'count', :field => field }
+      self.query!
+    end
+
+    def max field
+      @options[:aggregation] = { :method => :max, :field => field }
+      self.query!
+    end
+
+    def min field
+      @options[:aggregation] = { :method => :min, :field => field }
+      self.query!
+    end
+
+    def avg field
+      @options[:aggregation] = { :method => :avg, :field => field }
+      self.query!
+    end
+
+    def sum field
+      @options[:aggregation] = { :method => :sum, :field => field }
+      self.query!
+    end
+
+    def increment field, value = 1
+      @options[:operation] =  { :method => 'increment', :field => field, :value => value }
+      self.query!
+    end
+
+    def decrement field, value = 1
+      @options[:operation] =  { :method => 'decrement', :field => field, :value => value }
+      self.query!
+    end
+
+    def update _id, data
+      @client.post "#{@segments}/#{_id}", data
+    end
+
+    def update_all data
+      @options[:data] = data
+      @client.put @segments, build_query
+    end
+
+    def build_query
+      query = {}
+      query[:limit] = @limit if @limit
+      query[:offset] = @offset if @offset
+
+      query[:q] = @wheres unless @wheres.empty?
+      query[:s] = @ordering unless @ordering.empty?
+      query[:g] = @group unless @group.empty?
+
+      {
+        :paginate => 'p',
+        :first => 'f',
+        :aggregation => 'aggr',
+        :operation => 'op',
+        :data => 'data',
+        :with => 'with',
+        :select => 'select',
+      }.each_pair do |option, shortname|
+        query[ shortname ] = @options[ option ] if @options[ option ]
+      end
+
+      self.reset!
+      query
+    end
+
+    protected
+
+    def reset!
+      @wheres = []
+      @options = {}
+      @wheres = []
+      @ordering = []
+      @group = []
+      @limit = nil
+      @offset = nil
+    end
+
+  end
+end

data/lib/hook-client/extensions.rb

@@ -0,0 +1,12 @@
+module Hook
+  module Extensions
+    autoload :Symbol, 'hook-client/extensions/symbol'
+
+    def self.eager_load!
+      self.constants.each {|const| self.const_get(const) }
+    end
+  end
+end
+
+# Load all the extensions
+Hook::Extensions.eager_load!

data/lib/hook-client/extensions/symbol.rb

@@ -0,0 +1,28 @@
+module DL
+  module Extensions
+    module Symbol
+
+      {
+        :gt => '>',
+        :gte => '>=',
+        :lt => '<',
+        :lte => '<=',
+        :ne => '!=',
+        :in => 'in',
+        :not_in => 'not_in',
+        :nin => 'not_in', # alias
+        :like => 'like',
+        :between => 'between',
+        :not_between => 'not_between',
+        # :max_distance,
+      }.each_pair do |method, comparation|
+        define_method(method) do
+          OpenStruct.new(:field => self, :comparation => comparation)
+        end
+      end
+
+    end
+  end
+end
+
+::Symbol.__send__(:include, DL::Extensions::Symbol)

data/lib/hook-client/keys.rb

@@ -0,0 +1,26 @@
+module Hook
+  class Keys
+
+    def initialize(options={})
+      @client = options.delete(:client) || Hook::Client.instance
+    end
+
+    # Return the unserialized value
+    #
+    # @param key [String, Symbol]
+    # @return [Object] value
+    def get(key)
+      @client.get("key/#{key}")
+    end
+
+    # Store serialized value
+    #
+    # @param key [String, Symbol] key
+    # @param value [Object] JSON serializable object
+    # @return [Object] The object you just stored.
+    def set(key, value)
+      @client.post("key/#{key}", { :value => value });
+    end
+
+  end
+end

data/lib/hook-client/model.rb

@@ -0,0 +1,116 @@
+require 'active_model'
+
+module Hook
+  #
+  # Provides ActiveRecord/like methods for querying Collections
+  #
+  module Model
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        extend ActiveModel::Naming
+        extend ActiveModel::Translation
+        extend ActiveModel::Callbacks
+        include ActiveModel::Validations
+        include ActiveModel::Conversion
+        include ActiveModel::Dirty
+        include ActiveModel::AttributeMethods
+        include ActiveModel::Serializers::JSON
+        include ActiveModel::Serializers::Xml
+
+        field :_id
+      end
+    end
+
+    module InstanceMethods
+      def initialize(attrs = {})
+        # is Hook::Client configured?
+        throw RuntimeError.new("Please use Hook::Client.configure.") unless Hook::Client.instance
+
+        @collection = Hook::Client.instance.collection(self.class.collection_name)
+        self.attributes = {}
+        attrs.each_pair do |name, value|
+          self.send(:"#{name}=", value) if self.respond_to?(:"#{name}")
+        end
+
+        # reset_changes
+        changes_applied if self._id
+      end
+
+      def save
+        return false if !self.changed? || !self.valid?
+
+        changes_applied
+        if self._id.nil?
+          self.attributes = @collection.update(self._id, attributes)
+        else
+          self.attributes = @collection.create(attributes)
+        end
+        self
+      end
+
+      def attributes=(attrs)
+        @attributes = attrs
+      end
+
+      def attributes
+        @attributes
+      end
+
+      def inspect
+        "#<#{self.class.name}: attributes=#{attributes.inspect}>"
+      end
+
+      # Delegator methods
+      def method_missing(m, *args, &block)
+        res = @collection.send(m, *args, &block)
+
+        # Check for success/error responses
+        if res.kind_of?(Hash) && res.length == 1
+          return res['success'] unless res['success'].nil?
+          throw RuntimeError.new(res['error']) unless res['error'].nil?
+        end
+
+        if (res.kind_of?(Hook::Collection))
+          self
+        else
+          (res.kind_of?(Array)) ? res.map {|r| self.class.new(r) } : self.class.new(res)
+        end
+      end
+
+    end
+
+    module ClassMethods
+      def collection_name(name = nil)
+        if name
+          @collection_name = name
+        else
+          @collection_name = ActiveModel::Naming.route_key(self)
+        end
+      end
+
+      def field name, options = {}
+        define_attribute_method name
+
+        # Define getter
+        define_method name do
+          # self.instance_variable_get("@#{name}")
+          attributes[name]
+        end
+
+        # Define setter
+        define_method "#{name}=" do |value|
+          self.send(:"#{name}_will_change!")
+          attributes[name] = value
+        end
+      end
+
+      def method_missing(m, *args, &block)
+        instance = self.new
+        instance.send(m, *args, &block)
+      end
+    end
+
+    include InstanceMethods
+  end
+end

data/lib/hook-client/version.rb

@@ -0,0 +1,3 @@
+module Hook
+  VERSION = '0.2.0'
+end

data/spec/client_spec.rb

@@ -0,0 +1,11 @@
+describe Hook::Client do
+
+  subject do
+    Hook::Client.instance
+  end
+
+  it "" do
+
+  end
+
+end

data/spec/collection_spec.rb

@@ -0,0 +1,68 @@
+describe Hook::Collection do
+
+  subject do
+    Hook::Client.instance
+  end
+
+  it "should create new items to collection" do
+    user = subject.collection(:users).create(:name => "Endel", :newsletter => true)
+    expect(user['name']).to eq("Endel")
+    expect(user['newsletter']).to eq(true)
+  end
+
+  it "should query for items" do
+    rows = subject.collection(:users).where(:name => "Endel").all
+    expect(rows.length).to be > 0
+  end
+
+  it "should delete all items" do
+    # create a dummy item
+    subject.collection(:users).create(:name => "Endel", :newsletter => true)
+    # remove every items
+    subject.collection(:users).delete_all
+    rows = subject.collection(:users).where(:name => "Endel").all
+    expect(rows.length).to be == 0
+  end
+
+  it "general methods" do
+    subject.collection(:highscores).delete_all
+
+    one = created = subject.collection(:highscores).create(:player => "One", :score => 50)
+    expect(created['player']).to eq("One")
+    expect(created['score']).to eq(50)
+
+    two = subject.collection(:highscores).create(:player => "Two", :score => 100)
+    three = subject.collection(:highscores).create(:player => "Three", :score => 25)
+    four = subject.collection(:highscores).create(:player => "Four", :score => 10)
+    five = subject.collection(:highscores).create(:player => "Five", :score => 150)
+    six = subject.collection(:highscores).create(:player => "Six", :score => 125)
+
+    # find multiple by id
+    rows = subject.collection(:highscores).find([two['_id'], three['_id']])
+    expect(rows.length).to be == 2
+    expect(rows[0]['player']).to be == 'Two'
+    expect(rows[1]['player']).to be == 'Three'
+
+    # .all
+    all = subject.collection(:highscores).all
+    expect(all.length).to be >= 6
+
+    # .first
+    five = subject.collection(:highscores).where(:player => "Five").first
+    expect(five['player']).to eq("Five")
+
+    # .count
+    count = subject.collection(:highscores).where(:score.lt => 25).count
+    expect(count).to be == 1
+
+    count = subject.collection(:highscores).where(:score.lte => 25).count
+    expect(count).to be == 2
+
+    count = subject.collection(:highscores).where(:score.between => 11..149).count
+    expect(count).to be == 4
+
+    count = subject.collection(:highscores).where(:player.ne => "One").count
+    expect(count).to be == 5
+  end
+
+end

data/spec/extensions_spec.rb

@@ -0,0 +1,47 @@
+describe Hook::Extensions do
+  it "should extend core Ruby classes" do
+    gt = :field_gt.gt
+    expect(gt.comparation).to eq('>')
+    expect(gt.field).to eq(:field_gt)
+
+    gte = :field_gte.gte
+    expect(gte.comparation).to eq('>=')
+    expect(gte.field).to eq(:field_gte)
+
+    lt = :field_lt.lt
+    expect(lt.comparation).to eq('<')
+    expect(lt.field).to eq(:field_lt)
+
+    lte = :field_lte.lte
+    expect(lte.comparation).to eq('<=')
+    expect(lte.field).to eq(:field_lte)
+
+    ne = :field_ne.ne
+    expect(ne.comparation).to eq('!=')
+    expect(ne.field).to eq(:field_ne)
+
+    _in = :field_in.in
+    expect(_in.comparation).to eq('in')
+    expect(_in.field).to eq(:field_in)
+
+    not_in = :field_not_in.not_in
+    expect(not_in.comparation).to eq('not_in')
+    expect(not_in.field).to eq(:field_not_in)
+
+    nin = :field_nin.nin
+    expect(nin.comparation).to eq('not_in')
+    expect(nin.field).to eq(:field_nin)
+
+    like = :field_like.like
+    expect(like.comparation).to eq('like')
+    expect(like.field).to eq(:field_like)
+
+    between = :field_between.between
+    expect(between.comparation).to eq('between')
+    expect(between.field).to eq(:field_between)
+
+    not_between = :field_not_between.not_between
+    expect(not_between.comparation).to eq('not_between')
+    expect(not_between.field).to eq(:field_not_between)
+  end
+end

data/spec/keys_spec.rb

@@ -0,0 +1,20 @@
+describe Hook::Keys do
+
+  subject do
+    Hook::Client.instance
+  end
+
+  it "should get and set keys" do
+    expect(subject.keys.get(:inexistent)).to be_nil
+
+    subject.keys.set :numeric, 12345
+    expect(subject.keys.get(:numeric)).to be == 12345
+
+    subject.keys.set :float, 19.99
+    expect(subject.keys.get(:float)).to be == 19.99
+
+    subject.keys.set :string, 'hello there!'
+    expect(subject.keys.get(:string)).to be == 'hello there!'
+  end
+end
+

data/spec/model_spec.rb

@@ -0,0 +1,55 @@
+class MyCollection
+  include Hook::Model
+  field :name
+  field :score
+  validates_presence_of :score
+end
+
+class CustomHighscore
+  include Hook::Model
+  field :name
+  field :score
+end
+
+describe Hook::Model do
+  it "should respond to activemodel dirty methods" do
+    instance = MyCollection.new
+    expect(instance.name).to be_nil
+    expect(instance.name_changed?).to be == false
+
+    instance.name = 'Endel'
+    expect(instance.name).to be == 'Endel'
+    expect(instance.name_changed?).to be == true
+
+    expect(instance.save).to be == false, "shouldn't save when model has validation errors"
+    expect(instance.errors.messages.length).to be == 1
+  end
+
+  it "should set default attributes" do
+    instance = MyCollection.new(:name => "Endel", :score => 100)
+    expect(instance.name).to be == "Endel"
+    expect(instance.score).to be == 100
+    expect(instance.changed?).to be == true
+    instance.save
+    expect(instance.changed?).to be == false
+  end
+
+  it "general methods" do
+    instance = MyCollection.create(:name => "Endel", :score => 100)
+    expect(instance.name).to be == "Endel"
+    expect(instance.score).to be == 100
+    expect(instance.changed?).to be == false
+    expect(instance.save).to be == false
+  end
+
+  it "should create multiple" do
+    rows = CustomHighscore.create([
+      {:name => "Somebody", :score => 50},
+      {:name => "Anybody", :score => 10},
+    ])
+    expect(rows.length).to be == 2
+    expect(rows[0].name).to be == "Somebody"
+    expect(rows[1].name).to be == "Anybody"
+    expect(CustomHighscore.delete_all).to be == 2
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$: << File.expand_path('../lib')
+require 'hook-client'
+require 'logger'
+require 'json'
+
+logger = Logger.new(STDOUT)
+app = JSON.parse(File.open('spec/app.json').read)
+app_key = app['keys'].select{|k| k['type'] == 'server' }.first
+
+Hook::Client.configure(
+  :app_id => app_key['app_id'],
+  :key => app_key['key'],
+  :endpoint => 'http://hook.dev/public/index.php/'
+  # :logger => logger
+)

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: hook-client
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Endel Dreyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Hook Client for Ruby
+email: endel@doubleleft.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hook-client/auth.rb
+- lib/hook-client/channel/sse.rb
+- lib/hook-client/channel/websocket.rb
+- lib/hook-client/channel.rb
+- lib/hook-client/client.rb
+- lib/hook-client/collection.rb
+- lib/hook-client/extensions/symbol.rb
+- lib/hook-client/extensions.rb
+- lib/hook-client/keys.rb
+- lib/hook-client/model.rb
+- lib/hook-client/version.rb
+- lib/hook-client.rb
+- spec/client_spec.rb
+- spec/collection_spec.rb
+- spec/extensions_spec.rb
+- spec/keys_spec.rb
+- spec/model_spec.rb
+- spec/spec_helper.rb
+- README.md
+- LICENSE
+homepage: http://github.com/doubleleft/hook-ruby
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Hook Ruby Client
+test_files: []
+has_rdoc: