codebreaker_vk 0.3.1 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08ab1117ccd9224ff33761dce7aa30a1cd572e67001b7e58b9499b9c3af850b5'
-  data.tar.gz: 90ffb5d6bbe399a0a762b6828bd202496818871d714dff4a6716d95e15280163
+  metadata.gz: ce6a637c137f2f28c5b4abb77c15dea5b45e9fc642a33a9f7e9cf4e811962df5
+  data.tar.gz: e0f628cce3aa5f7d64ec3f65e8971c5890e573fcb1e3c212bb02e544c74c789c
 SHA512:
-  metadata.gz: 3ca02359a5f01b2cafbb9e9ce3b1724dbe1a0014b994a9e81f931961089e2c188d7f3e2c4ee4cbdc3772f4e09938d59ea7ea1b4e377281e14156280d88450713
-  data.tar.gz: 92b9a4df7cc29020a358499c560b3a427f4a07ca07eb2178acc3ebc2497dd1d4005bcda269d5b3e0faea8a9a26ebd0125ede18aaf8bf6ca9a8aeb74fbf5d0267
+  metadata.gz: 03ed7c6c1f1e7030416eeed769a1f36c30766b09246549095f89d53963c7a616dcfb52dfc0812aec5e023516f11c68e694b6eba41051a2ebb595a9ef7a2836c1
+  data.tar.gz: 124cd40776dfe7f387794d4eadb5b24a5072da6b57c73a83e8010cd5668798ed4ebb2d09ded52bcb161ca23db7788fd8aa80d5f5ea8d8935df9901aa248bca6f

data/.overcommit.yml

@@ -37,7 +37,7 @@ PreCommit:
     enabled: true
 
   BundleAudit:
-    enabled: true
+    enabled: false
 
   RSpec:
     enabled: true

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    codebreaker_vk (0.3.1)
+    codebreaker_vk (1.0.1)
 
 GEM
   remote: https://rubygems.org/

data/autoload.rb

@@ -3,14 +3,14 @@
 require 'i18n'
 require 'yaml'
 require_relative 'config/i18n'
-require_relative 'lib/codebreaker_vk/uploader/uploader'
-require_relative 'lib/codebreaker_vk/validate/validate'
-require_relative 'lib/codebreaker_vk/validating_data'
-require_relative 'lib/codebreaker_vk/check_errors'
-require_relative 'lib/codebreaker_vk/difficulty'
+
+require_relative 'lib/codebreaker_vk/validation'
+require_relative 'lib/codebreaker_vk/output'
+require_relative 'lib/codebreaker_vk/database'
 require_relative 'lib/codebreaker_vk/game'
-require_relative 'lib/codebreaker_vk/console'
-require_relative 'lib/codebreaker_vk/game_user'
-require_relative 'lib/codebreaker_vk/game_messages'
-require_relative 'lib/codebreaker_vk/game_process'
+require_relative 'lib/codebreaker_vk/game_console'
+require_relative 'lib/codebreaker_vk/game_menu'
+require_relative 'lib/codebreaker_vk/table_data'
+
+
 require_relative 'lib/codebreaker_vk/version'

data/config/locales/en.yml

@@ -1,41 +1,38 @@
 en:
-  goodbye: 'Goodbye'
-  console:
-    greeting: "Hello, lets play the 'Codebreaker' game"
-    choose_the_command: "Choose the command\n
-      -Enter %{rules} if you want to see rules of the game\n
-      -Enter %{stats} if you want to see the statistics of users results\n
-      -Enter %{start} if you want to start the game\n
-      -Enter %{exit} if you want to quite the game\n"
-    what_name: "What is your name?\nName must be from 3 to 20 characters"
-    showed_hint: 'Code contains this number: %{showed}'
-    zero_hints: "You don't have any hints"
-    result: 'Your result is %{result}'
-    make_guess: "Make your guess\nYou need to enter four numbers between 1 and 6 "
-    enter_hint: "Or enter 'hint' to open one digit from code"
-    left_attempts_and_hints: "You have %{attempts} attempts and %{hints} hints"
-    win: "You win\n-Enter %{yes} if you want to save your progress"
-    lose: 'Game over, you lose if you want you can start a new game'
-    empty_db: 'You are the first one'
-    select_difficulty: 'Select difficulty: %{difficulties}'
-    stats_user_info: "%{position}) Name: %{name} difficulty: %{level}\n"
-    stats_lefts: "Attempts: %{all_attempts}/%{attempts} Hints: %{all_hints}/%{hints}"
-    rules: "Game Rules\n
-      • Codebreaker is a logic game in which a code-breaker tries to break a secret code created by a code-maker. The codemaker, which will be played by the codebreaker_vk we’re going to write, creates a secret code of four numbers between 1 and 6.\n
-      • The codebreaker gets some number of chances to break the code (depends on chosen difficulty). In each turn, the codebreaker makes a guess of 4 numbers. The codemaker then marks the guess with up to 4 signs - + or - or empty spaces.\n
-      • A + indicates an exact match - one of the numbers in the guess is the same as one of the numbers in the secret code and in the same position. For example\n
-        Secret number - 1234\n
-        Input number - 6264\n
-        Number of pluses - 2 (second and fourth position)\n
-      • A - indicates a number match - one of the numbers in the guess is the same as one of the numbers in the secret code but in a different position. For example\n
-        Secret number - 1234\n
-        Input number - 6462\n
-        Number of minuses - 2 (second and fourth position)\n
-      • An empty space indicates that there is not a current digit in a secret number.\n
-      • If codebreaker inputs the exact number as a secret number - codebreaker wins the game. If all attempts are spent - codebreaker loses.\n
-      • Codebreaker also has some number of hints(depends on chosen difficulty). If a user takes a hint - he receives back a separate digit of the secret code.\n"
-  error: "Unexpected input, it was '%{error}', try one more time"
-  invalid:
-    cover_error: 'Improper size'
-    include_error: 'Not include in propose inputs'
-    size_error: 'Invalid size'
+  greeting: "Welcome to codebreaker!\n"
+  goodbye: "Goodbye!\n"
+  rules: "GAME RULES\n
+          # Codebreaker is a logic game in which a code-breaker tries to break a secret code created by a code-maker. The\n codemaker, which will be played by the application we’re going to write, creates a secret code of four numbers between\n 1 and 6.\n
+          # The codebreaker gets some number of chances to break the code (depends on chosen difficulty). In each turn, the\n codebreaker makes a guess of 4 numbers. The codemaker then marks the guess with up to 4 signs - + or - or empty\n spaces.\n
+          # A + indicates an exact match: one of the numbers in the guess is the same as one of the numbers in the secret code\n and in the same position. For example:\n
+          Secret number - 1234\n
+          Input number - 6264\n
+          Number of pluses - 2 (second and fourth position)\n
+          # A - indicates a number match: one of the numbers in the guess is the same as one of the numbers in the secret code\n but in a different position. For example:\n
+          Secret number - 1234\n
+          Input number - 6462\n
+          Number of minuses - 2 (second and fourth position)\n
+          # An empty space indicates that there is not a current digit in a secret number.\n
+          # If codebreaker inputs the exact number as a secret number - codebreaker wins the game. If all attempts are spent -\n codebreaker loses.\n
+          # Codebreaker also has some number of hints(depends on chosen difficulty). If a user takes a hint - he receives back a\n
+          separate digit of the secret code.\n"
+  menu: "Choose one of next scenarios: 'start', 'rules', 'stats', 'exit'"
+  choose_difficulty: "Choose difficulty: easy, medium, hell"
+  choose_name: "Choose your name"
+  win: "Congratulations! You win!"
+  lose: "Sorry, you lose. Maybe another time."
+  wrong_difficulty: "There is no such difficulty. Please choose one from listed"
+  wrong_input: "wrong input"
+  wrong_name: "Choosen name is invalid. Name must be between 3 and 20 characters.\nPlease choose another one"
+  wrong_process: "There is no such command or your number is invalid. You can try use hint or exit"
+  wrong_run: "You have passed unexpected command. Please choose one from listed commands"
+  easy: "easy"
+  medium: "medium"
+  hell: "hell"
+  no_hints: "You have no hints"
+  game_process: "%{attempts} attempts and %{hints} hints left. Guess a secret code"
+  secret: "The secret code was %{secret}"
+  save: "Print 'save' if you want to save your result: "
+  game_over: 'Game Over'
+  stats: "Player %{name} played with difficulty level %{difficulty} (%{attempts_total} attempts, %{hints_total} hints) and won with %{attempts_used} attempts and %{hints_used} hints used."
+  no_stats: "Sorry, you have not any saves yet."

data/database.yaml

@@ -0,0 +1,8 @@
+---
+- !ruby/object:CodebreakerVk::TableData
+  name: trtr
+  difficulty: :easy
+  attempts_total: 15
+  attempts_used: 11
+  hints_total: 3
+  hints_used: 3

data/lib/codebreaker_vk/database.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module CodebreakerVk
+  module Database
+    SEED = 'database.yaml'
+
+    def load(path = SEED)
+      YAML.load_file(path)
+    end
+
+    def save(summary, path = SEED)
+      row = TableData.new(summary)
+      if File.exist?(path)
+        table = load(path)
+        table << row
+        File.write(path, table.to_yaml)
+      else
+        File.write(path, [row].to_yaml)
+      end
+    end
+
+    def save_results
+      attempts_total = Game::DIFFICULTY_LEVEL[@game.difficulty][:attempts]
+      hints_total = Game::DIFFICULTY_LEVEL[@game.difficulty][:hints]
+      summary = {
+        name: @game.name,
+        difficulty: @game.difficulty,
+        attempts_total: attempts_total,
+        attempts_used: attempts_total - @game.attempts,
+        hints_total: hints_total,
+        hints_used: hints_total - @game.hints
+      }
+      save(summary)
+    end
+  end
+end

data/lib/codebreaker_vk/game.rb

@@ -2,81 +2,74 @@
 
 module CodebreakerVk
   class Game
-    attr_reader :hints, :attempts, :difficulty, :breaker_numbers, :showed_hints, :player_name
-
-    INCLUDE_IN_GAME_NUMBERS = (1..6).freeze
-    CODE_SIZE = 4
-
-    GUESS_PLACE = '+'
-    GUESS_PRESENCE = '-'
-
-    def initialize(difficulty, user)
-      @breaker_numbers = generate_random_code
-      @breaker_numbers_copy = @breaker_numbers.clone.shuffle
-      @hints = difficulty.level[:hints]
-      @attempts = difficulty.level[:attempts]
-      @difficulty = difficulty.level
-      @player_name = user.name
-      @showed_hints = []
+    include Output
+    SECRET_CODE_LENGTH = 4
+    RANGE_START = 1
+    RANGE_END = 6
+    NOT_YET = '-'
+    GOT_IT = '+'
+    DIFFICULTY_LEVEL = {
+        easy: { attempts: 15, hints: 3 },
+        medium: { attempts: 10, hints: 2 },
+        hell: { attempts: 5, hints: 1 }
+    }.freeze
+
+    attr_accessor :attempts_total, :attempts, :difficulty, :hints_total, :hints, :name, :secret
+
+    def initialize(name:, difficulty:)
+      @name = name
+      @difficulty = difficulty
+      @attempts = DIFFICULTY_LEVEL[difficulty][:attempts]
+      @hints = DIFFICULTY_LEVEL[difficulty][:hints]
+      @secret = make_number
+      @unused_hints = @secret.chars
     end
 
-    def start_round(user_input)
-      @attempts -= 1
-      @game_numbers = { code: @breaker_numbers.clone, input: user_input }
-      collect_place_guess + collect_presence_guess
+    def make_number(numbers = RANGE_END)
+      (1..SECRET_CODE_LENGTH).map { rand(RANGE_START..numbers) }.join
     end
 
-    def hint
-      return if @hints.zero?
-
-      @hints -= 1
-      @showed_hints << @breaker_numbers_copy.pop
-      @showed_hints.last
+    def check(number)
+      @attempts -= 1
+      @last_result = check_numbers(@secret.chars, number.chars)
     end
 
-    def win?(result)
-      @breaker_numbers == result
+    def win?
+      @last_result == GOT_IT * SECRET_CODE_LENGTH
     end
 
-    def lose?(result)
-      @attempts == 1 && @breaker_numbers != result
-    end
+    def use_hint
+      return I18n.t(:no_hints) unless @hints.positive?
 
-    def to_h
-      {
-        player_name: @player_name,
-        level: @difficulty[:level],
-        all_hints: @difficulty[:hints],
-        all_attempts: @difficulty[:attempts],
-        left_hints: @hints,
-        left_attempts: @attempts,
-        date: Time.now
-      }
+      @hints -= 1
+      hint(@unused_hints)
     end
 
     private
 
-    def collect_place_guess
-      @game_numbers[:input].map.with_index do |user_num, index|
-        next if @game_numbers[:code][index] != user_num
+    def check_numbers(secret, numbers)
+      exact_matches, non_exact_matches = secret.zip(numbers).partition do |secret_number, input_number|
+        secret_number == input_number
+      end
+
+      result = Array.new(exact_matches.count, GOT_IT)
+
+      find_non_exact_matches(result, non_exact_matches) if non_exact_matches.any?
 
-        @game_numbers[:code][index] = nil
-        @game_numbers[:input][index] = nil
-        GUESS_PLACE
-      end.compact
+      result.join
     end
 
-    def collect_presence_guess
-      @game_numbers[:input].compact.map do |user_num|
-        next unless @game_numbers[:code].include?(user_num)
+    def find_non_exact_matches(result, non_exact_matches)
+      secret, numbers = non_exact_matches.transpose
+      numbers.each do |number_element|
+        next unless secret.include? number_element
 
-        @game_numbers[:code].delete_at(@game_numbers[:code].index(user_num))
-        GUESS_PRESENCE
-      end.compact
+        result.push(NOT_YET) && secret.delete_at(secret.index(number_element))
+      end
     end
 
-    def generate_random_code
-      Array.new(CODE_SIZE) { rand(INCLUDE_IN_GAME_NUMBERS) }
+    def hint(secret)
+      secret.shuffle.pop
     end
   end
 end

data/lib/codebreaker_vk/game_console.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module CodebreakerVk
+  class GameConsole
+    include Validation
+    include Database
+    include Output
+
+    HINT = 'hint'
+    SAVE = 'save'
+    INPUT_DATA = /^[1-6]{4}$/.freeze
+
+    def initialize(name, difficulty)
+      @game = Game.new(name: name, difficulty: difficulty)
+    end
+
+    def start
+      loop do
+        break if @game.attempts.zero? || @game.win?
+
+        start_info(@game.attempts, @game.hints)
+        input = gets.chomp
+        case input
+        when GameMenu::EXIT then break close
+        when HINT then next puts @game.use_hint
+        when INPUT_DATA then puts @game.check(input)
+        else puts I18n.t(:wrong_process)
+        end
+      end
+      puts I18n.t(:game_over)
+      statistics
+    end
+
+    def statistics
+      summary_info(@game.secret)
+      end_game
+    end
+
+    def end_game
+      if @game.win?
+        puts I18n.t(:win)
+        puts I18n.t(:save)
+        save_results if gets.chomp == SAVE
+      else
+        puts I18n.t(:lose)
+      end
+    end
+
+    def close
+      puts I18n.t(:goodbye)
+      exit
+    end
+  end
+end

data/lib/codebreaker_vk/game_menu.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'database'
+
+module CodebreakerVk
+  class GameMenu
+    extend Validation
+    extend Database
+    extend Output
+
+    START = 'start'
+    RULES = 'rules'
+    STATISTICS = 'stats'
+    EXIT = 'exit'
+
+    class << self
+      def welcome
+        puts I18n.t(:greeting)
+        run
+      end
+
+      def run
+        loop do
+          puts I18n.t(:menu)
+          case gets.chomp
+          when START then break registration
+          when RULES then rules
+          when STATISTICS then stats
+          when EXIT then break close
+          else puts I18n.t(:wrong_run)
+          end
+        end
+      end
+
+      def registration
+        GameConsole.new(choose_name, choose_difficulty).start
+        welcome
+      end
+
+      def choose_name
+        loop do
+          puts I18n.t(:choose_name)
+          name = gets.chomp
+          break close if name == EXIT
+          break name if valid_string_length?(name)
+
+          puts I18n.t(:wrong_name)
+        end
+      end
+
+      def choose_difficulty
+        loop do
+          puts I18n.t(:choose_difficulty)
+          input = gets.chomp
+          break close if input == EXIT
+          break input.to_sym if Game::DIFFICULTY_LEVEL.keys.include? input.to_sym
+
+          puts I18n.t(:wrong_difficulty)
+        end
+      end
+
+      def stats
+        return puts I18n.t(:no_stats) unless File.exist?('./seed.yaml')
+
+        table = load.sort_by { |row| [row.hints_total, row.attempts_used] }
+        table.each { |row| row.difficulty = Game::DIFFICULTY_LEVEL.key([row.attempts_total, row.hints_total]) }
+        puts table
+      end
+
+      def close
+        puts I18n.t(:goodbye)
+        exit
+      end
+    end
+  end
+end

data/lib/codebreaker_vk/output.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CodebreakerVk
+  module Output
+    def start_info(attempts, hints)
+      puts I18n.t(:game_process, attempts: attempts, hints: hints)
+    end
+
+    def summary_info(secret)
+      puts I18n.t(:secret, secret: secret)
+    end
+
+    def rules
+      puts I18n.t(:rules)
+    end
+  end
+end

data/lib/codebreaker_vk/table_data.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module CodebreakerVk
+  class TableData
+    attr_accessor :name, :difficulty, :attempts_total, :attempts_used, :hints_total, :hints_used
+
+    def initialize(name:, difficulty:, attempts_total:, attempts_used:, hints_total:, hints_used:)
+      @name = name
+      @difficulty = difficulty
+      @attempts_total = attempts_total
+      @attempts_used = attempts_used
+      @hints_total = hints_total
+      @hints_used = hints_used
+    end
+
+    def to_s
+      I18n.t(:stats,
+             name: @name,
+             difficulty: @difficulty,
+             attempts_total: @attempts_total,
+             attempts_used: @attempts_used,
+             hints_total: @hints_total,
+             hints_used: @hints_used)
+    end
+  end
+end

data/lib/codebreaker_vk/validation.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module CodebreakerVk
+  module Validation
+    MIN_LETTERS = 3
+    MAX_LETTERS = 20
+
+    def valid_string_length?(name, min = MIN_LETTERS, max = MAX_LETTERS)
+      name.is_a?(String) && name.length.between?(min, max)
+    end
+  end
+end

data/lib/codebreaker_vk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CodebreakerVk
-  VERSION = '0.3.1'
+  VERSION = '1.0.1'
 end

data/main.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'autoload'
+
+CodebreakerVk::GameMenu.run

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: codebreaker_vk
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.0.1
 platform: ruby
 authors:
 - VKuzmich
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-07 00:00:00.000000000 Z
+date: 2019-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -181,18 +181,17 @@ files:
 - codebreaker_vk.gemspec
 - config/i18n.rb
 - config/locales/en.yml
+- database.yaml
 - lib/codebreaker_vk.rb
-- lib/codebreaker_vk/check_errors.rb
-- lib/codebreaker_vk/console.rb
-- lib/codebreaker_vk/difficulty.rb
+- lib/codebreaker_vk/database.rb
 - lib/codebreaker_vk/game.rb
-- lib/codebreaker_vk/game_messages.rb
-- lib/codebreaker_vk/game_process.rb
-- lib/codebreaker_vk/game_user.rb
-- lib/codebreaker_vk/uploader/uploader.rb
-- lib/codebreaker_vk/validate/validate.rb
-- lib/codebreaker_vk/validating_data.rb
+- lib/codebreaker_vk/game_console.rb
+- lib/codebreaker_vk/game_menu.rb
+- lib/codebreaker_vk/output.rb
+- lib/codebreaker_vk/table_data.rb
+- lib/codebreaker_vk/validation.rb
 - lib/codebreaker_vk/version.rb
+- main.rb
 homepage: https://github.com/VKuzmich/codebreaker_vk
 licenses:
 - MIT

data/lib/codebreaker_vk/check_errors.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module CodebreakerVk
-  class CheckErrors < ValidatingData
-    attr_reader :input, :errors
-
-    def initialize(input)
-      super()
-      @input = input
-    end
-
-    def validate
-      @errors << I18n.t('invalid.include_error') unless check_include?(@input, Console::COMMANDS.values)
-    end
-  end
-end

data/lib/codebreaker_vk/console.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module CodebreakerVk
-  class Console < ValidatingData
-    include Uploader
-
-    ACCEPT_SAVING_RESULT = 'yes'
-    COMMANDS = { rules: 'rules',
-                 start: 'start',
-                 stats: 'stats',
-                 exit: 'exit' }.freeze
-
-    def greeting
-      Representer.greeting_msg
-    end
-
-    def main_menu
-      loop do
-        Representer.what_next_text
-        case make_valid_input_for_class(Navigator).input
-        when COMMANDS[:start] then return registration
-        when COMMANDS[:rules] then Representer.show_rules
-        when COMMANDS[:stats] then statistics
-        end
-      end
-    end
-
-    private
-
-    def statistics
-      loaded_db = load_db
-      loaded_db.empty? ? Representer.empty_db_msg : Representer.show_db(loaded_db)
-    end
-
-    def registration
-      Representer.what_name_msg
-      @user = make_valid_input_for_class(User)
-      @difficulty = choose_difficulty
-      @game = Game.new(@difficulty, @user)
-      make_guess
-    end
-
-    def choose_difficulty
-      Representer.select_difficulty_msg
-      loop do
-        finded_level = Difficulty.find(user_input)
-        return finded_level if finded_level
-
-        Representer.error_msg(I18n.t('invalid.include_error'))
-      end
-    end
-
-    def make_guess
-      loop do
-        Representer.make_guess_msg
-        guess = make_valid_input_for_class(Guess)
-        guess.hint? ? show_hint : check_round_result(guess.as_array_of_numbers)
-      end
-    end
-
-    def check_round_result(guess)
-      return win if @game.win?(guess)
-      return lose if @game.lose?(guess)
-
-      round_result = @game.start_round(guess)
-      Representer.round_info_text(round_result, @game.attempts, @game.hints)
-    end
-
-    def show_hint
-      @game.hints.positive? ? Representer.showed_hint_msg(@game.hint) : Representer.zero_hints_msg
-    end
-
-    def lose
-      Representer.lose_msg
-      start_new_game
-    end
-
-    def win
-      Representer.win_msg
-      save_result if user_input == ACCEPT_SAVING_RESULT
-      start_new_game
-    end
-
-    def start_new_game
-      Console.new.main_menu
-    end
-
-    def save_result
-      save_to_db(@game.to_h)
-    end
-
-    def make_valid_input_for_class(klass)
-      loop do
-        input = klass.new(user_input)
-        return input if input.valid?
-
-        Representer.error_msg(input.errors.join(', '))
-      end
-    end
-
-    def user_input
-      input = gets.chomp.downcase
-      input == COMMANDS[:exit] ? exit_console : input
-    end
-
-    def exit_console
-      Representer.goodbye
-      exit
-    end
-  end
-end

data/lib/codebreaker_vk/difficulty.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module CodebreakerVk
-  class Difficulty
-    attr_reader :level
-
-    DIFFICULTIES = {
-      simple: {
-        hints: 2,
-        attempts: 15,
-        level: 'simple'
-      },
-
-      middle: {
-        hints: 1,
-        attempts: 10,
-        level: 'middle'
-      },
-
-      hard: {
-        hints: 1,
-        attempts: 5,
-        level: 'hard'
-      }
-    }.freeze
-
-    def initialize(input)
-      @level = DIFFICULTIES[input]
-    end
-
-    def self.find(input)
-      input_as_key = input.to_sym
-      return unless DIFFICULTIES.key?(input_as_key)
-
-      new(input_as_key)
-    end
-  end
-end

data/lib/codebreaker_vk/game_messages.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module CodebreakerVk
-  class GameMessages
-    class << self
-      def greeting_msg
-        puts I18n.t('console.greeting')
-      end
-
-      def goodbye
-        puts I18n.t(:goodbye)
-      end
-
-      def what_next_text
-        puts I18n.t('console.choose_the_command', stats: Console::COMMANDS[:stats], rules: Console::COMMANDS[:rules],
-                    start: Console::COMMANDS[:start], exit: Console::COMMANDS[:exit])
-      end
-
-      def what_name_msg
-        puts I18n.t('console.what_name')
-      end
-
-      def select_difficulty_msg
-        puts I18n.t('console.select_difficulty', difficulties: Difficulty::DIFFICULTIES.keys.join(', '))
-      end
-
-      def make_guess_msg
-        puts I18n.t('console.make_guess')
-      end
-
-      def showed_hint_msg(showed)
-        puts I18n.t('console.showed_hint', showed: showed)
-      end
-
-      def zero_hints_msg
-        puts I18n.t('console.zero_hints')
-      end
-
-      def round_info_text(result, attempts, hints)
-        puts I18n.t('console.result', result: result)
-        puts I18n.t('console.left_attempts_and_hints', attempts: attempts, hints: hints)
-        puts I18n.t('console.make_guess')
-        puts I18n.t('console.enter_hint') if hints.positive?
-      end
-
-      def win_msg
-        puts I18n.t('console.win', yes: Console::ACCEPT_SAVING_RESULT)
-      end
-
-      def lose_msg
-        puts I18n.t('console.lose')
-      end
-
-      def empty_db_msg
-        puts I18n.t('console.empty_db')
-      end
-
-      def show_db(loaded_db)
-        sort_db(loaded_db).each_with_index do |user, index|
-          puts I18n.t('console.stats_user_info', position: index + 1, name: user[:name], level: user[:level])
-          puts I18n.t('console.stats_lefts', attempts: user[:left_attempts], all_attempts: user[:all_attempts],
-                      hints: user[:left_hints], all_hints: user[:all_hints])
-        end
-      end
-
-      def show_rules
-        puts I18n.t('console.rules')
-      end
-
-      def error_msg(error)
-        puts I18n.t('error', error: error)
-      end
-
-      def sort_db(loaded_db)
-        loaded_db.sort_by { |user| [user[:all_attempts], -user[:left_attempts], -user[:left_hints]] }
-      end
-    end
-  end
-end

data/lib/codebreaker_vk/game_process.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'difficulty'
-
-module CodebreakerVk
-  class GameProcess < ValidatingData
-    attr_reader :input, :errors
-
-    HINT = 'hint'
-
-    def initialize(input)
-      super()
-      @input = input
-    end
-
-    def validate
-      return if hint?
-
-      @errors << I18n.t('invalid.include_error') unless check_numbers?(@input, valid_numbers)
-      @errors << I18n.t('invalid.size_error') unless check_size?(@input, Game::CODE_SIZE)
-    end
-
-    def as_array_of_numbers
-      @as_array_of_numbers ||= @input.chars.map(&:to_i)
-    end
-
-    def hint?
-      @input == HINT
-    end
-
-    private
-
-    def valid_numbers
-      Game::INCLUDE_IN_GAME_NUMBERS.map(&:to_s)
-    end
-  end
-end

data/lib/codebreaker_vk/game_user.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module CodebreakerVk
-  class GameUser < ValidatingData
-    attr_reader :name, :errors
-
-    VALID_NAME_SIZE = (3..20).freeze
-
-    def initialize(name)
-      super()
-      @name = name
-    end
-
-    def validate
-      @errors << I18n.t('invalid.cover_error') unless check_cover?(@name, VALID_NAME_SIZE)
-    end
-  end
-end

data/lib/codebreaker_vk/uploader/uploader.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module CodebreakerVk
-  module Uploader
-    PATH_FOLDER = './data_base/'
-    PATH_NAME = 'database'
-    PATH_FORMAT = '.yaml'
-    PATH = PATH_FOLDER + PATH_NAME + PATH_FORMAT
-
-    def load_db
-      File.exist?(PATH) ? YAML.load_stream(File.open(PATH)) : []
-    end
-
-    def save_to_db(results)
-      File.open(PATH, 'a') { |f| f.write results.to_yaml }
-    end
-  end
-end

data/lib/codebreaker_vk/validate/validate.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module CodebreakerVk
-  module Validate
-    def check_cover?(cheackable, valid_numbers)
-      valid_numbers.cover?(cheackable.size)
-    end
-
-    def check_include?(cheackable, valid_collection)
-      valid_collection.include?(cheackable)
-    end
-
-    def check_size?(cheackable, valid_size)
-      cheackable.size == valid_size
-    end
-
-    def check_numbers?(cheackable, valid_numbers)
-      cheackable.each_char.all? { |guess_char| valid_numbers.include?(guess_char) }
-    end
-  end
-end

data/lib/codebreaker_vk/validating_data.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module CodebreakerVk
-  class ValidatingData
-    include Validate
-
-    def initialize
-      @errors = []
-    end
-
-    def validate
-      raise NotImplementedError
-    end
-
-    def valid?
-      validate
-      @errors.empty?
-    end
-  end
-end