socky 0.0.9 → 0.1.0

data/CHANGELOG.textile

@@ -1,5 +1,16 @@
 h1. Changelog
 
+h2. 0.1.0 / 2010-08-03
+
+*IMPORTANT! This version will not work with plugin version lower than 0.1.0*
+
+* new features:
+** server now send authentication status
+** new syntax
+** option to exclude clients/channels
+* bugfixes:
+** none
+
 h2. 0.0.9 / 2010-06-20
 
 *IMPORTANT! This version will not work with plugin version lower than 0.0.9*

data/VERSION

@@ -1 +1 @@
-0.0.9
+0.1.0

data/bin/socky

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
 require 'rubygems'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'socky')
+require File.join(File.dirname(File.expand_path(__FILE__)), '..', 'lib', 'socky')
 Socky::Runner.run

data/lib/socky.rb

@@ -60,5 +60,4 @@ require 'socky/options'
 require 'socky/runner'
 require 'socky/connection'
 require 'socky/net_request'
-require 'socky/server'
 require 'socky/message'

data/lib/socky/connection.rb

@@ -38,6 +38,8 @@ module Socky
 
     def channels
       @channels ||= query["channels"].to_s.split(",").collect(&:strip).reject(&:empty?)
+      @channels[0] ||= nil # Every user should have at last one channel
+      @channels
     end
 
     def subscribe

data/lib/socky/connection/authentication.rb

@@ -8,9 +8,11 @@ module Socky
           if response
             debug [self.name, "authentication successed"]
             add_to_pool
+            send_authentication("success")
             @authenticated_by_url = true
           else
             debug [self.name, "authentication failed"]
+            send_authentication("failure")
             disconnect
           end
         end unless admin || authenticated?
@@ -23,6 +25,10 @@ module Socky
         end
       end
 
+      def send_authentication(msg)
+        send_data({:type => :authentication, :body => msg})
+      end
+
       def authenticated?
         @authenticated ||= (admin ? authenticate_as_admin : authenticate_as_user)
       end

data/lib/socky/connection/finders.rb

@@ -12,35 +12,42 @@ module Socky
         end
 
         def find(opts = {})
-          clients = opts[:clients].to_a
-          channels = opts[:channels].to_a
+          to = symbolize_keys(opts[:to]) || {}
+          exclude = symbolize_keys(opts[:except]) || {}
+
           connections = find_all
-          connections = filter_by_clients(connections, clients) unless clients.empty?
-          connections = filter_by_channels(connections, channels) unless channels.empty?
+          connections = filter_by_clients(connections, to[:clients], exclude[:clients])
+          connections = filter_by_channels(connections, to[:channels], exclude[:channels])
 
           connections
         end
 
-        def find_by_clients(clients)
-          find(:clients => clients)
-        end
+        private
 
-        def find_by_channels(channels)
-          find(:channels => channels)
-        end
+        def filter_by_clients(connections, included_clients = nil, excluded_clients = nil)
+          # Empty table means "no users" - nil means "all users"
+          return [] if (included_clients.is_a?(Array) && included_clients.empty?)
 
-        def find_by_clients_and_channels(clients, channels)
-          find(:clients => clients, :channels => channels)
+          included_clients = included_clients.to_a
+          excluded_clients = excluded_clients.to_a
+
+          connections.collect do |connection|
+            connection if (included_clients.empty? || included_clients.include?(connection.client)) && !excluded_clients.include?(connection.client)
+          end.compact
         end
 
-        private
+        def filter_by_channels(connections, included_channels = nil, excluded_channels = nil)
+          # Empty table means "no channels" - nil means "all channels"
+          return [] if (included_channels.is_a?(Array) && included_channels.empty?)
 
-        def filter_by_clients(connections, clients)
-          connections.collect{ |connection| connection if clients.include? connection.client }.compact
-        end
+          included_channels = included_channels.to_a
+          excluded_channels = excluded_channels.to_a
 
-        def filter_by_channels(connections, channels)
-          connections.collect{ |connection| connection if channels.any?{ |channel| connection.channels.include?(channel) } }.compact
+          connections.collect do |connection|
+            connection if connection.channels.any? do |channel|
+              (included_channels.empty? || included_channels.include?(channel) ) && !excluded_channels.include?(channel)
+            end
+          end.compact
         end
 
       end

data/lib/socky/message.rb

@@ -38,30 +38,8 @@ module Socky
     end
 
     def broadcast
-      case params[:type].to_sym
-        when :to_clients then broadcast_to_clients
-        when :to_channels then broadcast_to_channels
-        when :to_clients_on_channels then broadcast_to_clients_on_channels
-        else raise
-      end
-    rescue
-      raise(InvalidQuery, "unknown broadcast type")
-    end
-
-    def broadcast_to_clients
-      verify :clients
-      Socky::Server.send_to_clients(params[:body], params[:clients])
-    end
-
-    def broadcast_to_channels
-      verify :channels
-      Socky::Server.send_to_channels(params[:body], params[:channels])
-    end
-
-    def broadcast_to_clients_on_channels
-      verify :clients
-      verify :channels
-      Socky::Server.send_to_clients_on_channels(params[:body], params[:clients], params[:channels])
+      connections = Socky::Connection.find(params)
+      send_message(params[:body], connections)
     end
 
     def query
@@ -77,14 +55,13 @@ module Socky
       respond Socky::Connection.find_all
     end
 
-    def verify(field)
-      params[field] = params[field].to_a unless params[field].is_a?(Array)
-      params[field] = params[field].collect(&:to_s)
-    end
-
     def respond(message)
       creator.send_message(message)
     end
 
+    def send_message(message, connections)
+      connections.each{|connection| connection.send_message message}
+    end
+
   end
 end

data/spec/socky/connection/authentication_spec.rb

@@ -7,6 +7,7 @@ describe Socky::Connection::Authentication do
     context "#subscribe_request" do
       before(:each) do
         stub!(:admin).and_return(false)
+        stub!(:send_data)
       end
       it "should not call #send_subscribe_request if already authenticated" do
         stub!(:authenticated?).and_return(true)

data/spec/socky/connection/finders_spec.rb

@@ -2,10 +2,11 @@ require 'spec/spec_helper'
 
 describe Socky::Connection::Finders do
   include Socky::Connection::Finders
+  include Socky::Misc
   
   context "class" do
     before(:each) do
-      @connection1 = mock(:connection1, :client => "client1", :channels => [])
+      @connection1 = mock(:connection1, :client => "client1", :channels => [nil])
       @connection2 = mock(:connection2, :client => "client1", :channels => ["1", "3", "5"])
       @connection3 = mock(:connection3, :client => "client2", :channels => ["2", "5"])
       @connection4 = mock(:connection4, :client => "client3", :channels => ["3", "5"])
@@ -23,74 +24,165 @@ describe Socky::Connection::Finders do
       it "should return all connections if no options specified" do
         self.class.find.should eql(@connections)
       end
-      context "if :clients option is specified" do
-        it "should return all connections if :clients is nil or empty" do
-          self.class.find(:clients => nil).should eql(@connections)
-          self.class.find(:clients => []).should eql(@connections)
-        end
-        it "should return only connections from specified client" do
-          self.class.find(:clients => "client1").should eql([@connection1,@connection2])
-        end
-        it "should return only connections from specified clients if array provided" do
-          self.class.find(:clients => ["client1","client2"]).should eql([@connection1,@connection2,@connection3])
-        end
-      end
-      context "if :channels option is specified" do
-        it "should return all connections if :channels is nil or empty" do
-          self.class.find(:channels => nil).should eql(@connections)
-          self.class.find(:channels => []).should eql(@connections)
-        end
-        it "should return all connections that include specified channel" do
-          self.class.find(:channels => "3").should eql([@connection2,@connection4])
-        end
-        it "should return all connections that include at last one of specified channels" do
-          self.class.find(:channels => ["2","3"]).should eql([@connection2,@connection3,@connection4])
-        end
-      end
-      context "if both :clients and :channels options are provided" do
-        context "but :channels are empty" do
+      context "on :to" do
+        context "if :clients option is specified" do
+          it "should return all connections if :clients is nil" do
+            self.class.find(:to => {:clients => nil}).should eql(@connections)
+          end
+          it "should return none connections if :clients is empty" do
+            self.class.find(:to => {:clients => []}).should eql([])
+          end
           it "should return only connections from specified client" do
-            self.class.find(:channels => [],:clients => "client1").should eql([@connection1,@connection2])
+            self.class.find(:to => {:clients => "client1"}).should eql([@connection1,@connection2])
           end
           it "should return only connections from specified clients if array provided" do
-            self.class.find(:channels => [],:clients => ["client1","client2"]).should eql([@connection1,@connection2,@connection3])
+            self.class.find(:to => {:clients => ["client1","client2"]}).should eql([@connection1,@connection2,@connection3])
           end
         end
-        context "but :clients are empty" do
+        context "if :channels option is specified" do
+          it "should return all connections if :channels is nil" do
+            self.class.find(:to => {:channels => nil}).should eql(@connections)
+          end
+          it "should return none connections if :channels is empty" do
+            self.class.find(:to => {:channels => []}).should eql([])
+          end
           it "should return all connections that include specified channel" do
-            self.class.find(:clients => [],:channels => "3").should eql([@connection2,@connection4])
+            self.class.find(:to => {:channels => "3"}).should eql([@connection2,@connection4])
           end
           it "should return all connections that include at last one of specified channels" do
-            self.class.find(:clients => [],:channels => ["2","3"]).should eql([@connection2,@connection3,@connection4])
+            self.class.find(:to => {:channels => ["2","3"]}).should eql([@connection2,@connection3,@connection4])
           end
         end
-        it "should return only connections from specified client that include specified channel" do
-          self.class.find(:clients => "client1",:channels => "3").should eql([@connection2])
-          self.class.find(:clients => "client1",:channels => "2").should eql([])
+        context "if both :clients and :channels options are provided" do
+          context "but :channels are nil" do
+            it "should return only connections from specified client" do
+              self.class.find(:to => {:channels => nil,:clients => "client1"}).should eql([@connection1,@connection2])
+            end
+            it "should return only connections from specified clients if array provided" do
+              self.class.find(:to => {:channels => nil,:clients => ["client1","client2"]}).should eql([@connection1,@connection2,@connection3])
+            end
+          end
+          context "but :channels are empty" do
+            it "should return none connections" do
+              self.class.find(:to => {:channels => [],:clients => "client1"}).should eql([])
+            end
+            it "should return none connections if array provided" do
+              self.class.find(:to => {:channels => [],:clients => ["client1","client2"]}).should eql([])
+            end
+          end
+          context "but :clients are nil" do
+            it "should return all connections that include specified channel" do
+              self.class.find(:to => {:clients => nil,:channels => "3"}).should eql([@connection2,@connection4])
+            end
+            it "should return all connections that include at last one of specified channels" do
+              self.class.find(:to => {:clients => nil,:channels => ["2","3"]}).should eql([@connection2,@connection3,@connection4])
+            end
+          end
+          context "but :clients are empty" do
+            it "should return none connections" do
+              self.class.find(:to => {:clients => [],:channels => "3"}).should eql([])
+            end
+            it "should return none connections if array provided" do
+              self.class.find(:to => {:clients => [],:channels => ["2","3"]}).should eql([])
+            end
+          end
+          it "should return only connections from specified client that include specified channel" do
+            self.class.find(:to => {:clients => "client1",:channels => "3"}).should eql([@connection2])
+            self.class.find(:to => {:clients => "client1",:channels => "2"}).should eql([])
+          end
+          it "should return only connections from specified client that include one of specified channels" do
+            self.class.find(:to => {:clients => "client1",:channels => ["2","3"]}).should eql([@connection2])
+          end
+          it "should return only connections from specified clients that include specified channel" do
+            self.class.find(:to => {:clients => ["client1","client2"],:channels => "2"}).should eql([@connection3])
+          end
+          it "should return only connections from specified clients that include at last one of specified channels" do
+            self.class.find(:to => {:clients => ["client1","client2"],:channels => ["2","1"]}).should eql([@connection2,@connection3])
+          end
+        end
+      end
+      
+      context "on :except" do
+        context "if :clients option is specified" do
+          it "should return all connections if :clients is nil" do
+            self.class.find(:except => {:clients => nil}).should eql(@connections)
+          end
+          it "should return all connections if :clients is empty" do
+            self.class.find(:except => {:clients => []}).should eql(@connections)
+          end
+          it "should return all connections except of specified client" do
+            self.class.find(:except => {:clients => "client1"}).should eql([@connection3,@connection4])
+          end
+          it "should return all connections except of specified clients if array provided" do
+            self.class.find(:except => {:clients => ["client1","client2"]}).should eql([@connection4])
+          end
         end
-        it "should return only connections from specified client that include one of specified channels" do
-          self.class.find(:clients => "client1",:channels => ["2","3"]).should eql([@connection2])
+        context "if :channels option is specified" do
+          it "should return all connections if :channels is nil" do
+            self.class.find(:except => {:channels => nil}).should eql(@connections)
+          end
+          it "should return all connections if :channels is empty" do
+            self.class.find(:except => {:channels => []}).should eql(@connections)
+          end
+          it "should return all connections except of that include all specified channels" do
+            self.class.find(:except => {:channels => ["2","5"]}).should eql([@connection1,@connection2,@connection4])
+          end
         end
-        it "should return only connections from specified clients that include specified channel" do
-          self.class.find(:clients => ["client1","client2"],:channels => "2").should eql([@connection3])
+        context "if both :clients and :channels options are provided" do
+          context "but :channels are nil" do
+            it "should return all connections except of specified client" do
+              self.class.find(:except => {:channels => nil,:clients => "client1"}).should eql([@connection3,@connection4])
+            end
+            it "should return all connections except of specified clients if array provided" do
+              self.class.find(:except => {:channels => nil,:clients => ["client1","client2"]}).should eql([@connection4])
+            end
+          end
+          context "but :channels are empty" do
+            it "should return all connections except of specified client" do
+              self.class.find(:except => {:channels => [],:clients => "client1"}).should eql([@connection3,@connection4])
+            end
+            it "should return all connections except of provided clients if array provided" do
+              self.class.find(:except => {:channels => [],:clients => ["client1","client2"]}).should eql([@connection4])
+            end
+          end
+          context "but :clients are nil" do
+            it "should return all connections except of that include all of specified channels" do
+              self.class.find(:except => {:clients => nil,:channels => ["2","5"]}).should eql([@connection1,@connection2,@connection4])
+            end
+          end
+          context "but :clients are empty" do
+            it "should return all connections except of that include all of specified channels " do
+              self.class.find(:except => {:clients => [],:channels => ["2","5"]}).should eql([@connection1,@connection2,@connection4])
+            end
+          end
+          it "should return all connections except of specified client or all specified channels" do
+            self.class.find(:except => {:clients => "client2",:channels => "3"}).should eql([@connection1,@connection2,@connection4])
+            self.class.find(:except => {:clients => "client2",:channels => ["3","5"]}).should eql([@connection1,@connection2])
+          end
+          it "should return only connections from specified clients that include specified channel" do
+            self.class.find(:except => {:clients => ["client1","client2"],:channels => "3"}).should eql([@connection4])
+            self.class.find(:except => {:clients => ["client1","client2"],:channels => ["3","5"]}).should eql([])
+          end
         end
-        it "should return only connections from specified clients that include at last one of specified channels" do
-          self.class.find(:clients => ["client1","client2"],:channels => ["2","1"]).should eql([@connection2,@connection3])
+      end
+    
+      context "on :to and :except" do
+        context "should value 'except' more that 'to'" do
+          it "on :client" do
+            self.class.find(:to => {:clients => "client1"},:except => {:clients => "client1"}).should eql([])
+          end
+          it "on :channels" do
+            self.class.find(:to => {:channels => "5"},:except => {:channels => "5"}).should eql([])
+          end
+          it "on :client allow and :channels except" do
+            self.class.find(:to => {:clients => "client2"},:except => {:channels => ["2","5"]}).should eql([])
+          end
+          it "on :channels allow and :clients except" do
+            self.class.find(:to => {:channels => ["5"]},:except => {:clients => "client2"}).should eql([@connection2,@connection4])
+          end
         end
       end
     end
-    it "#find_by_clients should call #find with clients option" do
-      self.class.should_receive(:find).with({:clients => "client1"})
-      self.class.find_by_clients("client1")
-    end
-    it "#find_by_channels should call #find with channels option" do
-      self.class.should_receive(:find).with({:channels => "1"})
-      self.class.find_by_channels("1")
-    end
-    it "#find_by_clients_and_channels should call #find with both clients and channels option" do
-      self.class.should_receive(:find).with({:clients => "client1", :channels => "1"})
-      self.class.find_by_clients_and_channels("client1","1")
-    end
     
   end
 end

data/spec/socky/connection_spec.rb

@@ -55,9 +55,9 @@ describe Socky::Connection do
         @connection.channels.should_not be_nil
         @connection.channels.class.should eql(Array)
       end
-      it "should return empty table if socket request data 'channels' is nil" do
+      it "should return table with nil if socket request data 'channels' is nil" do
         @connection.socket.request["Query"]["channels"] = nil
-        @connection.channels.should eql([])
+        @connection.channels.should eql([nil])
       end
       it "should return table of channels if provided and separated by comma" do
         @connection.socket.request["Query"]["channels"] = "aaa,bbb,ccc"

data/spec/socky/message_spec.rb

@@ -75,87 +75,18 @@ describe Socky::Message do
       end
     end
     context "#broadcast" do
-      it "should call #broadcast_to_clients if message type is :to_clients" do
-        @message.stub!(:params).and_return({:type => :to_clients})
-        @message.stub!(:broadcast_to_clients)
-        @message.should_receive(:broadcast_to_clients)
+      it "should select target connections basing on params" do
+        @message.stub!(:params).and_return({:some => :abstract})
+        @message.stub!(:send_message)
+        Socky::Connection.should_receive(:find).with({:some => :abstract})
         @message.broadcast
       end
-      it "should not distinguish between string and symbol in type" do
-        @message.stub!(:params).and_return({:type => 'to_clients'})
-        @message.stub!(:broadcast_to_clients)
-        @message.should_receive(:broadcast_to_clients)
-        @message.broadcast
-      end
-      it "should call #broadcast_to_channels if message type is :to_channels" do
-        @message.stub!(:params).and_return({:type => :to_channels})
-        @message.stub!(:broadcast_to_channels)
-        @message.should_receive(:broadcast_to_channels)
+      it "should call #send_message with message body and connection list" do
+        @message.stub!(:params).and_return({:body => "some message"})
+        Socky::Connection.stub!(:find).and_return(["first","second"])
+        @message.should_receive(:send_message).with("some message", ["first", "second"])
         @message.broadcast
       end
-      it "should call #broadcast_to_clients_on_channels if message type is :to_clients_on_channels" do
-        @message.stub!(:params).and_return({:type => :to_clients_on_channels})
-        @message.stub!(:broadcast_to_clients_on_channels)
-        @message.should_receive(:broadcast_to_clients_on_channels)
-        @message.broadcast
-      end
-      it "should raise error if message type is nil" do
-        @message.stub!(:params).and_return({:type => nil})
-        lambda {@message.broadcast}.should raise_error Socky::SockyError
-      end
-      it "should raise error if message type is not one of :to_clients, :to_channels or :to_cleints_on_channels" do
-        @message.stub!(:params).and_return({:type => "invalid"})
-        lambda {@message.broadcast}.should raise_error Socky::SockyError
-      end
-    end
-    context "#broadcast_to_clients" do
-      before(:each) do
-        @message.stub!(:verify)
-        Socky::Server.stub!(:send_to_clients)
-      end
-      it "should verify :clients params existence" do
-        @message.should_receive(:verify).with(:clients)
-        @message.broadcast_to_clients
-      end
-      it "should call socky server #send_to_clients with own params" do
-        @message.stub!(:params).and_return(:body => "some message", :clients => "some clients")
-        Socky::Server.should_receive(:send_to_clients).with("some message", "some clients")
-        @message.broadcast_to_clients
-      end
-    end
-    context "#broadcast_to_channels" do
-      before(:each) do
-        @message.stub!(:verify)
-        Socky::Server.stub!(:send_to_channels)
-      end
-      it "should verify :channels params existence" do
-        @message.should_receive(:verify).with(:channels)
-        @message.broadcast_to_channels
-      end
-      it "should call socky server #send_to_channels with own params" do
-        @message.stub!(:params).and_return(:body => "some message", :channels => "some channels")
-        Socky::Server.should_receive(:send_to_channels).with("some message", "some channels")
-        @message.broadcast_to_channels
-      end
-    end
-    context "#broadcast_to_clients_on_channels" do
-      before(:each) do
-        @message.stub!(:verify)
-        Socky::Server.stub!(:send_to_clients_on_channels)
-      end
-      it "should verify :clients params existence" do
-        @message.should_receive(:verify).with(:clients)
-        @message.broadcast_to_clients_on_channels
-      end
-      it "should verify :channels params existence" do
-        @message.should_receive(:verify).with(:channels)
-        @message.broadcast_to_clients_on_channels
-      end
-      it "should call socky server #send_to_clients_on_channels with own params" do
-        @message.stub!(:params).and_return(:body => "some message", :clients => "some clients", :channels => "some channels")
-        Socky::Server.should_receive(:send_to_clients_on_channels).with("some message", "some clients", "some channels")
-        @message.broadcast_to_clients_on_channels
-      end
     end
     context "#query" do
       it "should call #query_show_connections if message type is :show_connections" do
@@ -193,28 +124,6 @@ describe Socky::Message do
         @message.query_show_connections
       end
     end
-    context "#verify" do
-      it "should convert posted field to empty array if field is nil" do
-        @message.params[:clients] = nil
-        @message.verify :clients
-        @message.params[:clients].should eql([])
-      end
-      it "should convert posted field to array containing field value if field is not array" do
-        @message.params[:clients] = "some client"
-        @message.verify :clients
-        @message.params[:clients].should eql(["some client"])
-      end
-      it "should not convert field if field is array" do
-        @message.params[:clients] = ["some client"]
-        @message.verify :clients
-        @message.params[:clients].should eql(["some client"])
-      end
-      it "should change every array value to string" do
-        @message.params[:clients] = [1,2,3]
-        @message.verify :clients
-        @message.params[:clients].should eql(["1","2","3"])
-      end
-    end
     context "#respond" do
       it "should call creator #send_message" do
         @connection.should_receive(:send_message)

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: socky
 version: !ruby/object:Gem::Version 
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 9
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors: 
 - Bernard Potocki
@@ -14,16 +15,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-20 00:00:00 +02:00
+date: 2010-08-03 00:00:00 +02:00
 default_executable: socky
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: em-websocket
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 31
         segments: 
         - 0
         - 1
@@ -35,9 +38,11 @@ dependencies:
   name: em-http-request
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -69,7 +74,6 @@ files:
 - lib/socky/options/config.rb
 - lib/socky/options/parser.rb
 - lib/socky/runner.rb
-- lib/socky/server.rb
 - spec/em-websocket_spec.rb
 - spec/files/default.yml
 - spec/files/invalid.yml
@@ -83,7 +87,6 @@ files:
 - spec/socky/options/parser_spec.rb
 - spec/socky/options_spec.rb
 - spec/socky/runner_spec.rb
-- spec/socky/server_spec.rb
 - spec/socky_spec.rb
 - spec/spec_helper.rb
 - spec/stallion.rb
@@ -97,23 +100,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Socky is a WebSocket server and client for Ruby on Rails
@@ -129,7 +136,6 @@ test_files:
 - spec/socky/options/parser_spec.rb
 - spec/socky/options_spec.rb
 - spec/socky/runner_spec.rb
-- spec/socky/server_spec.rb
 - spec/socky_spec.rb
 - spec/spec_helper.rb
 - spec/stallion.rb

data/lib/socky/server.rb

@@ -1,28 +0,0 @@
-module Socky
-  class Server
-    include Socky::Misc
-
-    class << self
-
-      def send_to_clients(message, clients)
-        connections = Socky::Connection.find_by_clients(clients)
-        send_data(message, connections)
-      end
-
-      def send_to_channels(message, channels)
-        connections = Socky::Connection.find_by_channels(channels)
-        send_data(message, connections)
-      end
-
-      def send_to_clients_on_channels(message, clients, channels)
-        connections = Socky::Connection.find_by_clients_and_channels(clients, channels)
-        send_data(message, connections)
-      end
-
-      def send_data(message, connections)
-        connections.each{|connection| connection.send_message message}
-      end
-
-    end
-  end
-end

data/spec/socky/server_spec.rb

@@ -1,35 +0,0 @@
-require 'spec/spec_helper'
-
-describe Socky::Server do
-  
-  context "class" do
-    it "#send_data should call send_message on each of provided connections" do
-      connections = []
-      3.times {|i| connections << mock("connection#{i}", :send_message => nil)}
-      connections.each{|connection| connection.should_receive(:send_message).with("abstract")}
-      described_class.send_data("abstract",connections)
-    end
-    it "#send_to_clients should find connections by clients and call #send_data on them" do
-      Socky::Connection.stub!(:find_by_clients).and_return(["first","second","third"])
-      described_class.stub!(:send_data)
-      Socky::Connection.should_receive(:find_by_clients).with("abstract")
-      described_class.should_receive(:send_data).with("message", ["first","second","third"])
-      described_class.send_to_clients("message","abstract")
-    end
-    it "#send_to_channels should find connections by channels and call #send_data on them" do
-      Socky::Connection.stub!(:find_by_channels).and_return(["first","second","third"])
-      described_class.stub!(:send_data)
-      Socky::Connection.should_receive(:find_by_channels).with("abstract")
-      described_class.should_receive(:send_data).with("message", ["first","second","third"])
-      described_class.send_to_channels("message","abstract")
-    end
-    it "#send_to_clients_on_channels should find connections by clients and channels and call #send_data on them" do
-      Socky::Connection.stub!(:find_by_clients_and_channels).and_return(["first","second","third"])
-      described_class.stub!(:send_data)
-      Socky::Connection.should_receive(:find_by_clients_and_channels).with("abstract1","abstract2")
-      described_class.should_receive(:send_data).with("message", ["first","second","third"])
-      described_class.send_to_clients_on_channels("message","abstract1","abstract2")
-    end
-  end
-  
-end