qi 9.0.0.beta2 → 10.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f66c9affa38d8e5dadfc596d5df81b47839187830d834600d624558d3643077e
-  data.tar.gz: fd345a4baeacbf22a0a898731dc26b19063727190a497a6d4cf779ca6275bf96
+  metadata.gz: 3aa8e642b758585848e8313040632928a9e4f2f3054850f8fd5357891bbc1e85
+  data.tar.gz: 644e686cd59a9a61ce7405441d57c36dd38cec638d45814c2d2a4aa8cf7c6c29
 SHA512:
-  metadata.gz: f5ef7c30f20b03fb3a6712c8b14824b1878a0f706159973b9d5c0c6270092042e12a4ecc50254e99f8d6107466367f58d530d77489370b3a54437e8f31bf42bb
-  data.tar.gz: 9364870e925d1769e5c9d233bcc8acb626a0a9d70d62725eafda311a926bd6ed398cb5e0efbff71a09ca659bcfc5e67037126ee4c4cffaa7b79e2687dcc1f470
+  metadata.gz: b796b912f5bd07395d2a90166e10e9109d717ee3e873e546f50117438a341ea0e485b2daa2121b37af58ab2be594935d3cd3f126eed01ecacd44f457faf0740e
+  data.tar.gz: 0ed78551692a98212c3de8293216bde978c745a8502db6d890dbc4c40f991045014736c0c1b8ba75d3ae96d7e012f50a3cfefd1dcbc8b9e4e09dc54fcac0f4a4

data/LICENSE.md

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+# The MIT License
 
-Copyright (c) 2015-2021 Sashite
+Copyright (c) 2015-2023 Sashite
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -6,20 +6,20 @@
 [![RuboCop](https://github.com/sashite/qi.rb/workflows/RuboCop/badge.svg?branch=main)](https://github.com/sashite/qi.rb/actions?query=workflow%3Arubocop+branch%3Amain)
 [![License](https://img.shields.io/github/license/sashite/qi.rb?label=License&logo=github)](https://github.com/sashite/qi.rb/raw/main/LICENSE.md)
 
-> `Qi` (棋) is an abstraction for updating positions of chess variants (including Chess, Janggi, Markruk, Shogi, Xiangqi), with a move.
+> `Qi` (Chinese: 棋; pinyin: _qí_) is an abstraction that could help to update positions for games like Shogi.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "qi", ">= 9.0.0.beta2"
+gem "qi", ">= 10.0.0.beta1"
 ```
 
 And then execute:
 
 ```sh
-bundle
+bundle install
 ```
 
 Or install it yourself as:
@@ -28,23 +28,18 @@ Or install it yourself as:
 gem install qi --pre
 ```
 
-## Examples
+## Example
 
 ```ruby
 require "qi"
 
-Qi.call(
-  [43, 13, "+B"],
-  in_hand: %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p],
-  square: {
-    3 => "s",
-    4 => "k",
-    5 => "s",
-    22 => "+P",
-    43 => "+B"
-  }
-)
-# => {:square=>{3=>"s", 4=>"k", 5=>"s", 22=>"+P", 13=>"+B"}, :in_hand=>["S", "r", "r", "b", "g", "g", "g", "g", "s", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p"]}
+captures  = %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p]
+squares   = { "3": "s", "4": "k", "5": "s", "22": "+P", "43": "+B" }
+
+captures, squares = Qi(*captures, **squares).call("43": nil, "13": "+B")
+
+captures  # => ["S", "r", "r", "b", "g", "g", "g", "g", "s", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p"]
+squares   # => {:"3"=>"s", :"4"=>"k", :"5"=>"s", :"22"=>"+P", :"13"=>"+B"}
 ```
 
 ## License

data/lib/kernel.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# shareable_constant_value: none
+
+# warn_indent: true
+
+require_relative File.join("qi", "action")
+
+# The Kernel module.
+module Kernel
+  # Abstraction to build positions.
+  #
+  # @return [Array] An action to change the position.
+  #
+  # @api public
+  def Qi(*captures, **squares)
+    ::Qi::Action.new(*captures, **squares)
+  end
+end

data/lib/qi/action.rb

@@ -3,59 +3,45 @@
 module Qi
   # The Action abstraction.
   class Action
-    # Initialize an action instance.
-    #
-    # @param src_square_id [Integer, nil] The source square ID.
-    # @param dst_square_id [Integer] The target square ID.
-    # @param moved_piece_name [String] The moved piece name.
-    # @param captured_piece_name [String, nil] The captured piece name.
-    #
-    # @example Initialize a promoted bishop action from 43 to 13
-    #   new(43, 13, "+B", nil)
-    #
-    # @see https://developer.sashite.com/specs/portable-action-notation
-    def initialize(src_square_id, dst_square_id, moved_piece_name, captured_piece_name = nil)
-      @src_square_id = src_square_id
-      @dst_square_id = dst_square_id
-      @moved_piece_name = moved_piece_name
-      @captured_piece_name = captured_piece_name
+    CAPTURE_CHAR = "&"
+    DROP_CHAR = "*"
+
+    # Action initializer.
+    def initialize(*captures, **squares)
+      @captures = captures
+      @squares  = squares
     end
 
     # Commit an action to the position.
     #
-    # @param in_hand [Array] The list of pieces in hand.
-    # @param square [Hash] The index of each piece on the board.
-    #
-    # @example Commit a Shogi action to the piece set of a position
-    #   call(
-    #     43, 13, "+B", nil,
-    #     in_hand: %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p],
-    #     square: {
-    #        3 => "s",
-    #        4 => "k",
-    #        5 => "s",
-    #       22 => "+P",
-    #       43 => "+B"
-    #     }
-    #   )
-    #   # => {:in_hand=>["S", "r", "r", "b", "g", "g", "g", "g", "s", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p"], :square=>{3=>"s", 4=>"k", 5=>"s", 22=>"+P", 13=>"+B"}}
-    #
-    # @return [Hash] The next piece set.
-    def call(in_hand:, square:)
-      in_hand = in_hand.dup
-      square = square.dup
-
-      if @src_square_id.nil?
-        piece_in_hand_id = in_hand.index(@moved_piece_name)
-        in_hand.delete_at(piece_in_hand_id) unless piece_in_hand_id.nil?
-      else
-        square.delete(@src_square_id)
+    # @return [Array] An action to change the position.
+    def call(**diffs)
+      captures = @captures
+      squares  = @squares
+
+      diffs.each do |k, v|
+        case String(k)
+        when CAPTURE_CHAR
+          captures = capture(v, *captures)
+        when DROP_CHAR
+          captures = drop(v, *captures)
+        else
+          squares = squares.merge(k => v)
+        end
       end
 
-      square[@dst_square_id] = @moved_piece_name
-      in_hand.push(@captured_piece_name) unless @captured_piece_name.nil?
+      [captures, squares.compact]
+    end
+
+    private
+
+    def capture(item, *items)
+      [item] + items
+    end
 
-      { in_hand: in_hand, square: square }
+    def drop(item, *items)
+      items.delete_at(items.index(item))
+      items
     end
   end
 end

data/lib/qi.rb

@@ -1,48 +1,7 @@
 # frozen_string_literal: true
 
-require_relative File.join("qi", "move")
+require_relative "kernel"
 
 # The Qi abstraction.
-#
-# @example Apply a move to a classic Shogi problem
-#   Qi.call(
-#     [43, 13, "+B"],
-#     in_hand: %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p],
-#     square: {
-#        3 => "s",
-#        4 => "k",
-#        5 => "s",
-#       22 => "+P",
-#       43 => "+B"
-#     }
-#   )
-#   # => {:in_hand=>["S", "r", "r", "b", "g", "g", "g", "g", "s", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p"], :square=>{3=>"s", 4=>"k", 5=>"s", 22=>"+P", 13=>"+B"}}
 module Qi
-  # Apply a move to the position.
-  #
-  # @param move [Array] The move to play.
-  # @param in_hand [Array] The list of pieces in hand.
-  # @param square [Hash] The index of each piece on the board.
-  #
-  # @see https://developer.sashite.com/specs/portable-chess-notation
-  # @see https://developer.sashite.com/specs/portable-move-notation
-  #
-  # @example Apply a move to a classic Shogi problem
-  #   call(
-  #     [43, 13, "+B"],
-  #     in_hand: %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p],
-  #     square: {
-  #        3 => "s",
-  #        4 => "k",
-  #        5 => "s",
-  #       22 => "+P",
-  #       43 => "+B"
-  #     }
-  #   )
-  #   # => {:in_hand=>["S", "r", "r", "b", "g", "g", "g", "g", "s", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p"], :square=>{3=>"s", 4=>"k", 5=>"s", 22=>"+P", 13=>"+B"}}
-  #
-  # @return [Hash] The piece set of the next position.
-  def self.call(move, in_hand:, square:)
-    Move.new(move).call(in_hand: in_hand, square: square)
-  end
 end

metadata

@@ -1,17 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: qi
 version: !ruby/object:Gem::Version
-  version: 9.0.0.beta2
+  version: 10.0.0.beta1
 platform: ruby
 authors:
 - Cyril Kato
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-13 00:00:00.000000000 Z
+date: 2023-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: brutal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0.beta4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0.beta4
+- !ruby/object:Gem::Dependency
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rubocop-gitlab-security
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -150,7 +164,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Instantiate PCN's positions and apply PMN's moves.
+description: An abstraction that could help to update positions for games like Shogi.
 email: contact@cyril.email
 executables: []
 extensions: []
@@ -158,17 +172,15 @@ extra_rdoc_files: []
 files:
 - LICENSE.md
 - README.md
+- lib/kernel.rb
 - lib/qi.rb
 - lib/qi/action.rb
-- lib/qi/move.rb
-homepage: https://developer.sashite.com/specs/
+homepage: https://github.com/sashite/qi.rb
 licenses:
 - MIT
 metadata:
-  bug_tracker_uri: https://github.com/sashite/qi.rb/issues
-  documentation_uri: https://rubydoc.info/gems/qi/index
-  source_code_uri: https://github.com/sashite/qi.rb
-post_install_message:
+  rubygems_mfa_required: 'true'
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -176,15 +188,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.2.22
-signing_key:
+rubygems_version: 3.4.1
+signing_key: 
 specification_version: 4
-summary: Update positions with a move.
+summary: An abstraction that could help to update positions for games like Shogi.
 test_files: []

data/lib/qi/move.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "action"
-
-module Qi
-  # The Move abstraction.
-  class Move
-    # Initialize a move instance.
-    #
-    # @param move [Array] The move to apply.
-    #
-    # @example Initialize a promoted bishop move from 43 to 13
-    #   new([43, 13, "+B"])
-    #
-    # @see https://developer.sashite.com/specs/portable-move-notation
-    def initialize(move)
-      @actions = move.each_slice(4)
-    end
-
-    # Apply a move to the piece set of a position.
-    #
-    # @param in_hand [Array] The list of pieces in hand.
-    # @param square [Hash] The index of each piece on the board.
-    #
-    # @example Apply a move to a classic Shogi problem
-    #   call(
-    #     [43, 13, "+B"],
-    #     in_hand: %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p],
-    #     square: {
-    #        3 => "s",
-    #        4 => "k",
-    #        5 => "s",
-    #       22 => "+P",
-    #       43 => "+B"
-    #     }
-    #   )
-    #   # => {:in_hand=>["S", "r", "r", "b", "g", "g", "g", "g", "s", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p"], :square=>{3=>"s", 4=>"k", 5=>"s", 22=>"+P", 13=>"+B"}}
-    #
-    # @return [Hash] The piece set of the next position.
-    def call(in_hand:, square:)
-      @actions.inject(in_hand: in_hand, square: square) do |piece_set, attrs|
-        Action.new(*attrs).call(**piece_set)
-      end
-    end
-  end
-end