internet_scrabble_club 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA1: 
-  metadata.gz: dcfdf5998716687a13e1783db2b02bfce70d52df
-  data.tar.gz: 778e23b7e995aaa4828c6a76ab2578bcced7d7b2
+  metadata.gz: dfbc285681699ddf19091435e5a89d134670f332
+  data.tar.gz: 249f4e0d5f7681ec4fb2bfa42c7585f411ab09e7
 SHA512: 
-  metadata.gz: 63b67073d577c4d9ab3b4df1409674f3f0fdbb8000579d16c3fd2caf545aa11699224c608310921ba90d4bc4f5613ce847b6df5571e21660fff917ecede1ee3f
-  data.tar.gz: 6917a3c52eca3a6eb058ea7a301c1b871f0c6bc8fc96c023862d1b41df9440705ae1a5c3bb7cfcda19781c7bcc8101637702e3b347c8a01bfced349bbacad600
+  metadata.gz: 4f5829c3508db7f815e57fb9630b964d773dca34a51822c90d4db67ca97cdd0bc1a37e3841f681e65647df3f8e773af62fde9cca3797fd2286a199a70d367bd6
+  data.tar.gz: 13ac5b2ef5ff307b5045c73a2ab319b8247a447d0e27a77e5375b057fe66a98c575a2c02164ee24a3efd17902fe6c61719c59d2d90457724393dd522d96f7f1c

data/.gitignore

@@ -3,6 +3,7 @@
 .bundle
 .config
 .yardoc
+.Rhistory
 Gemfile.lock
 InstalledFiles
 _yardoc
@@ -15,3 +16,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+data/

data/.ruby-version

@@ -1 +1 @@
-rbx-2.2.6
+rbx-2.2.10

data/Rakefile

@@ -1 +1 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'

data/bin/scraper.rb

@@ -0,0 +1,12 @@
+# TODO: Move to rake task
+
+require 'internet_scrabble_club/scraper/players'
+require 'internet_scrabble_club/scraper/games'
+
+Celluloid.shutdown_timeout = 2 * 60
+
+InternetScrabbleClub::Scraper::Players.new('iscscraper', 'da39a3ee5e')
+# InternetScrabbleClub::Scraper::Games.new('iscscraper', 'da39a3ee5e')
+
+# TODO: Use supervisor group
+sleep

data/bin/spectator.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+require 'pp'
+
+require 'celluloid'
+require 'internet_scrabble_club/client'
+
+Celluloid.logger.level = Logger::INFO
+
+class Spectator
+  include Celluloid
+  include InternetScrabbleClub::Entities
+
+  def initialize(nickname, password)
+    @client = InternetScrabbleClub::Client.new
+    @client.authenticate(nickname, password)
+    @client.on_message { |message| handle_message(message) }
+  end
+
+  def handle_message(message)
+    puts message.inspect
+    # case message.command
+    # when /(UN)?SEEK/
+    #   10.times { |i| @client.send_message('EXAMINE', 'HISTORY', message.nickname, i) }
+    # when /EXAMINE/
+    #   game_attributes = construct_game_from_message(message)
+    #   persist_game(game_attributes)
+    # end
+  end
+
+  # private
+
+  # def persist_game(game_attributes)
+  #   game = Game.create!(game_attributes)
+  #   report_game_created(game)
+  # end
+
+  # def report_game_created(game)
+  #   puts "(#{game.id}), at #{game.date}, by #{game.players.map(&:nickname).join(' & ')}, #{game.plays.count} plays in total."
+  # end
+
+  # def construct_game_from_message(message)
+  #   players = collect_from_setup(message) do |setup|
+  #     nickname, rating = setup.values_at(:nickname, :rating)
+  #     player = Player.new(nickname: nickname, rating: rating)
+  #   end
+
+  #   initial_racks = collect_from_setup(message) { |setup| setup.fetch(:initial_rack) }
+  #   final_scores = collect_from_setup(message) { |setup| setup.fetch(:final_score) }
+
+  #   create_play_object = ->(play_attributes) {
+  #     case play_attributes.delete(:type)
+  #     when 'MOVE' then Plays::Move.new(play_attributes)
+  #     when 'CHANGE' then Plays::Change.new(play_attributes)
+  #     when 'PAS' then Plays::Pass.new(play_attributes)
+  #     end
+  #   }
+
+  #   first_player_plays = message.first_player.plays.map do |play|
+  #     create_play_object.call(play.to_h.merge(player: players[0]))
+  #   end
+
+  #   second_player_plays = message.second_player.plays.map do |play|
+  #     create_play_object.call(play.to_h.merge(player: players[1]))
+  #   end
+
+  #   plays = first_player_plays.zip(second_player_plays)
+  #     .flatten(1).compact.each_with_index.map { |play, index| play.index = index; play }
+
+  #   { date: message.date,
+  #     dictionary_code: message.dictionary_code,
+  #     initial_racks: initial_racks,
+  #     final_scores: final_scores,
+  #     plays: plays,
+  #     players: players
+  #   }
+  # end
+
+  # def collect_from_setup(message)
+  #   [:first, :second].collect { |prefix| yield(message.send(:"#{prefix}_player").setup) }
+  # end
+end
+
+
+if ARGV.length < 2
+  fail "Please provide nickname and password: bin/spectator <nickname> <password>"
+end
+
+Spectator.new(ARGV[0], ARGV[1])
+
+sleep

data/internet_scrabble_club.gemspec

@@ -1,7 +1,6 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'internet_scrabble_club'
+# encoding: utf-8
+
+require File.expand_path('../lib/internet_scrabble_club', __FILE__)
 
 Gem::Specification.new do |spec|
   spec.name          = 'internet_scrabble_club'

data/lib/internet_scrabble_club.rb

@@ -1,3 +1,3 @@
 module InternetScrabbleClub
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/lib/internet_scrabble_club/client.rb

@@ -6,72 +6,76 @@ require 'celluloid/autostart'
 require 'events'
 require 'middleware'
 
-require_relative 'multi_queue'
-
-require_relative 'client/extensions/authentication'
-require_relative 'client/extensions/echo_ping'
-require_relative 'client/extensions/keep_alive'
-
-require_relative 'client/middleware'
+require_relative './client/callback_queue'
+require_relative './client/middleware'
 
 module InternetScrabbleClub
 
   class Client
     include Celluloid::IO
 
-    prepend Extensions::Authentication
-    prepend Extensions::EchoPing
-    prepend Extensions::KeepAlive
-
     finalizer :finalize
 
     attr_writer :socket, :middleware
     attr_writer :command_callback_queue, :event_emitter
 
+    DEFAULT_HOST = '50.97.175.138'
+    DEFAULT_PORT = 1330
+
     class InvalidCredentials < StandardError
       def initialize(message = nil)
         super(message || "Could not authenticate; the provided credentials are invalid.")
       end
     end
 
-    def initialize(host = '50.97.175.138', port = 1330)
+    def initialize(host = DEFAULT_HOST, port = DEFAULT_PORT)
       @socket = TCPSocket.new(host, port)
-      @command_callback_queue = MultiQueue.new
+      @command_callback_queue = Client::CallbackQueue.new
+
       @event_emitter = Events::EventEmitter.new
-      @event_emitter.on(:message) { |message| yield_command_callback(message) }
+      @event_emitter.on(:response) { |response| yield_command_callback(response) }
+
+      Celluloid.every(50) { send_request('SEEK') }
 
       async.run
     end
 
     def run
-      loop { middleware.call({}) }
+      loop { middleware_stack.call({}) }
+    end
+
+    def authenticate(nickname, password, &callback)
+      send_request('LOGIN', nickname, password, 1871, '?', &callback)
     end
 
-    def on_message(&callback)
-      @event_emitter.on(:message, &callback)
+    def on_response(command_regex = /.*/, &callback)
+      @event_emitter.on(:response) do |response|
+        callback.call(response) if response[:command] =~ command_regex
+      end
     end
 
-    def send_message(command, *arguments, &callback)
-      message = ['0', command, *arguments].join(' ')
-      @command_callback_queue.enqueue(command.downcase.to_sym, callback)
-      @socket.write("\0" << message.length << message)
+    def send_request(command, *arguments, &callback)
+      request = ['0', command, *arguments].join(' ')
+      @command_callback_queue.enqueue(command, callback)
+      @socket.write("\0" << request.length << request)
     end
 
     def finalize
       @socket.close if @socket
     end
 
-    private def yield_command_callback(message)
-      command_callback = @command_callback_queue.dequeue(message.command) { proc {} }
-      command_callback.call(message)
+    private def yield_command_callback(response)
+      command_callback = @command_callback_queue.dequeue(response[:command]) { proc {} }
+      command_callback.call(response)
     end
 
-    private def middleware
-      @middleware ||= ::Middleware::Builder.new.tap { |mw|
-        mw.use(Middleware::Read, @socket)
-        mw.use(Middleware::Parse)
-        mw.use(Middleware::Transform)
-        mw.use(Middleware::Emit, @event_emitter)
+    private def middleware_stack
+      @middleware_stack ||= ::Middleware::Builder.new.tap { |mw|
+        mw.use(Middleware::Response::Read, @socket)
+        mw.use(Middleware::Response::Parse)
+        mw.use(Middleware::Response::Transform)
+        mw.use(Middleware::Response::Emit, @event_emitter)
+        mw.use(Middleware::Request::EchoPing, self)
       }
     end
   end

data/lib/internet_scrabble_club/client/callback_queue.rb

@@ -0,0 +1,22 @@
+module InternetScrabbleClub
+  class Client
+
+    class CallbackQueue
+      def initialize
+        @queues = Hash.new { Array.new }
+      end
+
+      def enqueue(command, callback)
+        @queues[command] += [callback]
+      end
+
+      def dequeue(command, default = nil)
+        return @queues[command].shift if @queues[command].any?
+        return yield(command) if block_given?
+        return default unless default.nil?
+        fail ArgumentError, "Missing callback handler for command #{command}"
+      end
+    end
+
+  end
+end

data/lib/internet_scrabble_club/client/middleware.rb

@@ -1,4 +1,7 @@
-require_relative 'middleware/emit'
-require_relative 'middleware/parse'
-require_relative 'middleware/read'
-require_relative 'middleware/transform'
+require_relative 'middleware/request/echo_ping'
+require_relative 'middleware/request/keep_alive'
+
+require_relative 'middleware/response/emit'
+require_relative 'middleware/response/parse'
+require_relative 'middleware/response/read'
+require_relative 'middleware/response/transform'

data/lib/internet_scrabble_club/client/middleware/request/echo_ping.rb

@@ -0,0 +1,23 @@
+module InternetScrabbleClub
+  class Client
+    module Middleware
+      module Request
+
+        class EchoPing
+          def initialize(stack, client)
+            @stack, @client = stack, client
+          end
+
+          def call(env)
+            if env.fetch(:response).values_at(:command, :sub_command) == %w(PING REPLY)
+              @client.send_request('PING', 'REPLY')
+            end
+
+            @stack.call(env)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/internet_scrabble_club/client/middleware/request/keep_alive.rb

@@ -0,0 +1,31 @@
+require 'celluloid'
+require 'celluloid/logger'
+
+module InternetScrabbleClub
+  class Client
+    module Middleware
+      module Request
+
+        class KeepAlive
+          def initialize(stack, client)
+            @stack, @client = stack, client
+            Celluloid.every(50) { keep_alive; log_keep_alive }
+          end
+
+          def keep_alive
+            @client.send_request('SEEK')
+          end
+
+          private def log_keep_alive
+            Celluloid::Logger.info("Sent keep alive command!")
+          end
+
+          def call(env)
+            @stack.call(env)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/internet_scrabble_club/client/middleware/response/emit.rb

@@ -0,0 +1,20 @@
+module InternetScrabbleClub
+  class Client
+    module Middleware
+      module Response
+
+        class Emit
+          def initialize(stack, event_emitter)
+            @stack, @event_emitter = stack, event_emitter
+          end
+
+          def call(env)
+            @event_emitter.emit(:response, env[:response])
+            @stack.call(env)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/internet_scrabble_club/client/middleware/response/parse.rb

@@ -0,0 +1,26 @@
+require 'parslet'
+require 'celluloid/logger'
+require_relative '../../response_parsers'
+
+module InternetScrabbleClub
+  class Client
+    module Middleware
+      module Response
+
+        class Parse
+          def initialize(stack, response_parser = ResponseParsers::Base.new)
+            @stack, @response_parser = stack, response_parser
+          end
+
+          def call(env)
+            env[:response] = @response_parser.parse(env[:response])
+            @stack.call(env)
+          rescue Parslet::ParseFailed
+            Celluloid::Logger.warn("Failed to parse response: #{env[:response]}")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/internet_scrabble_club/client/middleware/response/read.rb

@@ -0,0 +1,21 @@
+module InternetScrabbleClub
+  class Client
+    module Middleware
+      module Response
+
+        class Read
+          def initialize(stack, socket)
+            @stack, @socket = stack, socket
+          end
+
+          def call(env)
+            response_length = @socket.getc.ord * 256 + @socket.getc.ord
+            env[:response] = @socket.read(response_length)
+            @stack.call(env)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/internet_scrabble_club/client/middleware/response/transform.rb

@@ -0,0 +1,22 @@
+require_relative '../../response_transformers'
+
+module InternetScrabbleClub
+  class Client
+    module Middleware
+      module Response
+
+        class Transform
+          def initialize(stack, response_transformer = ResponseTransformers::Base.new)
+            @stack, @response_transformer = stack, response_transformer
+          end
+
+          def call(env)
+            env[:response] = @response_transformer.apply(env[:response])
+            @stack.call(env)
+          end
+        end
+
+      end
+    end
+  end
+end