mail_chess 0.1.0

data/README

@@ -0,0 +1,3 @@
+= Mail Chess
+
+This is an early version, not a final one, don't README (yet ;)).

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'rake/testtask'
+
+task :default => [:test]
+
+desc "Run tests"
+Rake::TestTask.new 'test' do |t|
+  t.pattern = 'test/*_test.rb'
+
+  t.verbose = false
+  t.warning = false
+end

data/lib/mail_chess/board.rb

@@ -0,0 +1,222 @@
+# encoding: utf-8
+
+require 'mail_chess'
+require 'sequel'
+
+module MailChess
+  # Columns of a chessboard
+  COLS = %w[a b c d e f g h]
+
+  # Rows of a chessboard
+  ROWS = %w[8 7 6 5 4 3 2 1]
+
+  # Represents a chessboard.
+  class Board
+    # Board ID in database.
+    attr_reader :id
+
+    # Board itself.
+    attr_accessor :board
+
+    # Pieces on this board.
+    attr_accessor :pieces
+
+    # Create a new Board object.
+    #
+    # Arguments:
+    #   db: Sequel database object
+    #   board_id: (Integer)
+    def initialize db, board_id
+      @db = db
+
+      Board.create_tables(@db) if Board.need_to_create_tables?(@db)
+
+      @db_entry = @db[:boards].filter(:id => board_id).first
+
+      @id = @db_entry[:id].to_i
+      @pieces = {}
+      @db[:pieces].filter(:board_id => @id).all.each do |p|
+        Piece::Piece.load! db, p[:id], self
+      end
+    end
+
+    # Checks if needed to create tables.
+    #
+    # Returns: (Boolean)
+    def self.need_to_create_tables? db
+      return (db.tables + [:boards, :pieces]).uniq.size != db.tables.size
+    end
+
+    # Create tables.
+    def self.create_tables db
+      db.create_table? :boards do
+        primary_key :id
+      end
+
+      db.create_table? :pieces do
+        primary_key :id
+        String :type
+        String :color
+        String :position
+        foreign_key :board_id, :boards, :key => :id
+      end
+    end
+
+    # Create new board object and save it to database.
+    #
+    # Arguments:
+    #   db: Sequel database object
+    #
+    # Returns: (Board)
+    def self.new! db
+      Board.create_tables(db) if Board.need_to_create_tables?(db)
+
+      id = db[:boards].insert
+
+      return Board.new db, id
+    end
+
+    # Load game from database.
+    #
+    # Arguments:
+    #   db: Sequel database object
+    #   filter: (Symbol) :id only (for now)
+    #   value: filters value
+    #
+    # Returns: (Board)
+    def self.load! db, filter, value
+      raise ArgumentError unless [:id, :reference].index(filter)
+      dataset = db[:games].filter(filter => value)
+      raise ArgumentError unless dataset.all.size == 1
+
+      id = dataset.first[:id]
+
+      b = Board.new db, id
+
+      return b
+    end
+
+    # Save game -- save the pieces.
+    def save!
+      pieces.values.each do |p|
+        p.save!
+      end
+    end
+    
+    # Delete game -- +save!+ won't fix it!
+    def delete!
+      pieces.values.each do |p|
+        p.delete!
+      end
+      
+      # board deleted in Game class
+    end
+
+    # Add a new piece to board.
+    #
+    # Arguments:
+    #   field: (String)
+    #   piece: (Piece)
+    #
+    # Returns: (Piece)
+    def add field, piece
+      @pieces[field] = piece
+
+      return piece
+    end
+
+    # Removes a piece from board.
+    #
+    # Arguments:
+    #   field: (String)
+    #
+    # Returns: (Piece)
+    def remove field
+      piece = @pieces[field]
+      @pieces.delete(field)
+
+      return piece
+    end
+
+    # Place the start position of pieces.
+    def start!
+      COLS.each do |c|
+        Piece::Pawn.new!(@db, self, c + '2', :white)
+        Piece::Pawn.new!(@db, self, c + '7', :black)
+      end
+
+      %w[a h].each do |c|
+        Piece::Rook.new!(@db, self, c + '1', :white)
+        Piece::Rook.new!(@db, self, c + '8', :black)
+      end
+
+      %w[b g].each do |c|
+        Piece::Knight.new!(@db, self, c + '1', :white)
+        Piece::Knight.new!(@db, self, c + '8', :black)
+      end
+
+      %w[c f].each do |c|
+        Piece::Bishop.new!(@db, self, c + '1', :white)
+        Piece::Bishop.new!(@db, self, c + '8', :black)
+      end
+
+      Piece::Queen.new!(@db, self, 'd1', :white)
+      Piece::Queen.new!(@db, self, 'd8', :black)
+
+      Piece::King.new!(@db, self, 'e1', :white)
+      Piece::King.new!(@db, self, 'e8', :black)
+    end
+
+    # Generate HTML output.
+    #
+    # Attributes:
+    #    player: (Symbol) which view
+    #
+    # Returns: (String)
+    def to_html player = :white
+      result = '<table border="0" cellpadding="0" cellspacing="0">'
+      result << '<tr height="40"><td align="center" width="40"></td>'
+
+      cols = (player == :white ? COLS : COLS.reverse)
+      cols.each do |c|
+        result << '<td align="center" width="40"><b>'
+        result << c.capitalize + '</b></td>'
+      end
+      result << '<td align="center" width="40"></td></tr>'
+
+      rows = (player == :white ? ROWS : ROWS.reverse)
+      start_color = :white
+
+      rows.each do |r|
+        result << '<tr height="40"><td align="center"><b>' + r + '</b></td>'
+        cell_color = start_color
+        cols.each do |c|
+          result << '<td align="center" bgcolor="'
+          result << (cell_color == :white ? '#ffffff' : '#d0d0d0')
+          result << '">'
+          
+          if @pieces[c + r]
+            result << '<font size="6">'
+            result << @pieces[c + r].html
+            result << '</font>'
+          end
+          result << '</td>'
+          cell_color = (cell_color == :white ? :black : :white)
+        end
+        result << '<td align="center"><b>' + r + '</b></td></tr>'
+        start_color = (start_color == :white ? :black : :white)
+      end
+
+      result << '<tr height="40"><td align="center" width="40"></td>'
+      cols.each do |c|
+        result << '<td align="center" width="40"><b>'
+        result << c.capitalize + '</b></td>'
+      end
+      result << '<td align="center" width="40"></td></tr>'
+
+      result << '</table>'
+
+      return result
+    end
+  end
+end

data/lib/mail_chess/game.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+require 'mail_chess'
+require 'sequel'
+
+module MailChess
+  # Represents a chess game.
+  class Game
+    # Game ID in database.
+    attr_reader :id
+
+    # Game reference.
+    attr_reader :reference
+
+    # Board belongs to this game.
+    attr_reader :board
+
+    # Players hash. (keys: :white, :black)
+    attr_reader :players
+
+    # Current player's color.
+    attr_accessor :current
+
+    # Create a new Game object.
+    #
+    # Arguments:
+    #   db: Sequel database object
+    #   game_id: (Integer)
+    def initialize db, game_id
+      @db = db
+
+      Game.create_tables(@db) if Game.need_to_create_tables?(@db)
+
+      @db_entry = @db[:games].filter(:id => game_id).first
+
+      @id = @db_entry[:id].to_i
+      @reference = @db_entry[:reference]
+      @current = @db_entry[:current].to_sym
+      @board = Board.load! @db, :id, @db_entry[:board_id]
+
+      @players = Hash.new
+      @db[:pairs].filter(:game_id => @id).all.each do |p|
+        @players[p[:color].to_sym] = Player.load!(@db, :id, p[:player_id].to_i)
+      end
+
+    end
+
+    # Checks if needed to create tables.
+    #
+    # Returns: (Boolean)
+    def self.need_to_create_tables? db
+      return (db.tables + [:boards, :games, :players, 
+                           :pairs]).uniq.size != db.tables.size
+    end
+
+    # Create tables.
+    def self.create_tables db
+      db.create_table? :boards do
+        primary_key :id
+      end
+
+      db.create_table? :games do
+        primary_key :id
+        String :reference
+        String :current
+        foreign_key :board_id, :boards, :key => :id
+      end
+
+      db.create_table? :players do
+        primary_key :id
+        String :name
+        String :email
+      end
+
+      db.create_table? :pairs do
+        primary_key :id
+        foreign_key :player_id, :players, :key => :id
+        foreign_key :game_id, :games, :key => :id
+        String :color
+      end
+    end
+
+    # Create a new game object and save it to database.
+    #
+    # Arguments:
+    #   db: Sequel database object
+    #   white: (Player) first player
+    #   black: (Player) second player
+    #   reference: (String)
+    #
+    # Returns: (Game)
+    def self.new! db, white, black, reference
+      Game.create_tables(db) if Game.need_to_create_tables?(db)
+
+      b = Board.new! db
+      id = db[:games].insert(:reference => reference,
+                             :current => 'white',
+                             :board_id => b.id)
+      db[:pairs].insert(:player_id => white.id,
+                        :game_id => id,
+                        :color => 'white')
+      db[:pairs].insert(:player_id => black.id,
+                        :game_id => id,
+                        :color => 'black')
+
+      return Game.new db, id
+    end
+    
+    # Load game from database.
+    #
+    # Arguments:
+    #   db: Sequel database object
+    #   filter: (Symbol) :id or :reference
+    #   value: filters value
+    #
+    # Returns: (Game)
+    def self.load! db, filter, value
+      raise ArgumentError unless [:id, :reference].index(filter)
+      dataset = db[:games].filter(filter => value)
+      return nil unless dataset.all.size == 1
+      id = dataset.first[:id]
+
+      return Game.new db, id
+    end
+
+    # Save game -- update the +current+ field.
+    def save!
+      @db[:games].filter(:id => @id).update(:current => current.to_s)
+    end
+
+    # Delete game -- +save!+ won't fix it!
+    def delete!
+      @board.delete!
+      @db[:pairs].filter(:game_id => @id).delete
+      @db[:games].filter(:id => @id).delete
+      @db[:boards].filter(:id => @board.id).delete
+    end
+  end
+end

data/lib/mail_chess/pieces/base.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+require 'mail_chess'
+require 'sequel'
+
+module MailChess
+  module Piece
+    # Represents a chesspiece.
+    class Piece
+      # Piece ID in database.
+      attr_reader :id
+      
+      # Piece type.
+      attr_reader :type
+      
+      # Piece color.
+      attr_reader :color
+      
+      # Board where this piece standing.
+      attr_reader :board
+
+      # HTML tag of this piece.
+      attr_reader :html
+      
+      # Create a new Piece object.
+      #
+      # Arguments:
+      #   db: Sequel database object
+      #   piece_id: (Integer)
+      def initialize db, piece_id, board
+        @db = db
+        
+        Piece.create_tables(@db) if Piece.need_to_create_tables?(@db)
+    
+        @db_entry = @db[:pieces].filter(:id => piece_id).first
+        
+        @id = @db_entry[:id].to_i
+        @type = @db_entry[:type]
+        @color = @db_entry[:color].to_sym
+        @board = board
+        @board.add @db_entry[:position], self
+      end
+
+      # Checks if needed to create tables.
+      #
+      # Returns: (Boolean)
+      def self.need_to_create_tables? db
+        return (db.tables + [:boards, :pieces]).uniq.size != db.tables.size
+      end
+      
+      # Create tables.
+      def self.create_tables db
+        db.create_table? :boards do
+          primary_key :id
+        end
+        
+        db.create_table? :pieces do
+          primary_key :id
+          String :type
+          String :color
+          String :position
+          foreign_key :board_id, :boards, :key => :id
+        end
+      end
+
+      # Find out the position of this piece.
+      #
+      # Returns: (String)
+      def position
+        return @board.pieces.key(self)
+      end
+
+      # ABSTRACT Create a new piece and add to a table.
+      #
+      # Arguments:
+      #   db: Sequel database object
+      #   board: (Board)
+      #   position: (String) eg.: 'f3'
+      #   color: (Symbol) :white or :black
+      #
+      # Returns: (Piece)
+      def self.new! db, board, position, color
+        Piece.create_tables(db) if Piece.need_to_create_tables?(db)
+      end
+      
+      # Load the pieces to a board.
+      #
+      # Arguments:
+      #   db: Sequel database object
+      #   board: (Board)
+      #
+      # Returns: (Piece)
+      def self.load! db, piece_id, board
+        p = db[:pieces].filter(:id => piece_id).first
+        color = p[:color].to_sym
+        position = p[:position]
+        case p[:type]
+          when 'bishop' then Bishop.new(db, piece_id, board)
+          when 'king' then King.new(db, piece_id, board)
+          when 'knight' then Knight.new(db, piece_id, board)
+          when 'pawn' then Pawn.new(db, piece_id, board)
+          when 'rook' then Rook.new(db, piece_id, board)
+          when 'queen' then Queen.new(db, piece_id, board)
+        end
+      end
+      
+      # Save piece -- position.
+      def save!
+        @db[:pieces].filter(:id => @id).update(:position => position)
+      end
+      
+      # Delete piece -- +save!+ won't fix it!
+      def delete!
+        @db[:pieces].filter(:id => @id).delete
+      end
+    end
+  end
+end

data/lib/mail_chess/pieces/bishop.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'mail_chess'
+require 'sequel'
+
+module MailChess
+  module Piece
+    # Represents a bishop chess piece.
+    class Bishop < Piece
+      # Calls the superclass.
+      def initialize db, piece_id, board = nil
+        super db, piece_id, board
+        
+        @html = @color == :white ? '&#9815;' : '&#9821;'
+      end
+
+      # Overwrite superclass method.
+      def self.new! db, board, position, color
+        super db, board, position, color
+
+        id = db[:pieces].insert(:type => 'bishop', 
+                                :color => color.to_s,
+                                :position => position,
+                                :board_id => board.id)
+
+        return Bishop.new db, id, board
+      end
+    end
+  end
+end

data/lib/mail_chess/pieces/king.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'mail_chess'
+require 'sequel'
+
+module MailChess
+  module Piece
+    # Represents a king chess piece.
+    class King < Piece
+      # Calls the superclass.
+      def initialize db, piece_id, board = nil
+        super db, piece_id, board
+        
+        @html = @color == :white ? '&#9812;' : '&#9818;'
+      end
+
+      # Overwrite superclass method.
+      def self.new! db, board, position, color
+        super db, board, position, color
+
+        id = db[:pieces].insert(:type => 'king', 
+                                :color => color.to_s,
+                                :position => position,
+                                :board_id => board.id)
+
+        return King.new db, id, board
+      end
+    end
+  end
+end

data/lib/mail_chess/pieces/knight.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'mail_chess'
+require 'sequel'
+
+module MailChess
+  module Piece
+    # Represents a knight chess piece.
+    class Knight < Piece
+      # Calls the superclass.
+      def initialize db, piece_id, board = nil
+        super db, piece_id, board
+        
+        @html = @color == :white ? '&#9816;' : '&#9822;'
+      end
+
+      # Overwrite superclass method.
+      def self.new! db, board, position, color
+        super db, board, position, color
+
+        id = db[:pieces].insert(:type => 'knight', 
+                                :color => color.to_s,
+                                :position => position,
+                                :board_id => board.id)
+
+        return Knight.new db, id, board
+      end
+    end
+  end
+end
+

data/lib/mail_chess/pieces/pawn.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'mail_chess'
+require 'sequel'
+
+module MailChess
+  module Piece
+    # Represents a pawn chess piece.
+    class Pawn < Piece
+      # Calls the superclass.
+      def initialize db, piece_id, board = nil
+        super db, piece_id, board
+        
+        @html = @color == :white ? '&#9817;' : '&#9823;'
+      end
+
+      # Overwrite superclass method.
+      def self.new! db, board, position, color
+        super db, board, position, color
+        
+        id = db[:pieces].insert(:type => 'pawn', 
+                                :color => color.to_s,
+                                :position => position,
+                                :board_id => board.id)
+                                
+        return Pawn.new db, id, board
+      end
+    end
+  end
+end

data/lib/mail_chess/pieces/queen.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'mail_chess'
+require 'sequel'
+
+module MailChess
+  module Piece
+    # Represents a queen chess piece.
+    class Queen < Piece
+      # Calls the superclass.
+      def initialize db, piece_id, board = nil
+        super db, piece_id, board
+        
+        @html = @color == :white ? '&#9813;' : '&#9819;'
+      end
+
+      # Overwrite superclass method.
+      def self.new! db, board, position, color
+        super db, board, position, color
+
+        id = db[:pieces].insert(:type => 'queen', 
+                                :color => color.to_s,
+                                :position => position,
+                                :board_id => board.id)
+
+        return Queen.new db, id, board
+      end
+    end
+  end
+end
+

data/lib/mail_chess/pieces/rook.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'mail_chess'
+require 'sequel'
+
+module MailChess
+  module Piece
+    # Represents a rook chess piece.
+    class Rook < Piece
+      # Calls the superclass.
+      def initialize db, piece_id, board = nil
+        super db, piece_id, board
+        
+        @html = @color == :white ? '&#9814;' : '&#9820;'
+      end
+
+      # Overwrite superclass method.
+      def self.new! db, board, position, color
+        super db, board, position, color
+
+        id = db[:pieces].insert(:type => 'rook', 
+                                :color => color.to_s,
+                                :position => position,
+                                :board_id => board.id)
+
+        return Rook.new db, id, board
+      end
+    end
+  end
+end
+

data/lib/mail_chess/player.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+require 'mail_chess'
+require 'sequel'
+
+module MailChess
+  # Represents a player with an email account.
+  class Player
+    # Player ID in the database.
+    attr_reader :id
+
+    # Player name.
+    attr_accessor :name
+
+    # Player email address.
+    attr_reader :email
+
+    # Create a new Player object.
+    #
+    # Arguments:
+    #   db: Sequel database object
+    #   player_id: (Integer)
+    def initialize db, player_id
+      @db = db
+      
+      Player.create_tables(@db) if Player.need_to_create_tables?(@db)
+
+      @db_entry = @db[:players].filter(:id => player_id).first
+
+      @id = @db_entry[:id].to_i
+      @name = @db_entry[:name]
+      @email = @db_entry[:email]
+    end
+
+    # Checks if needed to create tables.
+    #
+    # Returns: (Boolean)
+    def self.need_to_create_tables? db
+      return (db.tables + [:players]).uniq.size != db.tables.size
+    end
+
+    # Create tables.
+    def self.create_tables db
+      db.create_table? :players do
+        primary_key :id
+        String :name
+        String :email
+      end
+    end
+
+    # Create a new player object and save it to the database.
+    #
+    # Arguments:
+    #   db: Sequel database object
+    #   email: (String) players email address
+    #   name: (String) players name
+    #
+    # Returns: (Player)
+    def self.new! db, email, name = ""
+      Player.create_tables(db) if Player.need_to_create_tables?(db)
+
+      id = db[:players].insert(:name => name, :email => email)
+
+      return Player.new db, id
+    end
+
+    # Load player from database.
+    #
+    # Arguments:
+    #   db: Sequel database object
+    #   filter: (Symbol) :id or :email
+    #   value: filters value
+    #
+    # Returns: (Player)
+    def self.load! db, filter, value
+      raise ArgumentError unless [:id, :email].index(filter)
+      dataset = db[:players].filter(filter => value)
+      raise ArgumentError unless dataset.all.size == 1
+
+      id = dataset.first[:id]
+
+      return Player.new db, id
+    end
+
+    # Find player's game by a reference string.
+    #
+    # Arguments:
+    #   reference: (String) game reference string
+    #
+    # Returns: (Game) or nil
+    def game reference
+      return Game.load! @db, :reference, reference
+    end
+
+    # Save player -- name only
+    def save!
+      @db[:players].filter(:id => @id).update(:name => @name)
+    end
+  end
+end

data/lib/mail_chess.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'mail_chess/board'
+require 'mail_chess/game'
+require 'mail_chess/player'
+
+require 'mail_chess/pieces/base'
+require 'mail_chess/pieces/bishop'
+require 'mail_chess/pieces/king'
+require 'mail_chess/pieces/knight'
+require 'mail_chess/pieces/pawn'
+require 'mail_chess/pieces/queen'
+require 'mail_chess/pieces/rook'

data/test/db_operations_test.rb

@@ -0,0 +1,56 @@
+require 'mail_chess'
+require 'test/unit'
+
+class DatabaseOperationsTest < Test::Unit::TestCase
+  def setup
+    @db = Sequel.connect 'sqlite:/'
+
+    p1 = MailChess::Player.new!(@db, 'john@doe.net', 'John Doe')
+    p2 = MailChess::Player.new!(@db, 'jane@doe.net')
+
+    g = MailChess::Game.new!(@db, p1, p2, 'abc')
+    g.board.start!
+  end
+
+  def test_load
+    g = MailChess::Player.load!(@db, :email, 'john@doe.net').game('abc')
+
+    assert_equal 2, g.players.size
+    assert_equal :white, g.current
+    assert_not_nil g.board
+    assert_equal 32, g.board.pieces.size
+  end
+
+  def test_save
+    g = MailChess::Player.load!(@db, :email, 'john@doe.net').game('abc')
+    
+    g.players[:white].name = 'John'
+    g.players[:white].save!
+
+    g.current = :black
+    g.save!
+
+    g.board.pieces['a3'] = g.board.pieces.delete('a2')
+    g.board.save!
+
+    # check
+    g_new = MailChess::Player.load!(@db, :email, 'john@doe.net').game('abc')
+
+    assert_equal 'John', g_new.players[:white].name
+    assert_equal :black, g_new.current
+    assert_nil g_new.board.pieces['a2']
+    assert_not_nil g_new.board.pieces['a3']
+  end
+
+  def test_delete
+    g = MailChess::Player.load!(@db, :email, 'john@doe.net').game('abc')
+
+    g.delete!
+
+    assert_equal 0, @db[:pieces].all.size
+    assert_equal 0, @db[:boards].all.size
+    assert_equal 0, @db[:games].all.size
+    assert_equal 0, @db[:pairs].all.size
+    assert_equal 2, @db[:players].all.size
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: mail_chess
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- András Kárász
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Play chess with your friends in email!
+email: karaszandris@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mail_chess/game.rb
+- lib/mail_chess/player.rb
+- lib/mail_chess/pieces/rook.rb
+- lib/mail_chess/pieces/queen.rb
+- lib/mail_chess/pieces/knight.rb
+- lib/mail_chess/pieces/bishop.rb
+- lib/mail_chess/pieces/pawn.rb
+- lib/mail_chess/pieces/base.rb
+- lib/mail_chess/pieces/king.rb
+- lib/mail_chess/board.rb
+- lib/mail_chess.rb
+- Rakefile
+- README
+- test/db_operations_test.rb
+homepage: http://rubygems.org/gems/mail_chess
+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.23
+signing_key: 
+specification_version: 3
+summary: Mail Chess
+test_files: []