trumpet-trumpet 0.0.1 → 0.0.2

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 1
+:patch: 2
 :major: 0
 :minor: 0

data/lib/core_extensions.rb

@@ -135,19 +135,4 @@ class Hash #:nodoc:
 
     param
   end
-  
-  # @return <String> The hash as attributes for an XML tag.
-  #
-  # @example
-  #   { :one => 1, "two"=>"TWO" }.to_xml_attributes
-  #     #=> 'one="1" two="TWO"'
-  def to_xml_attributes
-    map do |k,v|
-      %{#{k.to_s.snake_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
-    end.join(' ')
-  end
-end
-
-class BlankSlate #:nodoc:
-  instance_methods.each { |m| undef_method m unless m =~ /^__/ }
 end

data/lib/trumpet/channel.rb

@@ -9,23 +9,23 @@ module Trumpet
     attr_reader *@@attributes
     
     def self.create(options)
-      Channel.new(HTTP.post('/channels', :parameters => options))
+      Channel.new(Trumpet::Request.post('/channels', :parameters => options))
     end
     
     def self.find(name)
-      Channel.new(HTTP.post("/channels/#{name}"))
+      Channel.new(Trumpet::Request.get("/channels/#{name}"))
     end
     
     def self.all
-      HTTP::get('/channels').map { |attributes| Channel.new(attributes) }
+      Trumpet::Request.get('/channels').map { |attributes| Channel.new(attributes) }
     end
         
     def broadcast(message)
-      Message.new(HTTP.post("/channels/#{@name}/messages", :parameters => message.to_h))
+      Message.new(Trumpet::Request.post("/channels/#{@name}/messages", :parameters => message.to_h))
     end
     
     def messages
-      messages = HTTP.get("/channels/#{@name}/messages")
+      messages = Trumpet::Request.get("/channels/#{@name}/messages")
       messages.map { |attributes| Message.new(attributes) }
     end
 

data/lib/trumpet/helpers.rb

@@ -0,0 +1,5 @@
+module Trumpet
+  def self.authenticate_with(username, password)
+    Trumpet::Request.authenticate(username, password)
+  end
+end

data/lib/trumpet/listener.rb

@@ -14,15 +14,20 @@ module Trumpet
     
     
     def self.create(options)
-      Listener.new(HTTP.post('/listeners', :parameters => options))
+      Listener.new(Trumpet::Request.post('/listeners', :parameters => options))
     end
     
     def self.find(id)
-      Listener.new(HTTP.get("/listeners/#{id}"))
+      Listener.new(Trumpet::Request.get("/listeners/#{id}"))
     end
     
     def self.delete
-      HTTP.delete("/listeners/#{@id}")
+      !!Trumpet::Request.delete("/listeners/#{@id}")
+    end
+    
+    def self.all_by_receiver_id(receiver_id)
+      listeners = Trumpet::Request.get("/receivers/#{receiver_id}/listeners")
+      listeners.map { |attributes| Listener.new(attributes) }
     end
     
     

data/lib/trumpet/message.rb

@@ -19,14 +19,31 @@ module Trumpet
     attr_accessor *@@attributes
 
     def initialize(attributes)
-      
-
-      
       @@attributes.each do |attr|
         self.send "#{attr.to_s}=".to_sym, (attributes[attr] || attributes[attr.to_s])
       end
     end
     
+    def self.create(attributes)
+      message = Message.new(attributes)
+      message.broadcast
+      message
+    end
+    
+    # Post a message to the server, but only if it didn't come from the server
+    def broadcast
+      
+      puts "Self to h: #{self.to_h}"
+      puts "And plain to h: #{to_h}"
+      
+      unless @id
+        attributes = Trumpet::Request.post('/messages', :parameters => self.to_h)
+        @@attributes.each do |attr|
+          self.send "#{attr.to_s}=".to_sym, (attributes[attr] || attributes[attr.to_s])
+        end
+      end
+    end
+    
     def to_h
       @@attributes.inject({}) { |hash, attribute| hash[attribute] = self.send(attribute); hash }
     end

data/lib/trumpet/receiver.rb

@@ -19,19 +19,23 @@ module Trumpet
     
     
     def self.create(options={})
-      Receiver.new(HTTP.post("/receivers", :parameters => options))
+      Receiver.new(Trumpet::Request.post("/receivers", :parameters => options))
     end
     
     def self.find(id)
-      Receiver.new(HTTP.get("/receivers/#{id}"))
+      Receiver.new(Trumpet::Request.get("/receivers/#{id}"))
     end
 
     def delete
-      HTTP.delete("/receivers/#{@id}")
+      !!Trumpet::Request.delete("/receivers/#{@id}")
+    end
+    
+    def listeners
+      Trumpet::Listener.all_by_receiver_id(@id)
     end
     
     def messages
-      messages = HTTP.get("/receivers/#{@id}/messages")
+      messages = Trumpet::Request.get("/receivers/#{@id}/messages")
       messages.map { |attributes| Message.new(attributes) }
     end
     

data/lib/trumpet/request.rb

@@ -0,0 +1,66 @@
+module Trumpet
+  module Request
+    @@http = Resourceful::HttpAccessor.new
+    @@uri = 'http://api.trumpet.io:3000'
+    # @@uri = 'http://localhost:3000'
+  
+    def self.authenticate(username, password)
+      my_realm_authenticator = Resourceful::BasicAuthenticator.new('Trumpet', username, password)    
+      @@http = Resourceful::HttpAccessor.new(:authenticator => my_realm_authenticator)
+    end
+  
+    def self.get(path, options={})
+      do_request(:get, path, options)
+    end
+
+    def self.post(path, options={})
+      do_request(:post, path, options)
+    end
+
+    def self.put(path, options={})
+      do_request(:put, path, options)
+    end
+
+    def self.delete(path, options={})
+      do_request(:delete, path, options) 
+    end
+
+    private
+  
+      def self.do_request(method, path, options)
+        resource = @@http.resource("#{@@uri}#{URI.encode(path)}")
+        begin
+          response =
+            if method == :post
+              resource.send(method, options[:parameters].to_params, :content_type => "application/x-www-form-urlencoded")
+            elsif options[:parameters]
+              resource.send(method, options[:parameters].to_params)
+            else
+              resource.send(method)
+          end
+        rescue Resourceful::UnsuccessfulHttpRequestError => e
+          response = e.http_response
+          error_string = JSON.parse(response.body).to_s
+        
+          case response.code
+          when 400
+            raise Trumpet::BadRequest, error_string
+          when 403
+            raise Trumpet::Forbidden, error_string
+          when 404
+            raise Trumpet::NotFound, error_string
+          when 405
+            raise Trumpet::MethodNotAllowed, error_string
+          when 500
+            raise Trumpet::InternalServerError, error_string
+          when 501
+            raise Trumpet::NotImplemented, error_string
+          end
+        rescue IOError # Coudln't connect to server
+          raise Trumpet::ServerConnectionError, 'Could not connect to server'
+        end
+      
+        (options[:parse_response] == false) ? response : JSON.parse(response.body)
+      end
+  end
+end

data/lib/trumpet/transmitter.rb

@@ -17,27 +17,33 @@ module Trumpet
     attr_reader *@@attributes
     
     def self.create(options)
-      attributes = HTTP::post('transmitters', :query => options)
-      Transmitter.new(attributes)
+      Transmitter.new(Trumpet::Request.post('transmitters', :parameters => options))
     end
     
     def self.find(id)
-      attributes = get("/transmitters/#{id}")
-      Transmitter.new(attributes)
+      Transmitter.new(Trumpet::Request.get("/transmitters/#{id}"))
     end
     
     def delete
-      self.class.delete('/')
+      Trumpet::Request.delete("/transmitters/#{@id}")
     end
     
     def listeners
-      listeners = self.class.get("/transmitters/#{id}/listeners")
+      listeners = Trumpet::Request.get("/transmitters/#{@id}/listeners")
       listeners.map { |attributes| Listener.new(attributes) }
     end
     
     def broadcast(message)
-      self.class.post("/transmitters/#{@transmitter_id}/messages", :query => message.to_h)
+      Trumpet::Request.post("/transmitters/#{@transmitter_id}/messages", :parameters => message.to_h)
     end
-
+    
+    
+    protected
+    
+      def initialize(attributes)
+        @@attributes.each do |attr|
+          self.instance_variable_set(:"@#{attr.to_s}", attributes[attr.to_s]) if attributes[attr.to_s]
+        end
+      end
   end
 end

data/lib/trumpet/user.rb

@@ -4,17 +4,44 @@ module Trumpet
     attr_reader *@@attributes
     
     def self.create(options)
-      attributes = post('/users', options)
+      attributes = Trumpet::Request.post('/users', :parameters => options)
       User.new(attributes)
     end
     
     def self.find(name)
-      attributes = get("/users/#{name}")
-      User.new(attributes) if attributes["name"]
+      User.new(Trumpet::Request.get("/users/#{name}"))
     end
     
     def delete
-      self.class.delete("/users/#{@name}")
+      !!Trumpet::Request.delete("/users/#{@name}")
     end
+    
+    def channels
+      channels = Trumpet::Request.get("/users/#{@name}/channels")
+      channels.map { |attributes| Trumpet::Channel.new(attributes) }
+    end
+    
+    def listeners
+      listeners = Trumpet::Request.get("/users/#{@name}/listeners")
+      listeners.map { |attributes| Trumpet::Channel.new(attributes) }
+    end
+    
+    def receivers
+      receivers = Trumpet::Request.get("/users/#{@name}/receivers")
+      receivers.map { |attributes| Trumpet::Channel.new(attributes) }
+    end
+    
+    def transmitters
+      transmitters = Trumpet::Request.get("/users/#{@name}/transmitters")
+      transmitters.map { |attributes| Trumpet::Transmitter.new(attributes) }
+    end
+    
+    protected
+    
+      def initialize(attributes)
+        @@attributes.each do |attr|
+          self.instance_variable_set(:"@#{attr.to_s}", attributes[attr.to_s]) if attributes[attr.to_s]
+        end
+      end
   end
 end

data/lib/trumpet.rb

@@ -5,25 +5,17 @@ require 'resourceful'
 require 'json'
 
 require 'core_extensions'
-require 'http'
 
 
 module Trumpet
-  include HTTP
-  
-  def authenticate(name, token)
-    
-  end
-  
-  def authenticated?
-    
-  end
 end
 
+require 'trumpet/request'
 require 'trumpet/trumpet_resource'
 require 'trumpet/exceptions'
 require 'trumpet/message'
 require 'trumpet/receiver'
 require 'trumpet/listener'
 require 'trumpet/transmitter'
-require 'trumpet/channel'
+require 'trumpet/channel'
+require 'trumpet/helpers'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: trumpet-trumpet
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Michael Taras
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-30 00:00:00 -07:00
+date: 2009-05-01 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,14 +47,14 @@ files:
 - Rakefile
 - VERSION.yml
 - lib/core_extensions.rb
-- lib/http.rb
 - lib/trumpet.rb
 - lib/trumpet/channel.rb
 - lib/trumpet/exceptions.rb
+- lib/trumpet/helpers.rb
 - lib/trumpet/listener.rb
 - lib/trumpet/message.rb
 - lib/trumpet/receiver.rb
-- lib/trumpet/sieve.rb
+- lib/trumpet/request.rb
 - lib/trumpet/transmitter.rb
 - lib/trumpet/trumpet_resource.rb
 - lib/trumpet/user.rb

data/lib/http.rb

@@ -1,68 +0,0 @@
-module HTTP
-  @@http = Resourceful::HttpAccessor.new
-  @@uri = 'http://api.trumpet.io:3000'
-  
-  def self.get(path, options={})
-    do_request(:get, path, options)
-  end
-
-  def self.post(path, options={})
-    do_request(:post, path, options)
-  end
-
-  def self.put(path, options={})
-    do_request(:put, path, options)
-  end
-
-  def self.delete(path, options={})
-    do_request(:delete, path, options) 
-  end
-
-  private
-  
-    def self.do_request(method, path, options)
-      resource = @@http.resource("#{@@uri}#{URI.encode(path)}")
-      begin
-        response = if method == :post
-          resource.send(method, options[:parameters].to_params, :content_type => "application/x-www-form-urlencoded")
-        else
-          options[:parameters] ? resource.send(method, options[:parameters].to_params) : resource.send(method)
-        end
-      rescue Resourceful::UnsuccessfulHttpRequestError => e
-        response = e.http_response
-        error_string = JSON.parse(response.body).to_s
-        
-        case response.code
-        when 400
-          raise Trumpet::BadRequest, error_string
-        when 403
-          raise Trumpet::Forbidden, error_string
-        when 404
-          raise Trumpet::NotFound, error_string
-        when 405
-          raise Trumpet::MethodNotAllowed, error_string
-        when 500
-          raise Trumpet::InternalServerError, error_string
-        when 501
-          raise Trumpet::NotImplemented, error_string
-        end
-      rescue IOError # Coudln't connect to server
-        raise Trumpet::ServerConnectionError, 'Could not connect to server'
-      end
-      
-      (options[:parse_response] == false) ? response : JSON.parse(response.body)
-    end
-
-    def self.handle_response(response, parse_response)
-      case response.code
-      when 400
-        # TODO: what to do here?
-      when 404
-        raise Trumpet::ResourceNotFound JSON.parse(response.body)
-      when 500
-        # TODO: what to do here?
-      end
-      
-      parse_response ? JSON.parse(response.body) : response
-    end
-end

data/lib/trumpet/sieve.rb

@@ -1,102 +0,0 @@
-module Trumpet
-  class Sieve
-    include HTTParty
-    base_uri 'devour.cc:3000'
-    
-    @@options_attributes = [
-      :keywords     , :location ,
-      :via          , :to       ,
-      :days         , :start    ,
-      :end          , :expires  ,
-      :foreign_id
-    ]
-    
-    attr_accessor :id, :foreign_id, :name, :type, :created_at, :options
-    
-    @@options_attributes.each do |attribute|
-      define_method "#{attribute}=" do |value|
-        @options[attribute] = value
-      end
-      define_method attribute do
-        @options[attribute]
-      end
-    end
-    
-    
-    def initialize(options={})
-      options.reject! { |key, value| value.nil? || (value.is_a?(String) && value.strip.empty?) }
-      
-      @options = {}
-      @@options_attributes.each do |attribute|
-        value = options[attribute] || options[attribute.to_s]
-        @options[attribute] = value if value
-      end
-    end
-        
-    def pull
-      add_to_server
-
-      self.class.get("/sieves/#{id}").inject([]) do |memo, attributes|
-        memo << Nugget.new(attributes)
-      end
-    end
-
-    def subscribe
-      wait_time ||= 2 # seconds
-
-      while true
-        results = pull
-        results.each { |nugget| yield nugget }
-        wait_time = results.nil? ? wait_time*2 : [wait_time/2, 2].max
-        sleep(wait_time)
-      end
-    end
-    
-    def delete
-      self.class.delete("/sieves/#{@id}")
-    end
-        
-    def add_to_server
-      unless @id
-        attributes = self.class.post("/sieves", :query => options)
-        @id   = attributes['id']
-        @type = attributes['type']
-        @name = attributes['name']
-      end
-    end
-    
-    def self.index
-      get("/sieves")
-    end
-    
-    def self.find(id)
-      attributes = get("/sieves/?id=#{id}").first
-      instantiate(attributes)
-    end
-    
-    def self.find_by_foreign_id(foreign_id)
-      sieve_attributes = get("/sieves/?foreign_id=#{foreign_id}")
-      sieve_attributes.collect { |attributes| instantiate(attributes) }
-    end
-    
-    def self.create(options={})
-      sieve = new(options)
-      sieve.add_to_server
-      sieve
-    end
-
-    
-    private
-    
-      def self.instantiate(attributes)
-        sieve = allocate
-        
-        sieve.id = attributes['id']
-        sieve.options = attributes['options']
-        sieve.type = attributes['type']
-        sieve.name = attributes['name']
-        
-        sieve
-      end
-  end
-end