RubyGems - chess_openings - Versions diffs - 0.0.3 → 1.0.0 - Mend

chess_openings 0.0.3 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

checksums.yaml +4 -4
data/.gitignore +3 -1
data/.yardoc/checksums +4 -0
data/.yardoc/complete +0 -0
data/.yardoc/object_types +0 -0
data/.yardoc/objects/root.dat +0 -0
data/.yardoc/proxy_types +0 -0
data/Gemfile +3 -2
data/Gemfile.lock +13 -2
data/README.md +124 -10
data/{openings_parser.rb → bin/openings_parser} +24 -23
data/chess_openings.gemspec +16 -14
data/doc/ChessOpenings.html +1163 -0
data/doc/ChessOpeningsHelper.html +355 -0
data/doc/InvalidPGNError.html +135 -0
data/doc/Opening.html +909 -0
data/doc/SearchTree/Node.html +770 -0
data/doc/SearchTree.html +1081 -0
data/doc/_index.html +166 -0
data/doc/class_list.html +51 -0
data/doc/css/common.css +1 -0
data/doc/css/full_list.css +58 -0
data/doc/css/style.css +492 -0
data/doc/file.README.html +241 -0
data/doc/file_list.html +56 -0
data/doc/frames.html +17 -0
data/doc/index.html +241 -0
data/doc/js/app.js +243 -0
data/doc/js/full_list.js +216 -0
data/doc/js/jquery.js +4 -0
data/doc/method_list.html +371 -0
data/doc/top-level-namespace.html +110 -0
data/lib/chess_openings/chess_openings_helper.rb +18 -0
data/lib/chess_openings/json_openings/openings.json +3 -3
data/lib/chess_openings/opening.rb +31 -15
data/lib/chess_openings/search_tree.rb +97 -81
data/lib/chess_openings.rb +51 -20
metadata +61 -7
data/chess_openings-0.0.1.gem +0 -0

data/doc/top-level-namespace.html ADDED Viewed

@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>
+  Top Level Namespace
+    &mdash; Documentation by YARD 0.9.7
+</title>
+  <link rel="stylesheet" href="css/style.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/common.css" type="text/css" charset="utf-8" />
+<script type="text/javascript" charset="utf-8">
+  pathId = "";
+  relpath = '';
+</script>
+  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+  </head>
+  <body>
+    <div class="nav_wrap">
+      <iframe id="nav" src="class_list.html?1"></iframe>
+      <div id="resizer"></div>
+    </div>
+    <div id="main" tabindex="-1">
+      <div id="header">
+        <div id="menu">
+    <a href="_index.html">Index</a> &raquo;
+    <span class="title">Top Level Namespace</span>
+</div>
+        <div id="search">
+    <a class="full_list_link" id="class_list_link"
+        href="class_list.html">
+        <svg width="24" height="24">
+          <rect x="0" y="4" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="12" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="20" width="24" height="4" rx="1" ry="1"></rect>
+        </svg>
+    </a>
+</div>
+        <div class="clear"></div>
+      </div>
+      <div id="content"><h1>Top Level Namespace
+</h1>
+<div class="box_info">
+</div>
+<h2>Defined Under Namespace</h2>
+<p class="children">
+      <strong class="classes">Classes:</strong> <span class='object_link'><a href="ChessOpenings.html" title="ChessOpenings (class)">ChessOpenings</a></span>, <span class='object_link'><a href="ChessOpeningsHelper.html" title="ChessOpeningsHelper (class)">ChessOpeningsHelper</a></span>, <span class='object_link'><a href="InvalidPGNError.html" title="InvalidPGNError (class)">InvalidPGNError</a></span>, <span class='object_link'><a href="Opening.html" title="Opening (class)">Opening</a></span>, <span class='object_link'><a href="SearchTree.html" title="SearchTree (class)">SearchTree</a></span>
+</p>
+</div>
+      <div id="footer">
+  Generated on Thu Jan 12 10:12:16 2017 by
+  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  0.9.7 (ruby-2.2.0).
+</div>
+    </div>
+  </body>
+</html>

data/lib/chess_openings/chess_openings_helper.rb ADDED Viewed

@@ -0,0 +1,18 @@
+# Helper class with utility functions
+class ChessOpeningsHelper
+  # Transform contents of array to symbols
+  #
+  # @param [Array] moves Moves as strings or symbols
+  # @return [Array] Array with all moves as symbols
+  def self.moves_as_symbols(moves)
+    moves.map { |move| move.is_a?(String) ? move.to_sym : move }
+  end
+  # Transform contents of array to strings
+  #
+  # @param [Array] moves Moves as strings or symbols
+  # @return [Array] Array with all moves as strings
+  def self.moves_as_strings(moves)
+    moves.map { |move| move.is_a?(Symbol) ? move.to_s : move }
+  end
+end

data/lib/chess_openings/json_openings/openings.json CHANGED Viewed

@@ -636,8 +636,8 @@
 {"name":"Sicilian, Pin, Koch variation","eco_code":"B40","moves":["e4","c5","Nf3","e6","d4","cxd4","Nxd4","Nf6","Nc3","Bb4","e5"]},
 {"name":"Sicilian defence","eco_code":"B44","moves":["e4","c5","Nf3","e6","d4","cxd4","Nxd4","Nc6"]},
 {"name":"Sicilian, Szen (`anti-Taimanov') variation","eco_code":"B44","moves":["e4","c5","Nf3","e6","d4","cxd4","Nxd4","Nc6","Nb5"]},
-{"name":"Sicilian, Szen, hedgehog variation","eco_code":"B44","moves":["e4","c5","Nf3","e6","d4","cxd4","Nxd4","Nc6","Nb5","d6","c4","Nf6","Nb1-c3","a6","Na3","Be7","Be2","O-O","O-O","b6"]},
-{"name":"Sicilian, Szen variation, Dely-Kasparov gambit","eco_code":"B44","moves":["e4","c5","Nf3","e6","d4","cxd4","Nxd4","Nc6","Nb5","d6","c4","Nf6","Nb1-c3","a6","Na3","d5"]},
+{"name":"Sicilian, Szen, hedgehog variation","eco_code":"B44","moves":["e4","c5","Nf3","e6","d4","cxd4","Nxd4","Nc6","Nb5","d6","c4","Nf6","N1c3","a6","Na3","Be7","Be2","O-O","O-O","b6"]},
+{"name":"Sicilian, Szen variation, Dely-Kasparov gambit","eco_code":"B44","moves":["e4","c5","Nf3","e6","d4","cxd4","Nxd4","Nc6","Nb5","d6","c4","Nf6","N1c3","a6","Na3","d5"]},
 {"name":"Sicilian","eco_code":"B50","moves":["e4","c5","Nf3","d6"]},
 {"name":"Sicilian, wing gambit deferred","eco_code":"B50","moves":["e4","c5","Nf3","d6","b4"]},
 {"name":"Sicilian, Chekhover variation","eco_code":"B53","moves":["e4","c5","Nf3","d6","d4","cxd4","Qxd4"]},
@@ -1678,7 +1678,7 @@
 {"name":"French, Winawer, Kondratiyev variation","eco_code":"C15","moves":["e4","e6","d4","d5","Nc3","Bb4","Bd3","c5","exd5","Qxd5","Bd2"]},
 {"name":"French, Winawer, fingerslip variation","eco_code":"C15","moves":["e4","e6","d4","d5","Nc3","Bb4","Bd2"]},
 {"name":"French, Winawer, Alekhine (Maroczy) gambit","eco_code":"C15","moves":["e4","e6","d4","d5","Nc3","Bb4","Nge2"]},
-{"name":"French, Winawer, Alekhine gambit, Alatortsev variation","eco_code":"C15","moves":["e4","e6","d4","d5","Nc3","Bb4","Nge2","dxe4","a3","Be7","Nxe4","Nf6","Ne2-g3","O-O","Be2","Nc6"]},
+{"name":"French, Winawer, Alekhine gambit, Alatortsev variation","eco_code":"C15","moves":["e4","e6","d4","d5","Nc3","Bb4","Nge2","dxe4","a3","Be7","Nxe4","Nf6","N2g3","O-O","Be2","Nc6"]},
 {"name":"French, Winawer, Alekhine gambit","eco_code":"C15","moves":["e4","e6","d4","d5","Nc3","Bb4","Nge2","dxe4","a3","Bxc3+"]},
 {"name":"French, Winawer, Alekhine gambit, Kan variation","eco_code":"C15","moves":["e4","e6","d4","d5","Nc3","Bb4","Nge2","dxe4","a3","Bxc3+","Nxc3","Nc6"]},
 {"name":"French, Winawer, advance variation","eco_code":"C16","moves":["e4","e6","d4","d5","Nc3","Bb4","e5"]},

data/lib/chess_openings/opening.rb CHANGED Viewed

@@ -1,40 +1,56 @@
-class Opening
+require 'pgn'
+require_relative 'chess_openings_helper.rb'
+# Class that represents a chess Opening
+class Opening
   attr_accessor :name, :eco_code, :moves
   def initialize(name, eco_code, moves)
     @name = name
     @eco_code = eco_code
-    @moves = moves.map! { |move| move.is_a?(String)? move.to_sym : move }
+    @moves = moves.map! { |move| move.is_a?(String) ? move.to_sym : move }
   end
+  # String representation of Opening
+  #
+  # @return [String] String that represents an Opening
   def to_s
     "#{@eco_code}: #{@name}\n#{@moves}"
   end
+  # Hash representation of Opening
+  #
+  # @return [Hash] Hash that represents an Opening
   def to_h
-    { "name" => @name, "eco_code" => @eco_code, "moves" => @moves }
+    { 'name' => @name, 'eco_code' => @eco_code, 'moves' => @moves }
   end
+  # Compares two Openings
+  #
+  # @param [Opening] other Opening to be compared
+  # @return [Boolean] True if both Openings have same values, false otherwise
   def ==(other)
     @name == other.name && @eco_code == other.eco_code && @moves == other.moves
   end
+  # Returns PGN formatted String of the Opening
+  #
+  # @return [String] String that represents a game where Opening was used
   def to_pgn
-    result = ""
+    result = ''
     index = 1
     @moves.each do |move|
-      if index.odd?
-        result += "#{(index / 2.0).ceil}. #{move}"
-      elsif index.even? && @moves.size != index
-        result += " #{move} "
-      else
-        result += " #{move}"
-      end
+      result += index.odd? ? "#{(index / 2.0).ceil}.#{move}" : " #{move} "
       index += 1
     end
-    return result
+    result.chop!
+  end
+  # Returns FEN formatted String representation of the Opening
+  #
+  # @return [String] String that represents a game where Opening was used
+  def to_fen
+    moves = ChessOpeningsHelper.moves_as_strings(@moves)
+    PGN::Game.new(moves).fen_list.last
   end
-end
+end

data/lib/chess_openings/search_tree.rb CHANGED Viewed

@@ -1,128 +1,145 @@
-class SearchTree
+require_relative 'chess_openings_helper.rb'
+# Class that is a Tree-like data structure to hold all Openings
+class SearchTree
   attr_accessor :root
   def initialize
     @root = Node.new(nil)
   end
+  # Check if tree doesnt have child Nodes and root is empty
+  #
+  # @return [Boolean] True if the tree doesnt have childs and root value is nil, false otherwise
   def empty?
-    @root.is_leaf?
+    @root.empty? && @root.leaf?
   end
+  # Number of not empty Nodes
+  #
+  # @return [int] Total of not empty Nodes in the tree
   def size
     size_helper(@root)
   end
+  # String representation of the tree
+  #
+  # @return [String] Representation of the Nodes in the tree
   def to_s
     @root.to_s
   end
+  # Compares two trees
+  #
+  # @param [SearchTree] other SearchTree to be compared with
+  # @return [Boolean] True if both trees have the same children with the same values
   def ==(other)
-    return false unless @root.size == other.root.size
-    @root.keys.each do |key|
-      return false unless other.root.keys.include?(key)
-    end
-    @root.keys.each do |key|
-      return false unless @root.nodes[key] == other.root.nodes[key]
-    end
-    true
+    @root == other.root
   end
+  # Insert new value in SearchTree at the depth of the moves
+  #
+  # @param [Array] moves Path to the place to insert the value
+  # @param [Opening] value Value to be inserted in the tree
   def insert(moves, value)
-    moves = moves_in_symbols(moves)
+    moves = ChessOpeningsHelper.moves_as_symbols(moves)
     insert_helper(moves, value, @root)
   end
+  # Search in the tree with the path moves
+  #
+  # @param [Array] moves Array with Strings or symbols that represent the path
+  # @return [Opening] Opening that was found in the tree, Nil otherwise
   def search(moves)
-    moves = moves_in_symbols(moves)
+    moves = ChessOpeningsHelper.moves_as_symbols(moves)
     search_helper(moves, @root)
   end
+  # Search the tree for all the values from the path and values of its children
+  #
+  # @param [Array] moves Array with Strings or symbols that represent the path
+  # @return [Array] Array with values found
   def search_all_with_moves(moves)
-    moves = moves_in_symbols(moves)
+    moves = ChessOpeningsHelper.moves_as_symbols(moves)
     node = find_node(moves, @root)
     get_all_from_node(node).flatten
   end
+  # Get all values at a certain depth
+  #
+  # @param [int] num Depth to be used to find values
+  # @return [Array] Array with all the values found at depth num
+  def get_moves_in_depth(num)
+    get_moves_in_depth_helper(num, @root, 0).flatten
+  end
   private
-    def moves_in_symbols(moves)
-      moves.map! { |move| move.is_a?(String)? move.to_sym : move }
+  def get_moves_in_depth_helper(num_moves, curr_node, depth)
+    return [] if depth == num_moves && curr_node.value.nil?
+    return [curr_node.value] if depth == num_moves
+    result = []
+    curr_node.nodes.values.each do |node|
+      result << get_moves_in_depth_helper(num_moves, node, depth + 1)
     end
+    result
+  end
-    def find_node(moves, curr_node)
-      return curr_node if moves.empty?
-      curr_hash = curr_node.nodes
-      move = moves.first
-      return nil if curr_hash[move].nil?
-      next_node = curr_hash[move]
-      find_node(moves.drop(1), next_node)
-    end
+  def find_node(moves, curr_node)
+    return curr_node if moves.empty?
-    def get_all_from_node(curr_node)
+    curr_hash = curr_node.nodes
+    move = moves.first
+    return nil if curr_hash[move].nil?
-      result = curr_node.value.nil? ? [] : [curr_node.value]
-      return result if curr_node.is_leaf?
+    next_node = curr_hash[move]
+    find_node(moves.drop(1), next_node)
+  end
-      curr_hash = curr_node.nodes
+  def get_all_from_node(curr_node)
+    result = curr_node.value.nil? ? [] : [curr_node.value]
+    return result if curr_node.leaf?
-      curr_hash.each do |key, value|
-        next_node = value
-        result << get_all_from_node(next_node)
-      end
-      result
+    curr_hash = curr_node.nodes
+    curr_hash.values.each do |next_node|
+      result << get_all_from_node(next_node)
     end
-    def insert_helper(moves, value, curr_node)
-      return if moves.empty?
-      curr_hash = curr_node.nodes
-      move = moves.first
-      last_move = moves.size == 1
-      if curr_hash[move].nil?
-        if last_move
-          curr_hash[move] = Node.new(value)
-        else
-          curr_hash[move] = Node.new(nil)
-        end
-      else
-        curr_hash[move].value = value if last_move && curr_hash[move].value.nil?
-      end
+    result
+  end
-      next_node = curr_hash[move]
-      insert_helper(moves.drop(1), value, next_node)
+  def insert_helper(moves, value, curr_node)
+    return if moves.empty?
+    curr_hash = curr_node.nodes
+    move = moves.first
+    last_move = moves.size == 1
+    if curr_hash[move].nil?
+      curr_hash[move] = last_move ? Node.new(value) : Node.new(nil)
+    elsif last_move && curr_hash[move].value.nil?
+      curr_hash[move].value = value
     end
+    insert_helper(moves.drop(1), value, curr_hash[move])
+  end
-    def search_helper(moves, curr_node)
-      move = moves.first
-      curr_hash = curr_node.nodes
-      return nil if curr_hash[move].nil?
-      next_node = curr_hash[move]
-      return search_helper(moves.drop(1), next_node) || curr_hash[move].value
-    end
+  def search_helper(moves, curr_node)
+    move = moves.first
+    curr_hash = curr_node.nodes
+    return nil if curr_hash[move].nil?
+    next_node = curr_hash[move]
+    search_helper(moves.drop(1), next_node) || curr_hash[move].value
+  end
-    def size_helper(node)
-      sum = node.value.nil? ? 0 : 1
-      return sum if node.is_leaf?
-      node.keys.each do |key|
-        sum += size_helper(node.nodes[key])
-      end
-      return sum
+  def size_helper(node)
+    sum = node.value.nil? ? 0 : 1
+    return sum if node.leaf?
+    node.keys.each do |key|
+      sum += size_helper(node.nodes[key])
     end
+    sum
+  end
+  # Class that represents a node of a tree data structure
   class Node
     attr_accessor :value, :nodes
     def initialize(value)
@@ -130,7 +147,11 @@ class SearchTree
       @nodes = {}
     end
-    def is_leaf?
+    def empty?
+      @value.nil?
+    end
+    def leaf?
       @nodes.empty?
     end
@@ -147,17 +168,12 @@ class SearchTree
     end
     def ==(other)
-      return false if self.size != other.size || @value != other.value
+      return false if size != other.size || @value != other.value
       @nodes.keys.each do |key|
         return false unless other.keys.include?(key)
-      end
-      @nodes.keys.each do |key|
         return false if @nodes[key] != other.nodes[key]
       end
       true
     end
   end
-end
+end

data/lib/chess_openings.rb CHANGED Viewed

@@ -4,74 +4,105 @@ require 'json'
 require 'chess_openings/opening.rb'
 require 'chess_openings/search_tree.rb'
+# Class responsible for searching for chess Openings
 class ChessOpenings
   attr_accessor :tree, :list
   def initialize
     @tree = SearchTree.new
     @list = []
-    file = "/chess_openings/json_openings/openings.json"
+    file = '/chess_openings/json_openings/openings.json'
     openings_file = File.join(File.dirname(__FILE__), file)
-    openings = JSON.load(File.open(openings_file))["openings"]
+    openings = JSON.load(File.open(openings_file))['openings']
     openings.each do |op|
-      opening = Opening.new(op["name"], op["eco_code"], op["moves"])
+      opening = Opening.new(op['name'], op['eco_code'], op['moves'])
       @list << opening
       @tree.insert opening.moves, opening
     end
   end
-  def get_all
+  # Get all openings available
+  #
+  # @return [Array] Array with all the Openings possible
+  def all
     @list.dup
   end
+  # Get Opening from moves (as symbols or strings)
+  #
+  # @param [Array] moves Array with strings or symbols
+  # @return [Opening] Opening that has exactly the moves in the argument
   def from_moves(moves)
-    # moves.map! { |move| move.to_s if move.is_a? Symbol }
     @tree.search moves
   end
+  # Get Opening from a PGN file
+  #
+  # @param [String] file_name String with the path to the PGN file
+  # @return [Opening] Opening that was used in the PGN game
+  # @raise [InvalidPGNError] Path points to invalid PGN file
+  # @raise [LoadError] Path points to non existent file
   def from_pgn(file_name)
-    raise LoadError, "File does not exist" unless File.exist?(file_name)
+    raise LoadError, 'File does not exist' unless File.exist?(file_name)
     begin
       game = PGN.parse(File.read(file_name)).first
-      @tree.search game.moves
+      @tree.search game.moves.map(&:notation)
     rescue
-      raise InvalidPGNError, "Invalid PGN file"
+      raise InvalidPGNError, 'Invalid PGN file'
     end
   end
+  # Search Openings by name
+  #
+  # @param [String] name String with the name to search for
+  # @return [Array] Array with all the Openings found
   def with_name(name)
     @list.select { |op| op.name.downcase.include?(name.downcase) }
   end
+  # Search all Openings that start with the moves in the argument
+  #
+  # @param [Array] moves Moves to be searched for
+  # @return [Array] Array with all Openings that start with the moves provided
   def that_start_with(moves)
     @tree.search_all_with_moves moves
   end
+  # Get Opening from a PGN formatted String
+  #
+  # @param [String] string String in PGN format
+  # @return [Opening] Opening that was used in PGN formatted String
   def from_string(string)
     array = string.split
     moves = []
     array.each do |move|
-      if move.include?(".")
-        next if move.end_with?(".")
-        move = move.split(".").last
+      if move.include?('.')
+        next if move.end_with?('.')
+        move = move.split('.').last
       end
       moves << move
     end
     @tree.search moves
   end
-  private
+  # Get Opening from FEN string
+  #
+  # @param [String] fen_string FEN formatted String
+  # @return [Opening] Opening that was used in the game of the FEN String
+  def from_fen(fen_string)
+    fen = PGN::FEN.new(fen_string)
+    move_number = (fen.fullmove.to_i - 1) * 2
+    final_list = @tree.get_moves_in_depth(move_number)
+    final_list.select { |op| op.to_fen == fen_string }.first
+  end
-    def to_s
-      @tree.to_s
-    end
+  private
+  def to_s
+    @tree.to_s
+  end
 end
+# Exception raised when there is a error reading a PGN file
 class InvalidPGNError < RuntimeError
 end