chess_openings 0.0.3

data/lib/chess_openings/opening.rb

@@ -0,0 +1,40 @@
+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 }
+  end
+
+  def to_s
+    "#{@eco_code}: #{@name}\n#{@moves}"
+  end
+
+  def to_h
+    { "name" => @name, "eco_code" => @eco_code, "moves" => @moves }
+  end
+
+  def ==(other)
+    @name == other.name && @eco_code == other.eco_code && @moves == other.moves
+  end
+
+  def to_pgn
+    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
+
+      index += 1
+    end
+    return result
+  end
+end

data/lib/chess_openings/search_tree.rb

@@ -0,0 +1,163 @@
+class SearchTree
+
+  attr_accessor :root
+
+  def initialize
+    @root = Node.new(nil)
+  end
+
+  def empty?
+    @root.is_leaf?
+  end
+
+  def size
+    size_helper(@root)
+  end
+
+  def to_s
+    @root.to_s
+  end
+
+  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
+  end
+
+  def insert(moves, value)
+    moves = moves_in_symbols(moves)
+    insert_helper(moves, value, @root)
+  end
+
+  def search(moves)
+    moves = moves_in_symbols(moves)
+    search_helper(moves, @root)
+  end
+
+  def search_all_with_moves(moves)
+    moves = moves_in_symbols(moves)
+    node = find_node(moves, @root)
+    get_all_from_node(node).flatten
+  end
+
+
+  private
+
+    def moves_in_symbols(moves)
+      moves.map! { |move| move.is_a?(String)? move.to_sym : move }
+    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 get_all_from_node(curr_node)
+
+      result = curr_node.value.nil? ? [] : [curr_node.value]
+      return result if curr_node.is_leaf?
+
+      curr_hash = curr_node.nodes
+
+      curr_hash.each do |key, value|
+        next_node = value
+        result << get_all_from_node(next_node)
+      end
+
+      result
+    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
+
+      next_node = curr_hash[move]
+      insert_helper(moves.drop(1), value, next_node)
+    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 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
+    end
+
+  class Node
+
+    attr_accessor :value, :nodes
+
+    def initialize(value)
+      @value = value
+      @nodes = {}
+    end
+
+    def is_leaf?
+      @nodes.empty?
+    end
+
+    def size
+      @nodes.size
+    end
+
+    def keys
+      @nodes.keys
+    end
+
+    def include?(key)
+      @nodes.keys.include?(key)
+    end
+
+    def ==(other)
+      return false if self.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

data/openings_parser.rb

@@ -0,0 +1,85 @@
+require 'nokogiri'
+require 'open-uri'
+require 'json'
+load 'opening.rb'
+
+def get_eco_code(name)
+  name.split(' ').first
+end
+
+def remove_eco_code(name)
+  name.split(' ').drop(1).join(' ')
+end
+
+def has_more_than_1_code?(name)
+  get_eco_code(name).size > 3
+end
+
+def convert_line_to_array(moves)
+  moves.split(' ').select{ |move| !move.include?('.') }
+end
+
+initial_page = "http://www.365chess.com/eco.php"
+
+openings = []
+pages_to_scrap = [initial_page]
+
+# Scrap pages in pages_to_scrap array and dump Opening objects to openings array
+pages_to_scrap.each do |link|
+  
+  page = Nokogiri::HTML(open(link))   
+  page.css('ul#tree li.closed div.line').each do |line|
+
+    if has_more_than_1_code?(line.css('div.opname a').text)
+    
+      pages_to_scrap << line.css('div.opname a').first["href"]
+    else
+      name = remove_eco_code(line.css('div.opname a').text)
+      eco = get_eco_code(line.css('div.opname a').text)
+      moves = convert_line_to_array(line.css('div.fright').text.empty? ? line.css('div.opmoves').text : line.css('div.fright').text)
+
+      openings << Opening.new(name, eco, moves)
+    end
+  end
+end
+
+puts "Number of openings aquired: #{openings.size}"
+puts "Number of pages scrapped: #{pages_to_scrap.size}"
+
+# openings.each do |op|
+#   puts op.to_s
+# end
+
+# Check if there are some invalid openings
+invalid_openings = openings.select do |op|
+  op.name.empty? || op.moves.empty? || op.eco_code.empty?
+end
+
+# If there are no invalid openings, go ahead and create a JSON
+if invalid_openings.empty?
+
+  # Convert array elements to hashes
+  openings.map! { |op| op.to_h }
+
+  # Write to JSON
+  File.delete("openings.json") if File.exists?("openings.json")
+  File.open("openings.json", "a+") do |file|
+    file.write("{\n")
+    file.write("\"openings\": [\n")
+    
+    openings.each_with_index do |op, index|
+      result = openings.size == index + 1 ? "" : ", "
+      file.write("#{JSON.generate(op)}#{result}\n")
+    end
+    
+    file.write("]")
+    file.write("}")
+
+    puts "openings.json was successfully created!"
+  end
+
+else
+  puts "There were some invalid openings detected:"
+  puts invalid_openings
+end
+

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: chess_openings
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Simão Neves
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pgn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.6.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.6.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Gem that allows you to know what chess opening was used in a chess game,
+  find chess openings by name or get all openings that start with certain moves
+email:
+- simaocostaneves@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- chess_openings-0.0.1.gem
+- chess_openings.gemspec
+- lib/chess_openings.rb
+- lib/chess_openings/json_openings/openings.json
+- lib/chess_openings/opening.rb
+- lib/chess_openings/search_tree.rb
+- openings_parser.rb
+homepage: http://www.github.com/simaoneves/chess_openings
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Gem that allows you to calculate which opening was used in a chess game
+test_files: []