socky-client 0.4.3 → 0.5.0.beta1

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+pkg/
+*.gem

data/.travis.yml

@@ -0,0 +1,7 @@
+script: "bundle exec rake spec"
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - rbx
+  - jruby

data/CHANGELOG.md

@@ -1,11 +1,24 @@
 Changelog
 =========
 
+## 0.5.0.beta1 / 2011-08-01
+
+Socky was rewritten from scratch. From this version it's Rack application and is based on
+open protocol, and have a lot of new features. Some of them:
+
+- Rack app - you can run both Socky and your web-application in the same process!
+- New, standarized communication protocol(it will be easy to implement Socky in other languages)
+- New user authentication process - much faster and more secure
+- Allow users to dynamicly subscribe/unsubscribe from channels
+- New events system - easier to learn and much more powerfull
+
+And many more - please check [Socky website](http://socky.org) for more or check specific Socky elements at [Github](http://github.com/socky).
+
 ## 0.4.3 / 2010-10-30
 
 - new features:
   - new, simpler syntax
-- bugfixes
+- bugfixes:
   - none
 
 ## 0.4.2 / 2010-10-29

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem 'rake'

data/README.md

@@ -1,22 +1,40 @@
-Socky - client in Ruby
-===========
+# Socky - client in Ruby [![](http://travis-ci.org/socky/socky-client-ruby.png)](http://travis-ci.org/socky/socky-client-ruby)
 
-Socky is push server for Ruby based on WebSockets. It allows you to break border between your application and client browser by letting the server initialize a connection and push data to the client.
+Also important information can be found on our [google group](http://groups.google.com/group/socky-users).
 
-## Getting Started
+## Installation
 
-- [Install](http://github.com/socky/socky-client-ruby/wiki/install) the gem
-- Read up about its [Usage](http://github.com/socky/socky-client-ruby/wiki/usage) and [Configuration](http://github.com/socky/socky-client-ruby/wiki/configuration)
-- Try [Example Application](http://github.com/socky/socky-example) or [demo page](http://sockydemo.imanel.org)
-- Fork and Contribute your own modifications
-- See [sites using socky](http://github.com/socky/socky-server-ruby/wiki/sites)
-- Discuss on [google group](http://groups.google.com/group/socky-framework)
+``` bash
+$ gem install socky-client --pre
+```
+
+## Usage
+
+First require Socky Client:
+
+``` ruby
+require 'socky/client'
+```
+
+Then createn new Client instance. Parameters required are full address of Socky Server(including app name) and secret of app.
+
+``` ruby
+$socky_client = Socky::Client.new('http://ws.socky.org:3000/http/test_app', 'my_secret')
+```
+
+This instance of Socky Client can trigger events for all users of server. To do so you can use one of methods:
+
+``` ruby
+$socky_client.trigger!('my_event', :channel => 'my_channel', :data => 'my data') # Will raise on error
+$socky_client.trigger('my_event', :channel => 'my_channel', :data => 'my data') # Will return false on error
+$socky_client.trigger_async('my_event', :channel => 'my_channel', :data => 'my data') # Async method
+```
 
 ## License
 
 (The MIT License)
 
-Copyright (c) 2010 Bernard Potocki 
+Copyright (c) 2010 Bernard Potocki
 
 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:
 

data/Rakefile

@@ -1,27 +1,11 @@
-require 'rake'
-require 'rake/clean'
-CLEAN.include %w(**/*.{log,rbc})
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
 require 'rspec/core/rake_task'
 
-task :default => :spec
-
-RSpec::Core::RakeTask.new(:spec) do |t|
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["-c", "-f progress"]
+  t.pattern = 'spec/**/*_spec.rb'
 end
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "socky-client"
-    gemspec.summary = "Socky is a WebSocket server and client for Ruby"
-    gemspec.description = "Socky is a WebSocket server and client for Ruby"
-    gemspec.email = "bernard.potocki@imanel.org"
-    gemspec.homepage = "http://imanel.org/projects/socky"
-    gemspec.authors = ["Bernard Potocki"]
-    gemspec.add_dependency 'json'
-    gemspec.add_development_dependency 'rspec', '~> 2.0'
-    gemspec.files.exclude ".gitignore"
-  end
-rescue LoadError
-  puts "Jeweler not available. Install it with: gem install jeweler"
-end
+task :default => :spec

data/lib/socky/client/request.rb

@@ -0,0 +1,50 @@
+require 'socky/authenticator'
+require 'multi_json'
+require 'crack/core_extensions' # Used for Hash#to_params
+
+module Socky
+  class Client
+    class Request
+      
+      attr_reader :client, :event, :channel, :data
+
+      def initialize(client, event, channel, data = nil)
+        @client = client
+        @event = event
+        @channel = channel
+        @data = MultiJson.encode(data)
+      end
+            
+      def timestamp
+        @timestamp ||= Time.now.to_i
+      end
+      
+      def body
+        content = {}
+        content['event'] = @event
+        content['channel'] = @channel
+        content['timestamp'] = timestamp
+        content['data'] = @data
+        content['auth'] = auth_string
+        content.to_params
+      end
+      
+      private
+      
+      def auth_string
+        Authenticator.authenticate({
+          :connection_id => timestamp,
+          :channel => @channel,
+          :event => @event,
+          :data => @data
+        }, {
+          :secret => @client.secret,
+          :method => :http
+        })['auth']
+      rescue => e
+        raise AuthenticationError, e.message
+      end
+      
+    end
+  end
+end

data/lib/socky/client/version.rb

@@ -0,0 +1,5 @@
+module Socky
+  class Client
+    VERSION = '0.5.0.beta1'
+  end
+end

data/lib/socky/client.rb

@@ -0,0 +1,181 @@
+# Mostly copied from pusher gem - they did great job and probably there are no reason to reinvent wheel ;)
+autoload 'Logger', 'logger'
+require File.expand_path(File.dirname(__FILE__)) + '/client/request'
+
+module Socky
+  class Client
+    # All Socky errors descend from this class so you can easily rescue Socky errors
+    #
+    # @example
+    #   begin
+    #     socky_client.trigger!('an_event', :channel => 'my_channel', :data => {:some => 'data'})
+    #   rescue Socky::Client::Error => e
+    #     # Do something on error
+    #   end
+    class Error < RuntimeError; end
+    class ArgumentError < Error; end
+    class AuthenticationError < Error; end
+    class ConfigurationError < Error; end
+    class HTTPError < Error; attr_accessor :original_error; end
+    
+    class << self
+      attr_writer :logger
+      
+      # @private
+      def logger
+        @logger ||= begin
+          log = Logger.new($stdout)
+          log.level = Logger::INFO
+          log
+        end
+      end
+    end
+    
+    attr_reader :uri, :secret
+    attr_writer :logger
+    
+    # Create Socky::Client instance for later use.
+    # This is usually needed only once per application so it's good idea to put it in global variable
+    #
+    # @example
+    #   $socky_client = Socky::Client.new('http://example.org/http/my_app', 'my_secret')
+    #
+    # @param uri [String] Full uri(including app name) to Socky server
+    # @param secret [String] Socky App secret
+    #
+    def initialize(uri, secret)
+      @uri = URI.parse(uri)
+      @secret = secret
+    end
+    
+    # Trigger event
+    #
+    # @example
+    #   begin
+    #     $socky_client.trigger!('an_event', :channel => 'my_channe', :data => {:some => 'data'})
+    #   rescue Socky::Client::Error => e
+    #     # Do something on error
+    #   end
+    #
+    # @param [String] event Event name to be triggered in javascript.
+    # @param [Hash] opts Special options for request
+    # @option opts [String] :channel Channel to which event will be sent
+    # @option opts [Object] :data Data for trigger - Objects other than strings will be converted to JSON
+    #
+    # @raise [Socky::Client::Error] on invalid Socky Server response - see the error message for more details
+    # @raise [Socky::Client::HTTPError] on any error raised inside Net::HTTP - the original error is available in the original_error attribute
+    #
+    def trigger!(event, opts = {})
+      require 'net/http' unless defined?(Net::HTTP)
+      require 'net/https' if (ssl? && !defined?(Net::HTTPS))
+      
+      channel = opts[:channel] || opts['channel']
+      data = opts[:data] || opts['data']
+      raise ArgumentError, 'no channel provided' unless channel
+      
+      request = Socky::Client::Request.new(self, event, channel, data)
+      
+      @http_sync ||= begin
+        http = Net::HTTP.new(@uri.host, @uri.port)
+        http.use_ssl = true if ssl?
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if ssl?
+        http
+      end
+      
+      begin
+        response = @http_sync.post(@uri.path,
+          request.body, { 'Content-Type'=> 'application/json' })
+      rescue Errno::EINVAL, Errno::ECONNRESET, Errno::ECONNREFUSED,
+             Timeout::Error, EOFError,
+             Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+             Net::ProtocolError => e
+        error = Socky::Client::HTTPError.new("#{e.message} (#{e.class})")
+        error.original_error = e
+        raise error
+      end
+      
+      return handle_response(response.code.to_i, response.body.chomp)
+    end
+    
+    # Trigger event, catching and logging any errors.
+    #
+    # @note CAUTION! No exceptions will be raised on failure
+    # @param (see #trigger!)
+    #
+    def trigger(event, opts = {})
+      trigger!(event, opts)
+    rescue Socky::Client::Error => e
+      Socky::Client.logger.error("#{e.message} (#{e.class})")
+      Socky::Client.logger.debug(e.backtrace.join("\n"))
+      false
+    end
+    
+    # Trigger event asynchronously using EventMachine::HttpRequest
+    #
+    # @param (see #trigger!)
+    #
+    # @return [EM::DefaultDeferrable]
+    #   Attach a callback to be notified of success (with no parameters).
+    #   Attach an errback to be notified of failure (with an error parameter
+    #   which includes the HTTP status code returned)
+    #
+    # @raise [LoadError] unless em-http-request gem is available
+    # @raise [Socky::Client::Error] unless the eventmachine reactor is running.
+    #   You probably want to run your application inside a server such as thin.
+    #
+    def trigger_async(event, opts = {}, &block)
+      unless defined?(EventMachine) && EventMachine.reactor_running?
+        raise Error, "In order to use trigger_async you must be running inside an eventmachine loop"
+      end
+      require 'em-http' unless defined?(EventMachine::HttpRequest)
+      
+      channel = opts[:channel] || opts['channel']
+      data = opts[:data] || opts['data']
+      raise ArgumentError, 'no channel provided' unless channel
+      
+      request = Socky::Client::Request.new(self, event, channel, data)
+      
+      deferrable = EM::DefaultDeferrable.new
+      
+      http = EventMachine::HttpRequest.new(@uri).post({
+        :timeout => 5, :body => request.body, :head => {'Content-Type'=> 'application/json'}
+      })
+      http.callback {
+        begin
+          handle_response(http.response_header.status, http.response.chomp)
+          deferrable.succeed
+        rescue => e
+          deferrable.fail(e)
+        end
+      }
+      http.errback {
+        Socky::Client.logger.debug("Network error connecting to socky server: #{http.inspect}")
+        deferrable.fail(Error.new("Network error connecting to socky server"))
+      }
+      
+      deferrable
+    end
+    
+    private
+    
+    def handle_response(status_code, body)
+      case status_code
+      when 202
+        return true
+      when 400
+        raise Error, "Bad request: #{body}"
+      when 401
+        raise AuthenticationError, body
+      when 404
+        raise Error, "Resource not found: app name is probably invalid"
+      else
+        raise Error, "Unknown error (status code #{status_code}): #{body}"
+      end
+    end
+    
+    def ssl?
+      @uri.scheme == 'https'
+    end
+
+  end
+end

data/socky-client.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "socky/client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "socky-client"
+  s.version     = Socky::Client::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Bernard Potocki"]
+  s.email       = ["bernard.potocki@imanel.org"]
+  s.homepage    = "http://socky.org"
+  s.summary     = %q{Socky is a WebSocket server and client for Ruby}
+  s.description = %q{Socky is a WebSocket server and client for Ruby}
+  
+  s.add_dependency 'crack', "~> 0.1.0"
+  s.add_dependency 'multi_json', '~> 1.0'
+  s.add_dependency 'socky-authenticator', '~> 0.5.0.beta5'
+  s.add_development_dependency 'rspec', '~> 2.0'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/spec_helper.rb

@@ -2,6 +2,4 @@ require 'rubygems'
 require 'rspec'
 
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
-require 'socky-client'
-
-Socky.logger.level = Logger::ERROR
+require 'socky/client'

data/spec/unit/socky/client_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Socky::Client do
+end

metadata

@@ -1,104 +1,105 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: socky-client
-version: !ruby/object:Gem::Version 
-  hash: 9
-  prerelease: false
-  segments: 
-  - 0
-  - 4
-  - 3
-  version: 0.4.3
+version: !ruby/object:Gem::Version
+  version: 0.5.0.beta1
+  prerelease: 6
 platform: ruby
-authors: 
+authors:
 - Bernard Potocki
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-10-30 00:00:00 +02:00
+date: 2011-08-01 00:00:00.000000000 +02:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: json
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: crack
+  requirement: &70226763937280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: *70226763937280
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &70226763936780 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70226763936780
+- !ruby/object:Gem::Dependency
+  name: socky-authenticator
+  requirement: &70226763936320 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 2
-        - 0
-        version: "2.0"
+      - !ruby/object:Gem::Version
+        version: 0.5.0.beta5
+  type: :runtime
+  prerelease: false
+  version_requirements: *70226763936320
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70226763935760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :development
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: *70226763935760
 description: Socky is a WebSocket server and client for Ruby
-email: bernard.potocki@imanel.org
+email:
+- bernard.potocki@imanel.org
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- README.md
-files: 
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
 - CHANGELOG.md
+- Gemfile
 - README.md
 - Rakefile
-- VERSION
-- lib/socky-client.rb
-- lib/socky-client/websocket.rb
-- socky_hosts.yml
-- spec/socky-client_spec.rb
+- lib/socky/client.rb
+- lib/socky/client/request.rb
+- lib/socky/client/version.rb
+- socky-client.gemspec
 - spec/spec_helper.rb
+- spec/unit/socky/client_spec.rb
 has_rdoc: true
-homepage: http://imanel.org/projects/socky
+homepage: http://socky.org
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+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 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Socky is a WebSocket server and client for Ruby
-test_files: 
-- spec/socky-client_spec.rb
+test_files:
 - spec/spec_helper.rb
+- spec/unit/socky/client_spec.rb

data/VERSION

@@ -1 +0,0 @@
-0.4.3

data/lib/socky-client/websocket.rb

@@ -1,230 +0,0 @@
-# Copyright: Hiroshi Ichikawa <http://gimite.net/en/>
-# Lincense: New BSD Lincense
-# Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol
-
-require "socket"
-require "uri"
-require "digest/md5"
-require "openssl"
-
-
-class WebSocket
-
-    class << self
-
-        attr_accessor(:debug)
-
-    end
-
-    class Error < RuntimeError
-
-    end
-
-    def initialize(arg, params = {})
-
-        uri = arg.is_a?(String) ? URI.parse(arg) : arg
-
-        if uri.scheme == "ws"
-          default_port = 80
-        elsif uri.scheme = "wss"
-          default_port = 443
-        else
-          raise(WebSocket::Error, "unsupported scheme: #{uri.scheme}")
-        end
-
-        @path = (uri.path.empty? ? "/" : uri.path) + (uri.query ? "?" + uri.query : "")
-        host = uri.host + (uri.port == default_port ? "" : ":#{uri.port}")
-        origin = params[:origin] || "http://#{uri.host}"
-        key1 = generate_key()
-        key2 = generate_key()
-        key3 = generate_key3()
-
-        socket = TCPSocket.new(uri.host, uri.port || default_port)
-
-        if uri.scheme == "ws"
-          @socket = socket
-        else
-          @socket = ssl_handshake(socket)
-        end
-
-        write(
-          "GET #{@path} HTTP/1.1\r\n" +
-          "Upgrade: WebSocket\r\n" +
-          "Connection: Upgrade\r\n" +
-          "Host: #{host}\r\n" +
-          "Origin: #{origin}\r\n" +
-          "Sec-WebSocket-Key1: #{key1}\r\n" +
-          "Sec-WebSocket-Key2: #{key2}\r\n" +
-          "\r\n" +
-          "#{key3}")
-        flush()
-
-        line = gets().chomp()
-        raise(WebSocket::Error, "bad response: #{line}") if !(line =~ /\AHTTP\/1.1 101 /n)
-        read_header()
-        if @header["Sec-WebSocket-Origin"] != origin
-          raise(WebSocket::Error,
-            "origin doesn't match: '#{@header["WebSocket-Origin"]}' != '#{origin}'")
-        end
-        reply_digest = read(16)
-        expected_digest = security_digest(key1, key2, key3)
-        if reply_digest != expected_digest
-          raise(WebSocket::Error,
-            "security digest doesn't match: %p != %p" % [reply_digest, expected_digest])
-        end
-        @handshaked = true
-
-      @closing_started = false
-    end
-
-    attr_reader(:header, :path)
-
-    def send(data)
-      if !@handshaked
-        raise(WebSocket::Error, "call WebSocket\#handshake first")
-      end
-      data = force_encoding(data.dup(), "ASCII-8BIT")
-      write("\x00#{data}\xff")
-      flush()
-    end
-
-    def receive()
-      if !@handshaked
-        raise(WebSocket::Error, "call WebSocket\#handshake first")
-      end
-      packet = gets("\xff")
-      return nil if !packet
-      if packet =~ /\A\x00(.*)\xff\z/nm
-        return force_encoding($1, "UTF-8")
-      elsif packet == "\xff" && read(1) == "\x00" # closing
-        if @server
-          @socket.close()
-        else
-          close()
-        end
-        return nil
-      else
-        raise(WebSocket::Error, "input must be either '\\x00...\\xff' or '\\xff\\x00'")
-      end
-    end
-
-    def tcp_socket
-      return @socket
-    end
-
-    def host
-      return @header["Host"]
-    end
-
-    def origin
-      return @header["Origin"]
-    end
-
-    # Does closing handshake.
-    def close()
-      return if @closing_started
-      write("\xff\x00")
-      @socket.close() if !@server
-      @closing_started = true
-    end
-
-    def close_socket()
-      @socket.close()
-    end
-
-  private
-
-    NOISE_CHARS = ("\x21".."\x2f").to_a() + ("\x3a".."\x7e").to_a()
-
-    def read_header()
-      @header = {}
-      while line = gets()
-        line = line.chomp()
-        break if line.empty?
-        if !(line =~ /\A(\S+): (.*)\z/n)
-          raise(WebSocket::Error, "invalid request: #{line}")
-        end
-        @header[$1] = $2
-      end
-      if @header["Upgrade"] != "WebSocket"
-        raise(WebSocket::Error, "invalid Upgrade: " + @header["Upgrade"])
-      end
-      if @header["Connection"] != "Upgrade"
-        raise(WebSocket::Error, "invalid Connection: " + @header["Connection"])
-      end
-    end
-
-    def gets(rs = $/)
-      line = @socket.gets(rs)
-      $stderr.printf("recv> %p\n", line) if WebSocket.debug
-      return line
-    end
-
-    def read(num_bytes)
-      str = @socket.read(num_bytes)
-      $stderr.printf("recv> %p\n", str) if WebSocket.debug
-      return str
-    end
-
-    def write(data)
-      if WebSocket.debug
-        data.scan(/\G(.*?(\n|\z))/n) do
-          $stderr.printf("send> %p\n", $&) if !$&.empty?
-        end
-      end
-      @socket.write(data)
-    end
-
-    def flush()
-      @socket.flush()
-    end
-
-    def security_digest(key1, key2, key3)
-      bytes1 = websocket_key_to_bytes(key1)
-      bytes2 = websocket_key_to_bytes(key2)
-      return Digest::MD5.digest(bytes1 + bytes2 + key3)
-    end
-
-    def generate_key()
-      spaces = 1 + rand(12)
-      max = 0xffffffff / spaces
-      number = rand(max + 1)
-      key = (number * spaces).to_s()
-      (1 + rand(12)).times() do
-        char = NOISE_CHARS[rand(NOISE_CHARS.size)]
-        pos = rand(key.size + 1)
-        key[pos...pos] = char
-      end
-      spaces.times() do
-        pos = 1 + rand(key.size - 1)
-        key[pos...pos] = " "
-      end
-      return key
-    end
-
-    def generate_key3()
-      return [rand(0x100000000)].pack("N") + [rand(0x100000000)].pack("N")
-    end
-
-    def websocket_key_to_bytes(key)
-      num = key.gsub(/[^\d]/n, "").to_i() / key.scan(/ /).size
-      return [num].pack("N")
-    end
-
-    def force_encoding(str, encoding)
-      if str.respond_to?(:force_encoding)
-        return str.force_encoding(encoding)
-      else
-        return str
-      end
-    end
-
-    def ssl_handshake(socket)
-      ssl_context = OpenSSL::SSL::SSLContext.new()
-      ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
-      ssl_socket.sync_close = true
-      ssl_socket.connect()
-      return ssl_socket
-    end
-
-end

data/lib/socky-client.rb

@@ -1,135 +0,0 @@
-require 'json'
-require 'logger'
-require 'yaml'
-
-require File.dirname(__FILE__) + '/socky-client/websocket'
-
-module Socky
-
-  class << self
-    
-    attr_accessor :config_path, :logger
-    def config_path
-      @config_path ||= 'socky_hosts.yml'
-    end
-    
-    def config
-      @config ||= YAML.load_file(config_path).freeze
-    end
-
-    def send(*args)
-      options = normalize_options(*args)
-      send_message(options.delete(:data), options)
-    end
-
-    def show_connections
-      send_query(:show_connections)
-    end
-
-    def hosts
-      config[:hosts]
-    end
-    
-    def logger
-      @logger ||= Logger.new(STDOUT)
-    end
-    
-    def deprecation_warning(msg)
-      logger.warn "DEPRECATION WARNING: " + msg.to_s
-    end
-
-  private
-
-    def normalize_options(data, options = {})
-      case data
-        when Hash
-          options, data = data, nil
-        when String, Symbol
-          options[:data] = data
-      else
-        options.merge!(:data => data)
-      end
-
-      options[:data] = options[:data].to_s
-      options
-    end
-
-    def send_message(data, opts = {})
-      to = opts[:to] || {}
-      except = opts[:except] || {}
-      
-      # Move to new syntax
-      if opts[:to] || opts[:except]
-        deprecation_warning "Using of :to and :except will be removed in next version - please move to new syntax."        
-      end
-      to[:client]   ||= opts[:client]
-      to[:clients]  ||= opts[:clients]
-      to[:channel]  ||= opts[:channel]
-      to[:channels] ||= opts[:channels]
-      # end of new syntax
-
-      unless to.is_a?(Hash) && except.is_a?(Hash)
-        raise "recipiend data should be in hash format"
-      end
-
-      to_clients = to[:client] || to[:clients]
-      to_channels = to[:channel] || to[:channels]
-      except_clients = except[:client] || except[:clients]
-      except_channels = except[:channel] || except[:channels]
-
-      # If clients or channels are non-nil but empty then there's no users to target message
-      return if (to_clients.is_a?(Array) && to_clients.empty?) || (to_channels.is_a?(Array) && to_channels.empty?)
-
-      hash = {
-        :command  => :broadcast,
-        :body     => data,
-        :to => {
-          :clients  => to_clients,
-          :channels => to_channels,
-        },
-        :except => {
-          :clients  => except_clients,
-          :channels => except_channels,
-        }
-      }
-
-      [:to, :except].each do |type|
-        hash[type].reject! { |key,val| val.nil? || (type == :except && val.empty?)}
-        hash.delete(type) if hash[type].empty?
-      end
-
-      send_data(hash)
-    end
-
-    def send_query(type)
-      hash = {
-        :command  => :query,
-        :type     => type
-      }
-      send_data(hash, true)
-    end
-
-    def send_data(hash, response = false)
-      res = []
-      hosts.each do |address|
-        begin
-          scheme = (address[:secure] ? "wss" : "ws")
-          @socket = WebSocket.new("#{scheme}://#{address[:host]}:#{address[:port]}/?admin=1&client_secret=#{address[:secret]}")
-          @socket.send(hash.to_json)
-          res << @socket.receive if response
-        rescue
-          puts "ERROR: Connection to server at '#{scheme}://#{address[:host]}:#{address[:port]}' failed"
-        ensure
-          @socket.close if @socket && !@socket.tcp_socket.closed?
-        end
-      end
-      if response
-        res.collect {|r| JSON.parse(r)["body"] }
-      else
-        true
-      end
-    end
-
-  end
-
-end

data/socky_hosts.yml

@@ -1,5 +0,0 @@
-:hosts:
-  - :host: 127.0.0.1
-    :port: 8080
-    :secret: my_secret_key
-    :secure: false

data/spec/socky-client_spec.rb

@@ -1,194 +0,0 @@
-require 'spec_helper'  
-
-describe Socky do
-  it "should have config in hash form" do
-    Socky.config.should_not be_nil
-    Socky.config.class.should eql(Hash)
-  end
-  
-  it "should have host list taken from config" do
-    Socky.hosts.should eql(Socky.config[:hosts])
-  end
-  
-  context "#send" do
-    before(:each) do
-      Socky.stub!(:send_data)
-    end
-    it "should send broadcast with data" do
-      Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
-      Socky.send("test")
-    end
-    context "should normalize options" do
-      it "when nil given" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => ""})
-        Socky.send(nil)
-      end
-      it "when string given" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
-        Socky.send("test")
-      end
-      it "when hash given" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
-        Socky.send({:data => "test"})
-      end
-      it "when hash without body given" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => ""})
-        Socky.send({})
-      end
-    end
-    context "should handle recipient conditions for" do
-      # New syntax
-      it ":client" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :to => { :clients => "first" }})
-        Socky.send("test", :client => "first")
-      end
-      it ":clients" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :to => { :clients => ["first","second"] }})
-        Socky.send("test", :clients => ["first","second"])
-      end
-      it ":channel" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :to => { :channels => "first" }})
-        Socky.send("test", :channel => "first")
-      end
-      it ":channels" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :to => { :channels => ["first","second"] }})
-        Socky.send("test", :channels => ["first","second"])
-      end
-      it "combination" do
-        Socky.should_receive(:send_data).with({
-          :command => :broadcast,
-          :body => "test",
-          :to => {
-            :clients => "allowed_user",
-            :channels => "allowed_channel"
-          }
-        })
-        Socky.send("test", :clients => "allowed_user", :channels => "allowed_channel")
-      end      
-      # Old syntax
-      it ":to => :client" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :to => { :clients => "first" }})
-        Socky.send("test", :to => { :client => "first" })
-      end
-      it ":to => :clients" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :to => { :clients => ["first","second"] }})
-        Socky.send("test", :to => { :clients => ["first","second"] })
-      end
-      it ":to => :channel" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :to => { :channels => "first" }})
-        Socky.send("test", :to => { :channel => "first" })
-      end
-      it ":to => :channels" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :to => { :channels => ["first","second"] }})
-        Socky.send("test", :to => { :channels => ["first","second"] })
-      end
-      it ":except => :client" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :except => { :clients => "first" }})
-        Socky.send("test", :except => { :client => "first" })
-      end
-      it ":except => :clients" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :except => { :clients => ["first","second"] }})
-        Socky.send("test", :except => { :clients => ["first","second"] })
-      end
-      it ":except => :channel" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :except => { :channels => "first" }})
-        Socky.send("test", :except => { :channel => "first" })
-      end
-      it ":except => :channels" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :except => { :channels => ["first","second"] }})
-        Socky.send("test", :except => { :channels => ["first","second"] })
-      end
-      it "combination" do
-        Socky.should_receive(:send_data).with({
-          :command => :broadcast,
-          :body => "test",
-          :to => {
-            :clients => "allowed_user",
-            :channels => "allowed_channel"
-          },
-          :except => {
-            :clients => "disallowed_user",
-            :channels => "disallowed_channel"
-          }
-        })
-        Socky.send("test", :to => {
-          :clients => "allowed_user",
-          :channels => "allowed_channel"
-        },
-        :except => {
-          :clients => "disallowed_user",
-          :channels => "disallowed_channel"
-        })
-      end
-    end
-    context "should ignore nil value for" do
-      # New syntax
-      it ":clients" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
-        Socky.send("test", :clients => nil)
-      end
-      it ":channels" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
-        Socky.send("test", :channels => nil)
-      end
-      
-      # Old syntax
-      it ":to => :clients" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
-        Socky.send("test", :to => { :clients => nil })
-      end
-      it ":to => :channels" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
-        Socky.send("test", :to => { :channels => nil })
-      end
-      it ":except => :clients" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
-        Socky.send("test", :except => { :clients => nil })
-      end
-      it ":except => :channels" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
-        Socky.send("test", :except => { :channels => nil })
-      end
-    end
-    context "should handle empty array for" do
-      # New syntax
-      it ":clients by not sending message" do
-        Socky.should_not_receive(:send_data)
-        Socky.send("test", :clients => [])
-      end
-      it ":channels by not sending message" do
-        Socky.should_not_receive(:send_data)
-        Socky.send("test", :channels => [])
-      end
-      
-      # Old syntax
-      it ":to => :clients by not sending message" do
-        Socky.should_not_receive(:send_data)
-        Socky.send("test", :to => { :clients => [] })
-      end
-      it ":to => :channels by not sending message" do
-        Socky.should_not_receive(:send_data)
-        Socky.send("test", :to => { :channels => [] })
-      end
-      it ":except => :clients by ignoring it" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
-        Socky.send("test", :except => { :clients => [] })
-      end
-      it ":except => :channels by ignoring it" do
-        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
-        Socky.send("test", :except => { :channels => [] })
-      end
-    end
-  end
-  
-  context "#show_connections" do
-    before(:each) do
-      Socky.stub!(:send_data)
-    end
-    it "should send query :show_connections" do
-      Socky.should_receive(:send_data).with({:command => :query, :type => :show_connections}, true)
-      Socky.show_connections
-    end
-  end
-  
-end