smartfox_jruby 0.1

data/Gemfile

@@ -0,0 +1,9 @@
+source :rubygems
+gem 'jbundler', :git => 'https://github.com/mkristian/jbundler.git'
+
+gem 'activesupport', '~> 3.2.8'
+gem 'json'
+
+group :test do
+  gem 'rspec', '~> 2.10.0'
+end

data/Jarfile

@@ -0,0 +1,6 @@
+repository :first, "http://artifactory-innovations.i-free.ru/artifactory/ext-release-local"
+
+jar 'com.smartfox2x.client:sfs2x-client-core', '1.0.4'
+jar 'com.smartfox2x.client:sfs2x-api-java', '1.0.4'
+jar 'org.slf4j:slf4j-log4j12', '1.5.10'
+#jar 'net.sf.json-lib:json-lib:jar:jdk5:2.2.3'

data/lib/smartfox_jruby/common.rb

@@ -0,0 +1,152 @@
+require 'java'
+require 'active_support/all'
+java_import com.smartfoxserver.v2.entities.data.ISFSObject
+java_import com.smartfoxserver.v2.entities.data.SFSObject
+java_import com.smartfoxserver.v2.entities.data.SFSArray
+java_import java.util.Arrays
+java_import 'sfs2x.client.core.IEventListener'
+java_import 'sfs2x.client.core.SFSEvent'
+java_import 'sfs2x.client.SmartFox'
+java_import 'sfs2x.client.requests.LoginRequest'
+java_import 'sfs2x.client.requests.ExtensionRequest'
+
+module ISFSObject
+  def to_hash
+    HashWithIndifferentAccess.new(JSON.parse(to_json))
+  end
+
+  def to_s
+    to_json
+  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
+      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))
+      end
+      list
+    end
+  end
+end
+
+def SFSObject.from_hash(hash, opts = {})
+  res = SFSObject.new
+  opts ||= {}
+  hash.each_key do |key|
+    value = hash[key]
+    key = key.to_s
+    type = opts["#{key}_type".to_sym]
+    if value.is_a?(Hash)
+      res.putSFSObject(key, from_hash(value, opts[key.to_sym]))
+    elsif value.is_a?(Float)
+      if type == :double
+        res.putDouble(key, value.to_java(:double))
+      else
+        res.putFloat(key, value.to_java(:float))
+      end
+    elsif value.is_a?(Integer)
+      if type == :long
+        res.putLong(key, value.to_java(:long))
+      else
+        res.putInt(key, value.to_java(:int))
+      end
+    elsif value.is_a?(TrueClass) or value.is_a?(FalseClass)
+      res.putBool(key, value.to_java(:boolean))
+    elsif value.is_a?(String) or value.is_a?(Symbol)
+      res.putUtfString(key, value.to_java(:string))
+    elsif value.is_a?(Array)
+      unless value.empty?
+        if value[0].is_a?(Hash)
+          array = SFSArray.new
+          value.each { |hash|
+            array.addSFSObject(from_hash(hash, opts[key.to_sym]))
+          }
+          res.putSFSArray(key, array)
+        elsif value[0].is_a?(Float)
+          if type == :double
+            res.putDoubleArray(key, SmartfoxJruby::SFSUtil.to_java_list(value, :double))
+          else
+            res.putFloatArray(key, SmartfoxJruby::SFSUtil.to_java_list(value, :float))
+          end
+        elsif value[0].is_a?(Integer)
+          if type == :long
+            res.putLongArray(key, SmartfoxJruby::SFSUtil.to_java_list(value, :long))
+          else
+            res.putIntArray(key, SmartfoxJruby::SFSUtil.to_java_list(value, :int))
+          end
+        elsif value[0].is_a?(TrueClass) or value[0].is_a?(FalseClass)
+          res.putBoolArray(key, SmartfoxJruby::SFSUtil.to_java_list(value, :boolean))
+        elsif value[0].is_a?(String) or value[0].is_a?(Symbol)
+          res.putUtfStringArray(key, SmartfoxJruby::SFSUtil.to_java_list(value, :string))
+        end
+      end
+    end
+  end
+  res
+end
+
+class Hash
+  include ISFSObject
+
+  def to_sfsobject(opts = {})
+    SFSObject.from_hash(self, opts)
+  end
+
+  def method_missing(m, *args)
+    sfs_object = SFSObject.from_hash(self)
+    if sfs_object.respond_to?(m)
+      sfs_object.send(m, *args)
+    else
+      super
+    end
+  end
+end
+
+module Kernel
+  class WaitTimeoutException < Exception
+  end
+
+  def wait_with_timeout(timeout = 20, opts = {:sleep_time => 0.1})
+    timeout ||= 20
+    raise "Block is required!" unless block_given?
+    time = Time.now.to_i
+    finished = false
+    while (Time.now.to_i < time + timeout) && !finished
+      sleep opts[:sleep_time] || 0.01 # sleep for 10 ms to wait the response
+      finished = yield
+    end
+    raise WaitTimeoutException.new("Timeout while waiting!") unless finished
+  end
+end
+
+module Process
+  def self.alive?(pid)
+    return false unless pid
+    begin
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+  end
+end

data/lib/smartfox_jruby/sfs_adapter.rb

@@ -0,0 +1,172 @@
+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[: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
+  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})"
+    end
+  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?
+    end
+    worker.perform!
+  end
+
+  def connected?
+    @connected
+  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 login_as(username, password, params = {})
+    params = input_params.to_sfsobject if params.is_a?(Hash)
+    @login_as ||= {:username => username, :password => password, :params => params}
+  end
+
+  private
+
+  ###############
+  ### HELPERS ###
+
+  def request(*args)
+    worker.request(*args)
+  end
+
+  def worker(opts = {})
+    @worker ||= SfsWorker::Worker.new(@smart_fox, opts)
+    @worker
+  end
+
+  def sfs_send(req)
+    smart_fox.send(req)
+  end
+
+  #########################
+  ### 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_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]}'"
+    end
+  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_handshake_event(event)
+    # nothing to do
+  end
+
+
+  #######################
+  ### SERVICE HELPERS ###
+
+  def logger
+    opts[:logger]
+  end
+
+  def debug_enabled?
+    opts[:debug] || DEBUG
+  end
+
+  def debug(msg)
+    logger.debug "#{msg}" if debug_enabled?
+  end
+
+  def info(msg)
+    logger.info "#{msg}"
+  end
+
+  def log(msg)
+    logger.info "#{msg}"
+  end
+
+  def error(msg)
+    logger.error "#{msg}"
+  end
+
+
+end
+

data/lib/smartfox_jruby/sfs_runner.rb

@@ -0,0 +1,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
+
+  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
+      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 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 running?
+    !pids.blank? && pids.map { |pid| Process.alive?(pid.to_i) }.include?(true)
+  end
+
+  def launched?
+    @launched
+  end
+
+  def fault?
+    @fault
+  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
+
+  private
+
+  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 debug(msg)
+    @opts[:logger].debug(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 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 java_bin
+    Pathname.new(System.getProperty("java.home")).join("bin").join("java")
+  end
+
+  def java_opts
+    %Q[-XX:MaxPermSize=512m -Xms128m -Xms1024m]
+  end
+
+  def classpath
+    %Q[aimy:./:lib/*:lib/Jetty/*:extensions/__lib__/*]
+  end
+
+end
+

data/lib/smartfox_jruby/sfs_worker.rb

@@ -0,0 +1,256 @@
+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
+
+    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 append(&block)
+      unless link.blank?
+        link.blocks << block
+      else
+        current.blocks << block
+      end
+      self
+    end
+
+    def completed?
+      current.blank?
+    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
+      end
+      false
+    end
+
+    def to_s
+      "Proc[#{current.try(:name)}] --> #{current.try(:chained)}"
+    end
+  end
+
+  class Request
+    attr_reader :name
+    attr_reader :data
+
+    def initialize(name, data = {})
+      @name = name
+      @data = data
+    end
+
+    def to_extension_request
+      ExtensionRequest.new(@name.to_s, @data)
+    end
+
+    def to_s
+      "Req[#{@name}]#{data.to_json}"
+    end
+  end
+
+  class Response < Request
+    def to_s
+      "Resp[#{@name}]#{data.to_json}"
+    end
+  end
+
+  class ContextWorker
+
+    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 expect(name, opts={}, &block)
+      @worker.expect(name, opts.merge(:context => @context), &block)
+    end
+
+    def initialize(context, worker)
+      @context = context
+      @worker = worker
+    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
+
+    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
+
+    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 }
+      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)
+          @mutex.synchronize { processors << context }
+        end
+      else
+        context = Processor.new(name, &block)
+        @mutex.synchronize { processors << context }
+      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 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
+    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
+      end
+    end
+
+    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 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
+
+    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
+        ei += 1
+      end
+      debug "Events processing finished. #{dump_state}"
+    end
+
+    def debug(msg)
+      puts "[#{time}] DEBUG #{msg}" if opts[:debug]
+    end
+
+    def info(msg)
+      puts "[#{time}] INFO #{msg}"
+    end
+
+    def time
+      Time.now.strftime("%Y-%m-%d %H:%M:%S")
+    end
+  end
+end
+
+

data/lib/smartfox_jruby.rb

@@ -0,0 +1,14 @@
+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.1"
+
+
+end
+

data/smartfox_jruby.gemspec

@@ -0,0 +1,25 @@
+require 'pathname'
+require Pathname.new(File.dirname(File.expand_path(__FILE__))).join('lib/smartfox_jruby.rb')
+
+Gem::Specification.new do |s|
+  s.name = 'smartfox_jruby'
+  s.version = SmartfoxJruby::VERSION
+  s.date = '2013-02-08'
+  s.authors = ["Ilya Sadykov"]
+  s.email = 'i.sadykov@gmail.com'
+  s.homepage = ""
+  s.summary = %q{Smartfox client for jruby}
+  s.description = %q{Allows to connect and easily process messages from and to SmartFox game server}
+
+  s.add_development_dependency 'rspec', '~> 2.10.0'
+  s.add_runtime_dependency 'activesupport', '~> 3.2.8'
+  s.add_runtime_dependency 'json'
+  s.add_runtime_dependency "jar 'org.slf4j:slf4j-api:1.5.10'"
+  s.add_runtime_dependency "jar 'com.smartfox2x.client:sfs2x-client-core:1.0.4'"
+  s.add_runtime_dependency "jar 'com.smartfox2x.client:sfs2x-api-java:1.0.4'"
+
+  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 = %w(lib)
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification 
+name: smartfox_jruby
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: "0.1"
+platform: ruby
+authors: 
+  - Ilya Sadykov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-02-08 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ~>
+          - !ruby/object:Gem::Version 
+            version: 2.10.0
+    type: :development
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: activesupport
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ~>
+          - !ruby/object:Gem::Version 
+            version: 3.2.8
+    type: :runtime
+    version_requirements: *id002
+  - !ruby/object:Gem::Dependency 
+    name: json
+    prerelease: false
+    requirement: &id003 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id003
+  - !ruby/object:Gem::Dependency 
+    name: jar 'org.slf4j:slf4j-api:1.5.10'
+    prerelease: false
+    requirement: &id004 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id004
+  - !ruby/object:Gem::Dependency 
+    name: jar 'com.smartfox2x.client:sfs2x-client-core:1.0.4'
+    prerelease: false
+    requirement: &id005 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id005
+  - !ruby/object:Gem::Dependency 
+    name: jar 'com.smartfox2x.client:sfs2x-api-java:1.0.4'
+    prerelease: false
+    requirement: &id006 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id006
+description: Allows to connect and easily process messages from and to SmartFox game server
+email: i.sadykov@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - Gemfile
+  - Jarfile
+  - lib/smartfox_jruby.rb
+  - lib/smartfox_jruby/common.rb
+  - lib/smartfox_jruby/sfs_adapter.rb
+  - lib/smartfox_jruby/sfs_runner.rb
+  - lib/smartfox_jruby/sfs_worker.rb
+  - smartfox_jruby.gemspec
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Smartfox client for jruby
+test_files: []
+