spy_alley_application 0.3.0

data/lib/spy_alley_application/types/nationality.rb

@@ -0,0 +1,5 @@
+# frozen string literal: true
+
+SpyAlleyApplication::Types::Nationality =
+  ::Types::String::enum('french', 'german', 'spanish', 'italian', 'american', 'russian')
+

data/lib/spy_alley_application/types/player.rb

@@ -0,0 +1,123 @@
+# frozen string_literal: true
+
+require 'dry-initializer'
+require 'spy_alley_application/models/player'
+require 'spy_alley_application/models/board_spaces/black_market'
+require 'spy_alley_application/models/board_spaces/border_crossing'
+require 'spy_alley_application/models/board_spaces/buy_equipment'
+require 'spy_alley_application/models/board_spaces/buy_password'
+require 'spy_alley_application/models/board_spaces/confiscate_materials'
+require 'spy_alley_application/models/board_spaces/draw_free_gift'
+require 'spy_alley_application/models/board_spaces/draw_move_card'
+require 'spy_alley_application/models/board_spaces/embassy'
+require 'spy_alley_application/models/board_spaces/move_back'
+require 'spy_alley_application/models/board_spaces/sold_top_secret_information'
+require 'spy_alley_application/models/board_spaces/spy_alley_entrance'
+require 'spy_alley_application/models/board_spaces/spy_eliminator'
+require 'spy_alley_application/models/board_spaces/start'
+require 'spy_alley_application/models/board_spaces/take_another_turn'
+
+start_space = SpyAlleyApplication::Models::BoardSpaces::Start::new(id: 0) do |start_space|
+  junction_space = SpyAlleyApplication::Models::BoardSpaces::DrawMoveCard::new(id: 22,
+    next_space: SpyAlleyApplication::Models::BoardSpaces::BlackMarket::new(id: 23,
+    next_space: start_space))
+
+  spy_alley_entrance = SpyAlleyApplication::Models::BoardSpaces::SpyAlleyEntrance::new(id: 14,
+    next_space: SpyAlleyApplication::Models::BoardSpaces::SoldTopSecretInformation::new(id: 24,
+      in_spy_alley: true,
+      money_gained: 20,
+    next_space: SpyAlleyApplication::Models::BoardSpaces::SpyEliminator::new(id: 25,
+    next_space: SpyAlleyApplication::Models::BoardSpaces::Embassy::new(id: 26,
+      nationality: 'french',
+    next_space: SpyAlleyApplication::Models::BoardSpaces::Embassy::new(id: 27,
+      nationality: 'german',
+    next_space: SpyAlleyApplication::Models::BoardSpaces::ConfiscateMaterials::new(id: 28,
+    next_space: SpyAlleyApplication::Models::BoardSpaces::Embassy::new(id: 29,
+      nationality: 'spanish',
+    next_space: SpyAlleyApplication::Models::BoardSpaces::Embassy::new(id: 30,
+      nationality: 'italian',
+    next_space: SpyAlleyApplication::Models::BoardSpaces::Embassy::new(id: 31,
+      nationality: 'american',
+    next_space: SpyAlleyApplication::Models::BoardSpaces::Embassy::new(id: 32,
+      nationality: 'russian',
+      next_space: junction_space)))))))))) do |spy_alley_entrance|
+    SpyAlleyApplication::Models::BoardSpaces::BorderCrossing::new(id: 15,
+      next_space: SpyAlleyApplication::Models::BoardSpaces::MoveBack::new(id: 16,
+        move_back_space: spy_alley_entrance,
+      next_space: SpyAlleyApplication::Models::BoardSpaces::BuyPassword::new(id: 17,
+        nationality: 'german',
+      next_space: SpyAlleyApplication::Models::BoardSpaces::BuyEquipment::new(id: 18,
+        equipment_type: 'codebook',
+      next_space: SpyAlleyApplication::Models::BoardSpaces::DrawMoveCard::new(id: 19,
+      next_space: SpyAlleyApplication::Models::BoardSpaces::DrawFreeGift::new(id: 20,
+      next_space: SpyAlleyApplication::Models::BoardSpaces::BuyPassword::new(id: 21,
+        nationality: 'french',
+        next_space: junction_space)))))))
+  end
+
+  SpyAlleyApplication::Models::BoardSpaces::BuyPassword::new(id: 1, nationality: 'russian',
+    next_space: SpyAlleyApplication::Models::BoardSpaces::DrawMoveCard::new(id: 2,
+    next_space: SpyAlleyApplication::Models::BoardSpaces::BuyEquipment::new(id: 3,
+      equipment_type: 'disguise',
+    next_space: SpyAlleyApplication::Models::BoardSpaces::BuyPassword::new(id: 4,
+      nationality: 'american',
+    next_space: SpyAlleyApplication::Models::BoardSpaces::DrawMoveCard::new(id: 5,
+    next_space: SpyAlleyApplication::Models::BoardSpaces::TakeAnotherTurn::new(id: 6,
+    next_space: SpyAlleyApplication::Models::BoardSpaces::DrawFreeGift::new(id: 7,
+    next_space: SpyAlleyApplication::Models::BoardSpaces::SoldTopSecretInformation::new(id: 8,
+      in_spy_alley: false,
+      money_gained: 10,
+    next_space: SpyAlleyApplication::Models::BoardSpaces::BuyPassword::new(id: 9,
+      nationality: 'italian',
+    next_space: SpyAlleyApplication::Models::BoardSpaces::BuyEquipment::new(id: 10,
+      equipment_type: 'key',
+    next_space: SpyAlleyApplication::Models::BoardSpaces::BuyPassword::new(id: 11,
+      nationality: 'spanish',
+    next_space: SpyAlleyApplication::Models::BoardSpaces::DrawMoveCard::new(id: 12,
+    next_space: SpyAlleyApplication::Models::BoardSpaces::BlackMarket::new(id: 13,
+      next_space: spy_alley_entrance)))))))))))))
+end
+spaces = [start_space]
+(0..13).to_a.each do |i|
+  spaces.push(spaces.last.next_space)
+end
+spaces.push(spaces.last.branch_space)
+(15..22).to_a.each do |i|
+  spaces.push(spaces.last.next_space)
+end
+spaces.push(spaces[14].next_space)
+(24..31).to_a.each do |i|
+  spaces.push(spaces.last.next_space)
+end
+
+loc_type = Dry::Struct(id: Types::Coercible::Integer)
+
+i = Class::new do
+  include Dry::Initializer.define -> do
+    param :game_board_spaces, type: ::Types::Array::of(SpyAlleyApplication::Types::BoardSpace)
+    param :location_type, type: ::Types::Callable
+  end
+
+  def call(player)
+    player[:location] = game_board_spaces[location_type.(player[:location]).id]
+    player = player.map{|k, v| [k.eql?(:active?) ? :active : k, v]}.to_h
+    player = SpyAlleyApplication::Models::Player.(player)
+    all_equipment_distinct(player, player.equipment)
+    player
+  end
+
+  private
+  def all_equipment_distinct(player, equipment)
+    equipment_list = []
+    equipment.each do |equip|
+      equip_name = "#{equip.nationality} #{equip.type}"
+      if equipment_list.include?(equip_name)
+        raise Dry::Types::ConstraintError::new(
+          'All equipment for player is distinct', "player: #{player}, equipment: #{equipment}")
+      end
+      equipment_list.push equip_name
+    end
+  end
+end.new(spaces, loc_type)
+SpyAlleyApplication::Types::Player = ::Types::Constructor(Class){|value| i.call(value)}
+

data/lib/spy_alley_application/types/validation_builder.rb

@@ -0,0 +1,21 @@
+# frozen string_literal: true
+
+require 'spy_alley_application/models/validator/buying_equipment'
+require 'spy_alley_application/models/validator/choosing_new_spy_identity'
+require 'spy_alley_application/models/validator/confiscating_materials'
+require 'spy_alley_application/models/validator/making_accusation'
+require 'spy_alley_application/models/validator/moving'
+require 'spy_alley_application/models/validator/passing'
+require 'spy_alley_application/models/validator/rolling_die'
+require 'spy_alley_application/models/validator/using_move_card'
+
+SpyAlleyApplication::Types::ValidationBuilder =
+  SpyAlleyApplication::Models::Validator::BuyingEquipment |
+  SpyAlleyApplication::Models::Validator::ChoosingNewSpyIdentity |
+  SpyAlleyApplication::Models::Validator::ConfiscatingMaterials |
+  SpyAlleyApplication::Models::Validator::MakingAccusation |
+  SpyAlleyApplication::Models::Validator::Moving |
+  SpyAlleyApplication::Models::Validator::Passing |
+  SpyAlleyApplication::Models::Validator::RollingDie |
+  SpyAlleyApplication::Models::Validator::UsingMoveCard
+

data/lib/spy_alley_application/types/validator/non_admin.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spy_alley_application/types/validator/buy_equipment'
+require 'spy_alley_application/types/validator/choose_new_spy_identity'
+require 'spy_alley_application/types/validator/confiscate_materials'
+require 'spy_alley_application/types/validator/make_accusation'
+require 'spy_alley_application/types/validator/move'
+require 'spy_alley-application/types/validator/pass'
+require 'spy_alley_application/types/validator/roll_die'
+require 'spy_alley_application/types/validator/use_move_card'
+
+SpyAlleyApplication::Types::Validator::NonAdmin =
+  SpyAlleyApplication::Types::Validator::BuyEquipment |
+  SpyAlleyApplication::Types::Validator::ChooseNewSpyIdentity |
+  SpyAlleyApplicaiton::Types::Validator::ConfiscateMaterials |
+  SpyAlleyApplication::Types::Validator::MakeAccusation |
+  SpyAlleyApplication::Types::Validator::Move |
+  SpyAlleyApplication::Types::Validator::Pass |
+  SpyAlleyApplication::Types::Validator::RollDie |
+  SpyalleyApplication::Types::Validator::UseMoveCard
+

data/lib/spy_alley_application/types/wild_card.rb

@@ -0,0 +1,14 @@
+# frozen string_literal: true
+
+require 'dry-types'
+require 'spy_alley_application/models/wild_card'
+
+wild_card_enum = Types::String.enum('wild card')
+wild_card = SpyAlleyApplication::Models::WildCard::new
+
+SpyAlleyApplication::Types::WildCard =
+  Types::Constructor(SpyAlleyApplication::Models::WildCard) do |value|
+    wild_card_enum.call(value)
+    wild_card
+  end
+

data/lib/spy_alley_application/validator/builder.rb

@@ -0,0 +1,119 @@
+# frozen string literal: true
+
+require 'dry-initializer'
+require 'spy_alley_application/types/validation_builder'
+
+module SpyAlleyApplication
+  module Validator
+    class Builder
+      include Dry::Initializer.define -> do
+        option :process_next_turn_options, type: ::Types::Callable, reader: :private
+        option :change_orders_initializer, type: ::Types::Callable, reader: :private
+        option :wrap_result, type: ::Types::Hash
+      end
+
+      def call(game_board:, last_action_id:)
+        current_player = game_board.current_player
+        change_orders = change_orders_initializer.()
+        options = {}
+        change_orders = process_next_turn_options.(
+          game_board: game_board,
+          change_orders: change_orders)
+
+        change_orders.changes.each do |option_node| 
+          options = option_node.accept(self, options: options)
+        end
+
+        next_player_id = options[:next_player_id]
+        options = options.reject{|k, v| k.eql?(:next_player_id)}
+        
+        validate_player_action_and_user = GameValidator::Validator::Base::new(
+          legal_options: options.values.map{|o| o[:name]},
+          current_player_id: next_player_id,
+          last_action_id: last_action_id)
+
+        fv = {}
+        options.each do |k, v|
+          builder = SpyAlleyApplication::Types::ValidationBuilder.call(v)
+          fv[[v[:name], true]] = builder.build(admin?: true)
+          fv[[v[:name], false]] = builder.build(admin?: false)
+        end
+
+        GameValidator::Validator::new(
+          validate_player_action_and_user: validate_player_action_and_user,
+          full_validator_for: fv)
+      end
+
+      def handle_buy_equipment_option(option_node, options:)
+        options[:buy_equipment] = {
+          name: 'buy_equipment',
+          options: option_node.options,
+          limit: option_node.limit,
+          wrap_result: wrap_result[:buy_equipment]}
+        options
+      end
+
+      def handle_choose_new_spy_identity_option(option_node, options:)
+        options[:choose_new_spy_identity] = {
+          name: 'choose_new_spy_identity',
+          options: option_node.options,
+          wrap_result: wrap_result[:choose_new_spy_identity]}
+        options
+      end
+
+      def handle_confiscate_materials_option(option_node, options:)
+        options[:confiscate_materials] ||= {
+          name: 'confiscate_materials',
+          wrap_result: wrap_result[:confiscate_materials]}
+        options[:confiscate_materials][:target_player] = {
+          target_player_id: option_node.target_player_id,
+          targetable_equipment: option_node.targetable_equipment}
+        options
+      end
+
+      def handle_make_accusation_option(option_node, options:)
+        options[:make_accusation] = {
+          name: 'make_accusation',
+          player_id_list: option_node.player_id_list,
+          wrap_result: wrap_result[:make_accusation]}
+        options
+      end
+
+      def handle_move_option(option_node, options:)
+        options[:move] = {
+          name: 'move',
+          options: option_node.options,
+          wrap_result: wrap_result[:move]}
+        options
+      end
+
+      def handle_next_player(option_node, options:)
+        options[:next_player_id] = option_node.player_id
+        options
+      end
+
+      def handle_pass_option(option_node, options:)
+        options[:pass] = {
+          name: 'pass',
+          wrap_result: wrap_result[:pass]}
+        options
+      end
+ 
+      def handle_roll_die_option(option_node, options:)
+        options[:roll_die] = {
+          name: 'roll_die',
+          wrap_result: wrap_result[:roll_die]}
+        options
+      end
+
+      def handle_use_move_card(option_node, options:)
+        options[:use_move_card] = {
+          name: 'use_move_card',
+          card_list: option_node.card_list,
+          wrap_result: wrap_result[:use_move_card]}
+        options
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/validator/buy_equipment.rb

@@ -0,0 +1,39 @@
+# frozen string literal: true
+
+require 'dry-validation'
+require 'spy_alley_application/types/array_of_equipment'
+require 'spy_alley_application/types/coercible_integer_one_to_six'
+
+module SpyAlleyApplication
+  module Validator
+    class BuyEquipment < Dry::Validation::Contract
+      t = SpyAlleyApplication::Types
+      @@equipment_regex =
+        /\A(#{t::Nationality.values.join('|')}) (#{t::EquipmentType.values.join('|')})\z/
+
+      option :options, type: SpyAlleyApplication::Types::ArrayOfEquipment
+      option :limit, type: SpyAlleyApplication::Types::CoercibleIntegerOneToSix
+
+      params do
+        required(:equipment_to_buy)
+          .filled(::Types::Array::of(::Types::String.constrained(format: @@equipment_regex)))
+      end
+
+      rule(:equipment_to_buy) do
+        opts = options.map(&:to_s)
+        if !values[:equipment_to_buy].all?{|e| opts.include?(e)}
+          key.failure({text: "non allowable equipment is included", status: 422})
+        end
+
+        if !values[:equipment_to_buy].uniq.size.eql?(values[:equipment_to_buy].size)
+          key.failure({text: 'all equipment bought must be distinct', status: 400})
+        end
+
+        if values[:equipment_to_buy].size > limit
+          key.failure({text: "buying too many items, limit is #{limit}", status: 400})
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/validator/choose_new_spy_identity.rb

@@ -0,0 +1,24 @@
+# frozen string literal: true
+
+require 'dry-validation'
+require 'spy_alley_application/types/nationality'
+
+module SpyAlleyApplication
+  module Validator
+    class ChooseNewSpyIdentity < Dry::Validation::Contract
+      option :options, type: ::Types::Array::of(SpyAlleyApplication::Types::Nationality)
+        .constrained(size: 2)
+
+      params do
+        required(:nationality).filled(SpyAlleyApplication::Types::Nationality)
+      end
+
+      rule(:nationality) do
+        if !options.include?(values[:nationality])
+          key.failure({text: "'#{values[:nationality]}' not allowable", status: 422})
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/validator/confiscate_materials.rb

@@ -0,0 +1,22 @@
+# frozen string literal: true
+
+require 'dry-initializer'
+
+module SpyAlleyApplication
+  module Validator
+    class ConfiscateMaterials
+      include Dry::Initializer.define -> do
+        option :validate_target_player_id, type: ::Types::Callable
+        option :full_validator_for, type: ::Types::Hash
+      end
+
+      def call(action_hash)
+        result = validate_target_player_id.(action_hash)
+        return result if result.failure?
+        validate = full_validator_for[result[:target_player_id]]
+        validate.(action_hash)
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/validator/confiscate_materials/full_validator.rb

@@ -0,0 +1,39 @@
+# frozen string literal: true
+
+require 'dry-validation'
+require 'spy_alley_application/types/array_of_equipment'
+
+module SpyAlleyApplication
+  module Validator
+    class ConfiscateMaterials
+      class FullValidator < Dry::Validation::Contract
+        t = SpyAlleyApplication::Types
+        @@equipment_regex =
+          /\A(#{t::Nationality.values.join('|')}) (#{t::EquipmentType.values.join('|')})\z/
+
+        option :target_player_id, type: ::Types::Coercible::Integer
+        option :targetable_equipment, type: SpyAlleyApplication::Types::ArrayOfEquipment
+
+        params do
+          required(:target_player_id).filled(::Types::Coercible::Integer)
+          required(:equipment_to_confiscate)
+            .filled(::Types::String.constrained(format: @@equipment_regex))
+        end
+
+        rule(:target_player_id) do
+          if !target_player_id.eql?(values[:target_player_id])
+            key.failure({text: "'#{values[:target_player_id]}' not allowable", status: 422})
+          end
+        end
+
+        rule(:equipment_to_confiscate) do
+          opts = targetable_equipment.map(&:to_s)
+          if !opts.include?(values[:equipment_to_confiscate])
+            key.failure({text: "'#{values[:equipment_to_confiscate]}' not allowable", status: 422})
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/spy_alley_application/validator/confiscate_materials/validate_target_player_id.rb

@@ -0,0 +1,24 @@
+require 'dry-initializer'
+require 'spy_alley_application/types/nationality'
+require 'spy_alley_application/validator/make_accusation'
+
+module SpyAlleyApplication
+  module Validator
+    class ConfiscateMaterials
+      class ValidateTargetPlayerId < Dry::Validation::Contract
+        option :target_player_id_list, type: ::Types::ArrayOfStrictInteger
+        
+        params do
+          required(:target_player_id).filled(::Types::Coercible::Integer)
+        end
+
+        rule(:target_player_id) do
+          if !target_player_id_list.include?(values[:target_player_id])
+            key.failure({text: "'#{values[:target_player_id]}' not allowable", status: 422})
+          end
+        end
+      end
+    end
+  end
+end
+