smartfox_jruby 0.2.1-java → 0.2.2-java

data/Doubleshot

@@ -1,21 +1,27 @@
 # encoding: utf-8
 require 'pathname'
-require Pathname.new(File.dirname(File.expand_path(__FILE__))).join('lib/smartfox_jruby.rb')
+require File.join(File.dirname(File.expand_path(__FILE__)),"lib", "smartfox_jruby")
+
 Doubleshot.new do |config|
 
   config.project = "smartfox_jruby"
   config.version = SmartfoxJruby::VERSION
 
-  config.gem 'activesupport', '~> 3.2.8'
-  config.gem 'json'
-  config.gem 'rspec', '~> 2.10.0'
-
-  config.mvn_repository 'http://repo1.maven.org/maven2'
-  config.mvn_repository 'http://artifactory-innovations.i-free.ru/artifactory/ext-release-local'
-
+  config.mvn_repository 'http://maven.smecsia.me/'
   config.jar 'com.smartfox2x.client:sfs2x-client-core:jar:1.0.4'
   config.jar 'com.smartfox2x.client:sfs2x-api-java:jar:1.0.4'
   config.jar 'org.slf4j:slf4j-log4j12:jar:1.5.10'
+  config.jar 'io.netty:netty:jar:3.5.3.Final'
+  config.jar 'commons-beanutils:commons-beanutils:jar:1.7.0'
+  config.jar 'net.sf.ezmorph:ezmorph:jar:1.0.6'
+  config.jar 'net.sf.json-lib:json-lib:jar:jdk5:2.2.3'
+  config.jar 'commons-lang:commons-lang:jar:2.5'
+  config.jar 'commons-collections:commons-collections:jar:3.2.1'
+  config.jar 'commons-logging:commons-logging:jar:1.1.1'
+
+  config.gem 'activesupport', '~> 3.2.8'
+  config.gem 'json'
+  config.gem 'rspec', '~> 2.10.0'
 
   config.gemspec do |spec|
     spec.summary = "Smartfox client for jruby"
@@ -29,4 +35,4 @@ Doubleshot.new do |config|
     spec.license = "Apache 2.0"
   end
 
-end
+end

data/lib/smartfox_jruby/common.rb

@@ -20,35 +20,38 @@ module ISFSObject
   end
 end
 
-module SmartfoxJruby::SFSUtil
-  class << self
-    def boxing(v, type)
-      case type
-        when :long
-          java.lang.Long.valueOf(v)
-        when :float
-          java.lang.Float.valueOf(v)
-        when :double
-          java.lang.Double.valueOf(v)
-        when :int
-          java.lang.Integer.valueOf(v)
-        when :boolean
-          java.lang.Boolean.valueOf(v)
-        else
-          v
+module SmartfoxJruby
+  module SFSUtil
+    class << self
+      def boxing(v, type)
+        case type
+          when :long
+            java.lang.Long.valueOf(v)
+          when :float
+            java.lang.Float.valueOf(v)
+          when :double
+            java.lang.Double.valueOf(v)
+          when :int
+            java.lang.Integer.valueOf(v)
+          when :boolean
+            java.lang.Boolean.valueOf(v)
+          else
+            v
+        end
       end
-    end
 
-    def to_java_list(value, type)
-      list = java.util.ArrayList.new
-      value.to_java(type).each do |v|
-        list.add(boxing(v, type))
+      def to_java_list(value, type)
+        list = java.util.ArrayList.new
+        value.to_java(type).each do |v|
+          list.add(boxing(v, type))
+        end
+        list
       end
-      list
     end
   end
 end
 
+
 def SFSObject.from_hash(hash, opts = {})
   res = SFSObject.new
   opts ||= {}

data/lib/smartfox_jruby/sfs_adapter.rb

@@ -1,172 +1,174 @@
 require File.expand_path(File.dirname(__FILE__) + '/sfs_worker')
 
-class SmartfoxJruby::SfsAdapter
-  include IEventListener
-  attr_reader :opts
-  attr_reader :smart_fox
-  attr_reader :worker
-  attr_reader :username
-  DEBUG = false
-
-  def initialize(opts = {})
-    @opts = opts
-    debug "initializing sfs adapter..."
-    @smart_fox = SmartFox.new(false)
-    @connected = false
-    @worker = opts[:worker]
-    @login_as = opts[:login_as] || {}
-    @opts[:timeout] ||= 20
-    @opts[:logger] ||= Logger.new(STDOUT)
-    SFSEvent.constants.each do |evt|
-      evt_value = SFSEvent.const_get(evt)
-      debug "Registering event adapter to self for event '#{evt}' --> '#{evt_value}'..."
-      smart_fox.add_event_listener(evt_value, self)
+module SmartfoxJruby
+
+  class SfsAdapter
+    include IEventListener
+    attr_reader :opts
+    attr_reader :smart_fox
+    attr_reader :worker
+    attr_reader :username
+    DEBUG = false
+
+    def initialize(opts = {})
+      @opts = opts
+      @smart_fox = SmartFox.new(false)
+      @connected = false
+      @worker = opts[:worker]
+      @login_as = opts[:login_as] || {}
+      @opts[:timeout] ||= 20
+      @opts[:logger] ||= Logger.new(STDOUT)
+      SFSEvent.constants.each do |evt|
+        evt_value = SFSEvent.const_get(evt)
+        debug "Registering event adapter to self for event '#{evt}' --> '#{evt_value}'..."
+        smart_fox.add_event_listener(evt_value, self)
+      end
+      debug "initializing sfs adapter..."
     end
-  end
 
-  def connect!(opt = {})
-    opts.reverse_merge!(opt)
-    raise "host and port are required to connect SfsAdapter!" if opts[:host].blank? || opts[:port].blank?
-    debug "connecting to smartfox at #{opts[:host]}:#{opts[:port]} ..."
-    smart_fox.connect(opts[:host], opts[:port])
-  end
+    def connect!(opt = {})
+      opts.reverse_merge!(opt)
+      raise "host and port are required to connect SfsAdapter!" if opts[:host].blank? || opts[:port].blank?
+      debug "connecting to smartfox at #{opts[:host]}:#{opts[:port]} ..."
+      smart_fox.connect(opts[:host], opts[:port])
+    end
 
-  def dispatch(event)
-    debug "got event #{event.type}: #{event}"
-    callback = "on_#{event.type.try(:underscore)}_event"
-    if respond_to?(callback, true)
-      send(callback, event)
-    else
-      debug "Unknown event caught #{event.type} (No method '#{callback}' in #{self})"
+    def dispatch(event)
+      debug "got event #{event.type}: #{event}"
+      callback = "on_#{event.type.try(:underscore)}_event"
+      if respond_to?(callback, true)
+        send(callback, event)
+      else
+        debug "Unknown event caught #{event.type} (No method '#{callback}' in #{self})"
+      end
     end
-  end
 
-  def disconnect!
-    smart_fox.disconnect
-  end
+    def disconnect!
+      smart_fox.disconnect
+    end
 
-  def process!(wrk = nil, &block)
-    wait_with_timeout(@opts[:timeout]) { connected? }
-    @worker = wrk || opts[:worker]
-    if block_given? && connected?
-      instance_eval(&block)
-    else
-      raise "Worker is null!" if @worker.blank?
-      raise "Not connected!" unless connected?
+    def process!(wrk = nil, &block)
+      wait_with_timeout(@opts[:timeout]) { connected? }
+      @worker = wrk || opts[:worker]
+      if block_given? && connected?
+        instance_eval(&block)
+      else
+        raise "Worker is null!" if @worker.blank?
+        raise "Not connected!" unless connected?
+      end
+      worker.perform!
     end
-    worker.perform!
-  end
 
-  def connected?
-    @connected
-  end
+    def connected?
+      @connected
+    end
 
-  def on_connect(&block)
-    @on_connect ||= []
-    @on_connect << block if block_given?
-  end
+    def on_connect(&block)
+      @on_connect ||= []
+      @on_connect << block if block_given?
+    end
 
-  def on_login(&block)
-    @on_login ||= []
-    @on_login << block if block_given?
-  end
+    def on_login(&block)
+      @on_login ||= []
+      @on_login << block if block_given?
+    end
 
-  def login_as(username, password, params = {})
-    params = input_params.to_sfsobject if params.is_a?(Hash)
-    @login_as ||= {:username => username, :password => password, :params => params}
-  end
+    def login_as(username, password, params = {})
+      params = params.to_sfsobject if params.is_a?(Hash)
+      @login_as = {:username => username, :password => password, :params => params}
+    end
 
-  private
+    private
 
-  ###############
-  ### HELPERS ###
+    ###############
+    ### HELPERS ###
 
-  def request(*args)
-    worker.request(*args)
-  end
+    def request(*args)
+      worker.request(*args)
+    end
 
-  def worker(opts = {})
-    @worker ||= SfsWorker::Worker.new(@smart_fox, opts)
-    @worker
-  end
+    def worker(opts = {})
+      @worker ||= SfsWorker::Worker.new(@smart_fox, opts)
+      @worker
+    end
 
-  def sfs_send(req)
-    smart_fox.send(req)
-  end
+    def sfs_send(req)
+      smart_fox.send(req)
+    end
 
-  #########################
-  ### EVENTS PROCESSORS ###
+    #########################
+    ### EVENTS PROCESSORS ###
 
-  def on_extension_response_event(event)
-    debug "extension_response #{event.arguments.get("cmd")}"
-    @worker.response(event.arguments.get("cmd"), event.arguments.get("params").try(:to_hash) || {}) unless @worker.blank?
-  end
+    def on_extension_response_event(event)
+      debug "extension_response #{event.arguments.get("cmd")}"
+      @worker.response(event.arguments.get("cmd"), event.arguments.get("params").try(:to_hash) || {}) unless @worker.blank?
+    end
 
-  def on_connection_event(event)
-    debug "on_connection #{event}"
-    @on_connect.each { |block|
-      block.call(event) if block.is_a?(Proc)
-    } unless @on_connect.blank?
-    sfs_send(LoginRequest.new(@login_as[:username], @login_as[:password], opts[:zone],
-                              (@login_as[:params] || {}).to_sfsobject));
-  end
+    def on_connection_event(event)
+      debug "on_connection #{event}"
+      @on_connect.each { |block|
+        block.call(event) if block.is_a?(Proc)
+      } unless @on_connect.blank?
+      sfs_send(LoginRequest.new(@login_as[:username], @login_as[:password], opts[:zone],
+                                (@login_as[:params] || {}.to_sfsobject)));
+    end
 
-  def on_login_event(event)
-    args = event.arguments.get("data").to_hash
-    user = event.arguments.get("user")
-    debug("on_login, args=#{args.to_json}")
-    unless user.blank?
-      info "connected as #{user.name}"
-      @username = user.name
-      @connected = true
-      @on_login.each { |block|
-        block.call(@username) if block.is_a?(Proc)
-      } unless @on_login.blank?
-    else
-      raise "login error '#{args[Aimy::Param.ERROR_MESSAGE]}'"
+    def on_login_event(event)
+      args = event.arguments.get("data").to_hash
+      user = event.arguments.get("user")
+      debug("on_login, args=#{args.to_json}")
+      unless user.blank?
+        info "connected as #{user.name}"
+        @username = user.name
+        @connected = true
+        @on_login.each { |block|
+          block.call(@username) if block.is_a?(Proc)
+        } unless @on_login.blank?
+      else
+        raise "login error '#{args[Aimy::Param.ERROR_MESSAGE]}'"
+      end
     end
-  end
 
-  def on_login_error_event(event)
-    error("error while logging-in: #{event.arguments}")
-  end
+    def on_login_error_event(event)
+      error("error while logging-in: #{event.arguments}")
+    end
 
-  def on_connection_lost_event(event)
-    # nothing to do
-  end
+    def on_connection_lost_event(event)
+      # nothing to do
+    end
 
-  def on_handshake_event(event)
-    # nothing to do
-  end
+    def on_handshake_event(event)
+      # nothing to do
+    end
 
 
-  #######################
-  ### SERVICE HELPERS ###
+    #######################
+    ### SERVICE HELPERS ###
 
-  def logger
-    opts[:logger]
-  end
+    def logger
+      opts[:logger]
+    end
 
-  def debug_enabled?
-    opts[:debug] || DEBUG
-  end
+    def debug_enabled?
+      opts[:debug] || DEBUG
+    end
 
-  def debug(msg)
-    logger.debug "#{msg}" if debug_enabled?
-  end
+    def debug(msg)
+      logger.debug "#{msg}" if debug_enabled?
+    end
 
-  def info(msg)
-    logger.info "#{msg}"
-  end
+    def info(msg)
+      logger.info "#{msg}"
+    end
 
-  def log(msg)
-    logger.info "#{msg}"
-  end
+    def log(msg)
+      logger.info "#{msg}"
+    end
 
-  def error(msg)
-    logger.error "#{msg}"
-  end
+    def error(msg)
+      logger.error "#{msg}"
+    end
 
+  end
 
 end
-

data/lib/smartfox_jruby/sfs_runner.rb

@@ -3,120 +3,123 @@ require File.expand_path(File.dirname(__FILE__) + '/common')
 java_import java.lang.Runtime
 java_import java.lang.System
 
-class SmartfoxJruby::SfsRunner
-
-  def initialize(home_dir, opts = {})
-    @home_dir = home_dir
-    @opts = opts
-    @launched = false
-    @fault = false
-    @pid = nil
-  end
+module SmartfoxJruby
+  class SfsRunner
+
+    def initialize(home_dir, opts = {})
+      @home_dir = home_dir
+      @opts = opts
+      @launched = false
+      @fault = false
+      @pid = nil
+    end
 
-  def run!
-    Thread.new do
-      begin
-        info "Changing dir to #{work_dir}"
-        Dir.chdir(work_dir) do
-          info "Running cmd #{cmd}"
-          IO.popen(cmd) do |output|
-            @pid = output.pid
-            info "Running child with pid=#{output.pid}..."
-            output.each do |line|
-              debug(line.gsub(/\n/, ""))
-              @launched = true if line =~ /SmartFoxServer 2X \(.+\) READY!/
+    def run!
+      Thread.new do
+        begin
+          info "Changing dir to #{work_dir}"
+          Dir.chdir(work_dir) do
+            info "Running cmd #{cmd}"
+            IO.popen(cmd) do |output|
+              @pid = output.pid
+              info "Running child with pid=#{output.pid}..."
+              output.each do |line|
+                debug(line.gsub(/\n/, ""))
+                @launched = true if line =~ /SmartFoxServer 2X \(.+\) READY!/
+              end
             end
+            @fault = true
           end
-          @fault = true
+        rescue Exception => e
+          error "#{e}"
         end
-      rescue Exception => e
-        error "#{e}"
       end
     end
-  end
 
-  def kill!
-    info "Checking running processes: #{pids.join(",")}"
-    pids.each { |pid|
-      pid = pid.try(:strip).try(:to_i)
-      info "Killing the process with pid=#{pid}..."
-      Process.kill("KILL", pid) if Process.alive?(pid)
-      wait_with_timeout(5) { !Process.alive?(pid) } rescue ""
-    }
-  end
+    def kill!
+      info "Checking running processes: #{pids.join(",")}"
+      pids.each { |pid|
+        pid = pid.try(:strip).try(:to_i)
+        info "Killing the process with pid=#{pid}..."
+        Process.kill("KILL", pid) if Process.alive?(pid)
+        wait_with_timeout(5) { !Process.alive?(pid) } rescue ""
+      }
+    end
 
-  def run_and_wait!(opts = {})
-    run!
-    wait_until_launched_or_fault(opts[:timeout])
-  end
+    def run_and_wait!(opts = {})
+      run!
+      wait_until_launched_or_fault(opts[:timeout])
+    end
 
 
-  def kill_and_wait!(opts = {})
-    kill!
-    wait_until_terminated(opts[:timeout])
-  end
+    def kill_and_wait!(opts = {})
+      kill!
+      wait_until_terminated(opts[:timeout])
+    end
 
-  def running?
-    !pids.blank? && pids.map { |pid| Process.alive?(pid.to_i) }.include?(true)
-  end
+    def running?
+      !pids.blank? && pids.map { |pid| Process.alive?(pid.to_i) }.include?(true)
+    end
 
-  def launched?
-    @launched
-  end
+    def launched?
+      @launched
+    end
 
-  def fault?
-    @fault
-  end
+    def fault?
+      @fault
+    end
 
-  def wait_until_terminated(timeout = nil)
-    wait_with_timeout(timeout) { !running? }
-  end
+    def wait_until_terminated(timeout = nil)
+      wait_with_timeout(timeout) { !running? }
+    end
 
-  def wait_until_launched_or_fault(timeout = nil)
-    wait_with_timeout(timeout) { launched? or fault? }
-  end
+    def wait_until_launched_or_fault(timeout = nil)
+      wait_with_timeout(timeout) { launched? or fault? }
+    end
 
-  private
+    private
 
-  def pids
-    pids_out = `pgrep -f "#{work_dir}"`
-    (pids_out.try(:split, "\n")) || []
-  end
+    def pids
+      pids_out = `pgrep -f "#{work_dir}"`
+      (pids_out.try(:split, "\n")) || []
+    end
 
-  def error(msg)
-    @opts[:logger].error(msg) unless @opts[:logger].blank?
-  end
+    def error(msg)
+      @opts[:logger].error(msg) unless @opts[:logger].blank?
+    end
 
-  def debug(msg)
-    @opts[:logger].debug(msg) unless @opts[:logger].blank?
-  end
+    def debug(msg)
+      @opts[:logger].debug(msg) unless @opts[:logger].blank?
+    end
 
-  def info(msg)
-    @opts[:logger].info(msg) unless @opts[:logger].blank?
-  end
+    def info(msg)
+      @opts[:logger].info(msg) unless @opts[:logger].blank?
+    end
 
-  def work_dir
-    Pathname.new(@home_dir).join("SFS2X").to_s
-  end
+    def work_dir
+      Pathname.new(@home_dir).join("SFS2X").to_s
+    end
 
-  def env
-    %W[].to_java :string
-  end
+    def env
+      %W[].to_java :string
+    end
 
-  def cmd
-    %Q[#{java_bin} -cp #{classpath} #{java_opts} -Dsmartfox.work_dir="#{work_dir}" com.smartfoxserver.v2.Main]
-  end
+    def cmd
+      %Q[#{java_bin} -cp #{classpath} #{java_opts} -Dsmartfox.work_dir="#{work_dir}" com.smartfoxserver.v2.Main]
+    end
 
-  def java_bin
-    Pathname.new(System.getProperty("java.home")).join("bin").join("java")
-  end
+    def java_bin
+      Pathname.new(System.getProperty("java.home")).join("bin").join("java")
+    end
 
-  def java_opts
-    %Q[-XX:MaxPermSize=512m -Xms128m -Xms1024m]
-  end
+    def java_opts
+      %Q[-XX:MaxPermSize=512m -Xms128m -Xms1024m]
+    end
+
+    def classpath
+      %Q[aimy:./:lib/*:lib/Jetty/*:extensions/__lib__/*]
+    end
 
-  def classpath
-    %Q[aimy:./:lib/*:lib/Jetty/*:extensions/__lib__/*]
   end
 
 end

data/lib/smartfox_jruby/sfs_worker.rb

@@ -1,256 +1,258 @@
 require 'thread'
 require File.expand_path(File.dirname(__FILE__) + '/common')
 
-module SmartfoxJruby::SfsWorker
-  class Processor
-    attr_accessor :opts
-    attr_accessor :name
-    attr_accessor :chained
-    attr_accessor :current
-    attr_accessor :blocks
-
-    def initialize(name, opts = {}, &block)
-      @blocks = [block]
-      @name = name
-      @current = self
-      @chained = nil
-      @opts = opts
-    end
+module SmartfoxJruby
+  module SfsWorker
+    class Processor
+      attr_accessor :opts
+      attr_accessor :name
+      attr_accessor :chained
+      attr_accessor :current
+      attr_accessor :blocks
+
+      def initialize(name, opts = {}, &block)
+        @blocks = [block]
+        @name = name
+        @current = self
+        @chained = nil
+        @opts = opts
+      end
 
-    def chain(name, &block)
-      link.chained = Processor.new(name, @opts, &block)
-      self
-    end
+      def chain(name, &block)
+        link.chained = Processor.new(name, @opts, &block)
+        self
+      end
 
-    def link
-      p = current
-      p = p.chained while (!p.try(:chained).blank?)
-      p
-    end
+      def link
+        p = current
+        p = p.chained while (!p.try(:chained).blank?)
+        p
+      end
 
-    def append(&block)
-      unless link.blank?
-        link.blocks << block
-      else
-        current.blocks << block
+      def append(&block)
+        unless link.blank?
+          link.blocks << block
+        else
+          current.blocks << block
+        end
+        self
       end
-      self
-    end
 
-    def completed?
-      current.blank?
-    end
+      def completed?
+        current.blank?
+      end
 
-    def mandatory?
-      @opts[:mandatory].nil? || @opts[:mandatory]
-    end
+      def mandatory?
+        @opts[:mandatory].nil? || @opts[:mandatory]
+      end
 
-    def event(name, data = {})
-      if @current.name.to_s == name.to_s
-        @current.blocks.each { |b| b.call(data) }
-        @current = (@current.chained.blank?) ? nil : @current.chained
-        return true
+      def event(name, data = {})
+        if @current.name.to_s == name.to_s
+          @current.blocks.each { |b| b.call(data) }
+          @current = (@current.chained.blank?) ? nil : @current.chained
+          return true
+        end
+        false
       end
-      false
-    end
 
-    def to_s
-      "Proc[#{current.try(:name)}] --> #{current.try(:chained)}"
+      def to_s
+        "Proc[#{current.try(:name)}] --> #{current.try(:chained)}"
+      end
     end
-  end
 
-  class Request
-    attr_reader :name
-    attr_reader :data
+    class Request
+      attr_reader :name
+      attr_reader :data
 
-    def initialize(name, data = {})
-      @name = name
-      @data = data
-    end
+      def initialize(name, data = {})
+        @name = name
+        @data = data
+      end
 
-    def to_extension_request
-      ExtensionRequest.new(@name.to_s, @data)
-    end
+      def to_extension_request
+        ExtensionRequest.new(@name.to_s, @data)
+      end
 
-    def to_s
-      "Req[#{@name}]#{data.to_json}"
+      def to_s
+        "Req[#{@name}]#{data.to_json}"
+      end
     end
-  end
 
-  class Response < Request
-    def to_s
-      "Resp[#{@name}]#{data.to_json}"
+    class Response < Request
+      def to_s
+        "Resp[#{@name}]#{data.to_json}"
+      end
     end
-  end
 
-  class ContextWorker
+    class ContextWorker
 
-    def request(name, data = {})
-      @worker.request(name, data, :context => @context)
-    end
+      def request(name, data = {})
+        @worker.request(name, data, :context => @context)
+      end
 
-    def append_processor(opts = {}, &block)
-      @worker.append_processor(opts.merge(:context => @context), &block)
-    end
+      def append_processor(opts = {}, &block)
+        @worker.append_processor(opts.merge(:context => @context), &block)
+      end
 
-    def expect(name, opts={}, &block)
-      @worker.expect(name, opts.merge(:context => @context), &block)
-    end
+      def expect(name, opts={}, &block)
+        @worker.expect(name, opts.merge(:context => @context), &block)
+      end
 
-    def initialize(context, worker)
-      @context = context
-      @worker = worker
+      def initialize(context, worker)
+        @context = context
+        @worker = worker
+      end
     end
-  end
 
-  class Worker
-    attr_reader :send_queue
-    attr_reader :events_queue
-    attr_reader :processors
-    attr_reader :smart_fox
-    attr_reader :opts
-
-    def initialize(smart_fox, opts = {})
-      @send_queue = []
-      @processors = []
-      @events_queue = []
-      @opts = opts
-      @opts[:timeout] ||= 20
-      @smart_fox = smart_fox
-      @mutex = Mutex.new
-      @send_qm = Mutex.new
-    end
+    class Worker
+      attr_reader :send_queue
+      attr_reader :events_queue
+      attr_reader :processors
+      attr_reader :smart_fox
+      attr_reader :opts
+
+      def initialize(smart_fox, opts = {})
+        @send_queue = []
+        @processors = []
+        @events_queue = []
+        @opts = opts
+        @opts[:timeout] ||= 20
+        @smart_fox = smart_fox
+        @mutex = Mutex.new
+        @send_qm = Mutex.new
+      end
 
-    def append_processor(opts = {}, &block)
-      debug "appending processor with context #{opts[:context]}"
-      if opts[:context]
-        context = opts[:context].append(&block)
-      else
-        context = processors.last.append(&block)
+      def append_processor(opts = {}, &block)
+        debug "appending processor with context #{opts[:context]}"
+        if opts[:context]
+          context = opts[:context].append(&block)
+        else
+          context = processors.last.append(&block)
+        end
+        ContextWorker.new(context, self)
       end
-      ContextWorker.new(context, self)
-    end
 
-    def request(name, data = {}, opts = {})
-      debug "create request #{name} with context #{opts[:context]}"
-      data = data.to_sfsobject(opts[:serialize_opts]) if data.is_a?(Hash)
-      req = Request.new(name, data)
-      if !opts[:context].blank? && opts[:context].is_a?(Processor)
-        debug "appending #{req} to processor #{opts[:context]}"
-        context = opts[:context].append {
+      def request(name, data = {}, opts = {})
+        debug "create request #{name} with context #{opts[:context]}"
+        data = data.to_sfsobject(opts[:serialize_opts]) if data.is_a?(Hash)
+        req = Request.new(name, data)
+        if !opts[:context].blank? && opts[:context].is_a?(Processor)
+          debug "appending #{req} to processor #{opts[:context]}"
+          context = opts[:context].append {
+            @send_qm.synchronize { send_queue << req }
+          }
+        else
+          debug "adding #{req} to send_queue \n #{dump_state}"
+          context = req
           @send_qm.synchronize { send_queue << req }
-        }
-      else
-        debug "adding #{req} to send_queue \n #{dump_state}"
-        context = req
-        @send_qm.synchronize { send_queue << req }
+        end
+        ContextWorker.new(context, self)
       end
-      ContextWorker.new(context, self)
-    end
 
-    def expect(name, opts = {}, &block)
-      debug "Expecting to get response #{name} with context #{opts[:context]}"
-      unless opts[:context].blank?
-        if opts[:context].is_a?(Processor)
-          context = opts[:context].chain(name, &block)
-        elsif opts[:context].is_a?(Request)
-          context = Processor.new(name, :context => opts[:context], &block)
+      def expect(name, opts = {}, &block)
+        debug "Expecting to get response #{name} with context #{opts[:context]}"
+        unless opts[:context].blank?
+          if opts[:context].is_a?(Processor)
+            context = opts[:context].chain(name, &block)
+          elsif opts[:context].is_a?(Request)
+            context = Processor.new(name, :context => opts[:context], &block)
+            @mutex.synchronize { processors << context }
+          end
+        else
+          context = Processor.new(name, &block)
           @mutex.synchronize { processors << context }
         end
-      else
-        context = Processor.new(name, &block)
-        @mutex.synchronize { processors << context }
+        ContextWorker.new(context, self)
       end
-      ContextWorker.new(context, self)
-    end
 
-    def response(name, data = {})
-      info "Got response #{name} (#{data.to_json})..."
-      @mutex.synchronize { events_queue << Response.new(name, data) }
-    end
+      def response(name, data = {})
+        info "Got response #{name} (#{data.to_json})..."
+        @mutex.synchronize { events_queue << Response.new(name, data) }
+      end
 
-    def perform!
-      while !all_events_caught?
-        while !send_queue.blank?
-          req = nil
-          @send_qm.synchronize { req = send_queue.shift }
-          debug "sending request #{req.name}..."
-          smart_fox.send(req.to_extension_request) unless smart_fox.blank?
-          @last_act = Time.now.to_i
+      def perform!
+        while !all_events_caught?
+          while !send_queue.blank?
+            req = nil
+            @send_qm.synchronize { req = send_queue.shift }
+            debug "sending request #{req.name}..."
+            smart_fox.send(req.to_extension_request) unless smart_fox.blank?
+            @last_act = Time.now.to_i
+          end
+          process_events
+          check_timeouts
         end
-        process_events
-        check_timeouts
       end
-    end
 
-    def all_events_caught?
-      processors.blank? || processors.collect { |p| p.mandatory? }.blank?
-    end
+      def all_events_caught?
+        processors.blank? || processors.collect { |p| p.mandatory? }.blank?
+      end
 
-    def wait_all_events_caught
-      debug "Waiting all events being caught..."
-      begin
-        wait_with_timeout { all_events_caught? }
-      rescue WaitTimeoutException => e
-        raise "Failed to catch all the events:"+ dump_state
+      def wait_all_events_caught
+        debug "Waiting all events being caught..."
+        begin
+          wait_with_timeout { all_events_caught? }
+        rescue WaitTimeoutException => e
+          raise "Failed to catch all the events:"+ dump_state
+        end
       end
-    end
 
-    private
+      private
 
-    def dump_state
-      "events_queue = \n\t-#{events_queue.join("\n\t-")}" +
-          " \n processors = \n\t-#{processors.join("\n\t-")}" +
-          " \n send_queue = \n\t-#{send_queue.join("\n\t-")}"
-    end
+      def dump_state
+        "events_queue = \n\t-#{events_queue.join("\n\t-")}" +
+            " \n processors = \n\t-#{processors.join("\n\t-")}" +
+            " \n send_queue = \n\t-#{send_queue.join("\n\t-")}"
+      end
 
-    def check_timeouts
-      if !@last_act.blank? && Time.now.to_i > @last_act + opts[:timeout]
-        raise "Worker timeout! Latest interaction was #{Time.now.to_i - @last_act} sec ago!\n #{dump_state}"
+      def check_timeouts
+        if !@last_act.blank? && Time.now.to_i > @last_act + opts[:timeout]
+          raise "Worker timeout! Latest interaction was #{Time.now.to_i - @last_act} sec ago!\n #{dump_state}"
+        end
       end
-    end
 
-    def process_events
-      wait_with_timeout { !events_queue.blank? } rescue nil
-      ei = 0
-      debug "Processing events..."
-      while ei < events_queue.size
-        event = events_queue[ei]
-        pi = 0
-        debug "Processing event #{event.name}..."
-        while pi < processors.size
-          processor = processors[pi]
-          debug "Trying processor #{processor.name}..."
-          if processor.event(event.name, event.data)
-            @last_act = Time.now.to_i
-            debug "Processor found #{processor}"
-            @mutex.synchronize { events_queue.delete_at(ei) }
-            ei -= 1
-            if processor.completed?
-              debug "Processor completed #{processor.name}."
-              @mutex.synchronize { processors.delete_at(pi) }
-              pi -= 1
+      def process_events
+        wait_with_timeout { !events_queue.blank? } rescue nil
+        ei = 0
+        debug "Processing events..."
+        while ei < events_queue.size
+          event = events_queue[ei]
+          pi = 0
+          debug "Processing event #{event.name}..."
+          while pi < processors.size
+            processor = processors[pi]
+            debug "Trying processor #{processor.name}..."
+            if processor.event(event.name, event.data)
+              @last_act = Time.now.to_i
+              debug "Processor found #{processor}"
+              @mutex.synchronize { events_queue.delete_at(ei) }
+              ei -= 1
+              if processor.completed?
+                debug "Processor completed #{processor.name}."
+                @mutex.synchronize { processors.delete_at(pi) }
+                pi -= 1
+              end
             end
+            pi += 1
           end
-          pi += 1
+          ei += 1
         end
-        ei += 1
+        debug "Events processing finished. #{dump_state}"
       end
-      debug "Events processing finished. #{dump_state}"
-    end
 
-    def debug(msg)
-      puts "[#{time}] DEBUG #{msg}" if opts[:debug]
-    end
+      def debug(msg)
+        puts "[#{time}] DEBUG #{msg}" if opts[:debug]
+      end
 
-    def info(msg)
-      puts "[#{time}] INFO #{msg}"
-    end
+      def info(msg)
+        puts "[#{time}] INFO #{msg}"
+      end
 
-    def time
-      Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      def time
+        Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      end
     end
   end
-end
 
+end
 

data/lib/smartfox_jruby.rb

@@ -1,14 +1,15 @@
 require 'rubygems'
 require 'ostruct'
 require 'pathname'
-Dir[Pathname.new(File.dirname(File.expand_path(__FILE__))).join("#{File.basename(__FILE__)}").join("*.rb")].each { |f| require f }
 
 ####################################################
 # Main module
 module SmartfoxJruby
-  # configurable constants
-  VERSION = "0.2.1"
-
+  autoload :SfsRunner, 'smartfox_jruby/sfs_runner'
+  autoload :SfsAdapter, 'smartfox_jruby/sfs_adapter'
+  autoload :SfsWorker, 'smartfox_jruby/sfs_worker'
+  autoload :SFSUtil, 'smartfox_jruby/common'
+  VERSION = "0.2.2"
 
 end
 

metadata

@@ -2,14 +2,14 @@
 name: smartfox_jruby
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.2.1
+  version: 0.2.2
 platform: java
 authors:
 - Ilya Sadykov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-02-10 00:00:00.000000000 Z
+date: 2013-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -113,9 +113,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: !binary |-
         MA==
-      segments:
-      - 0
-      hash: 2
   none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: