codebreaker_vk 0.2.3 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0179c213f936b2afec4c93eb28fbf42aea7d4d5a6e8d111b80add0a2ca25d5b7'
-  data.tar.gz: 7d060ce7f860e3ef1f519eaaea55a420a0415406465bb461ca7496366d46556b
+  metadata.gz: '08ab1117ccd9224ff33761dce7aa30a1cd572e67001b7e58b9499b9c3af850b5'
+  data.tar.gz: 90ffb5d6bbe399a0a762b6828bd202496818871d714dff4a6716d95e15280163
 SHA512:
-  metadata.gz: 44c4e80ab609b6256897557712833a27f1cd55f8c7dd6eb91986f16a91cd9216767bb3f3c73c1ac2f274ef838328d84bb7c037a2355ebeaf8aea2f64d8ae6624
-  data.tar.gz: 5f2c7a0ddf0092736cc2fd85c2b5e7a67ab20846b7f820058bc956751780e9546fd25bb388418c3ee39480d37bbe80a311e3db204bd32a1b8f676cf5cae74d90
+  metadata.gz: 3ca02359a5f01b2cafbb9e9ce3b1724dbe1a0014b994a9e81f931961089e2c188d7f3e2c4ee4cbdc3772f4e09938d59ea7ea1b4e377281e14156280d88450713
+  data.tar.gz: 92b9a4df7cc29020a358499c560b3a427f4a07ca07eb2178acc3ebc2497dd1d4005bcda269d5b3e0faea8a9a26ebd0125ede18aaf8bf6ca9a8aeb74fbf5d0267

data/.overcommit.yml

@@ -43,14 +43,16 @@ PreCommit:
     enabled: true
 
   BundleOutdated:
-    enabled: true
+    enabled: false
 
   ExecutePermissions:
     enabled: false
 
   ForbiddenBranches:
-    enabled: true
+    enabled: false
     branch_patterns: ['master']
 
   LineEndings:
-    enabled: true
+    enabled: false
+
+

data/.rubocop.yml

@@ -0,0 +1,10 @@
+equire: rubocop-rspec
+
+Metrics/LineLength:
+  Max: 120
+
+Documentation:
+  Enabled: false
+
+Metrics/BlockLength:
+  ExcludedMethods: ['describe']

data/Gemfile

@@ -2,4 +2,5 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in codebreaker_vk.gemspec
 gemspec
-gem 'simplecov', require: false, group: :test
+gem 'simplecov', require: false, group: :test
+gem 'i18n'

data/Gemfile.lock

@@ -1,28 +1,30 @@
 PATH
   remote: .
   specs:
-    codebreaker_vk (0.2.3)
+    codebreaker_vk (0.3.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.0)
-    childprocess (0.9.0)
-      ffi (~> 1.0, >= 1.0.11)
+    childprocess (1.0.1)
+      rake (< 13.0)
     coderay (1.1.2)
     colorize (0.8.1)
+    concurrent-ruby (1.1.5)
     diff-lcs (1.3)
     docile (1.3.2)
     fasterer (0.5.1)
       colorize (~> 0.7)
       ruby_parser (>= 3.13.0)
-    ffi (1.11.1)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
     iniparse (1.4.4)
     jaro_winkler (1.5.3)
     json (2.2.0)
     method_source (0.9.2)
-    overcommit (0.48.1)
-      childprocess (~> 0.6, >= 0.6.3)
+    overcommit (0.49.0)
+      childprocess (>= 0.6.3, < 2.0)
       iniparse (~> 1.4)
     parallel (1.17.0)
     parser (2.6.3.0)
@@ -74,6 +76,7 @@ DEPENDENCIES
   bundler (~> 2.0)
   codebreaker_vk!
   fasterer (~> 0.5.1)
+  i18n
   overcommit
   pry (~> 0.12.2)
   rake (~> 10.0)

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 

data/autoload.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+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/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/version'

data/codebreaker_vk.gemspec

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-lib = File.expand_path("lib", __dir__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "codebreaker_vk/version"
+require 'codebreaker_vk/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "codebreaker_vk"
+  spec.name          = 'codebreaker_vk'
   spec.version       = CodebreakerVk::VERSION
-  spec.authors       = ["VKuzmich"]
+  spec.authors       = ['VKuzmich']
   spec.email         = ["vjk1976@ukr.net"]
 
   spec.summary       = 'Codebreaker game'
@@ -15,15 +15,12 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/VKuzmich/codebreaker_vk'
   spec.license       = 'MIT'
 
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'fasterer', '~> 0.5.1'

data/config/i18n.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+I18n.load_path << Dir[File.expand_path('config/locales') + '/*.yml']

data/config/locales/en.yml

@@ -0,0 +1,41 @@
+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'

data/lib/codebreaker_vk.rb

@@ -1,11 +1,4 @@
 # frozen_string_literal: true
 
-require_relative 'codebreaker_vk/game'
-require_relative 'codebreaker_vk/game_process'
-require_relative 'codebreaker_vk/errors/autoload'
 require_relative 'codebreaker_vk/version'
-
-module CodebreakerVk
-  class Error < StandardError; end
-  # Your code goes here...
-end
+require_relative '../autoload'

data/lib/codebreaker_vk/check_errors.rb

@@ -0,0 +1,16 @@
+# 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

@@ -0,0 +1,111 @@
+# 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

@@ -0,0 +1,38 @@
+# 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.rb

@@ -1,89 +1,82 @@
 # frozen_string_literal: true
 
-require_relative 'config'
-
 module CodebreakerVk
   class Game
-    attr_reader :tries_count, :hints_count, :errors
-
-    def initialize(difficulty: :easy)
-      validate_difficulty(difficulty)
-
-      @difficulty   = difficulty
-
-      @hint_indexes = (0...CODE_LENGTH).to_a
-
-      @secret       = Array.new(CODE_LENGTH) { rand(MIN_CODE_NUMBER..MAX_CODE_NUMBER) }
-
-      @tries_count  = DIFFICULTIES[@difficulty][:tries]
-      @hints_count  = DIFFICULTIES[@difficulty][:hints]
-
-      @errors       = []
-
-      @matches      = ''
+    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 = []
     end
 
-    def check_guess(input)
-      input = to_array(input)
-
-      return add_error(FormatError) unless valid? input
-
-      @tries_count -= 1
-
-      resolver = GameProcess.new(@secret, input)
-
-      @matches = resolver.matches
+    def start_round(user_input)
+      @attempts -= 1
+      @game_numbers = { code: @breaker_numbers.clone, input: user_input }
+      collect_place_guess + collect_presence_guess
     end
 
-    def generate_hint
-      return add_error(MaxHintError) if @hints_count.zero?
-
-      index = @hint_indexes.sample
-
-      hint = @secret[index]
+    def hint
+      return if @hints.zero?
 
-      @hint_indexes.delete index
-
-      @hints_count -= 1
-
-      hint
+      @hints -= 1
+      @showed_hints << @breaker_numbers_copy.pop
+      @showed_hints.last
     end
 
-    def win?
-      @matches == Array.new(CODE_LENGTH, EXACT_MATCH_SIGN).join
+    def win?(result)
+      @breaker_numbers == result
     end
 
-    def lose?
-      @tries_count.zero?
+    def lose?(result)
+      @attempts == 1 && @breaker_numbers != result
     end
 
-    def data
+    def to_h
       {
-          difficulty: DIFFICULTIES.keys.index(@difficulty),
-          secret: @secret,
-          tries_total: DIFFICULTIES[@difficulty][:tries],
-          hints_total: DIFFICULTIES[@difficulty][:hints],
-          tries_used: DIFFICULTIES[@difficulty][:tries] - @tries_count,
-          hints_used: DIFFICULTIES[@difficulty][:hints] - @hints_count
+        player_name: @player_name,
+        level: @difficulty[:level],
+        all_hints: @difficulty[:hints],
+        all_attempts: @difficulty[:attempts],
+        left_hints: @hints,
+        left_attempts: @attempts,
+        date: Time.now
       }
     end
 
     private
 
-    def add_error(err)
-      (@errors << err) && nil
-    end
+    def collect_place_guess
+      @game_numbers[:input].map.with_index do |user_num, index|
+        next if @game_numbers[:code][index] != user_num
 
-    def validate_difficulty(difficulty)
-      raise DifficultyLevelError unless DIFFICULTIES.include? difficulty.to_sym
+        @game_numbers[:code][index] = nil
+        @game_numbers[:input][index] = nil
+        GUESS_PLACE
+      end.compact
     end
 
-    def to_array(input)
-      input.to_i.digits.reverse
+    def collect_presence_guess
+      @game_numbers[:input].compact.map do |user_num|
+        next unless @game_numbers[:code].include?(user_num)
+
+        @game_numbers[:code].delete_at(@game_numbers[:code].index(user_num))
+        GUESS_PRESENCE
+      end.compact
     end
 
-    def valid?(input)
-      input.size == CODE_LENGTH && input.all? { |number| number.between? MIN_CODE_NUMBER, MAX_CODE_NUMBER }
+    def generate_random_code
+      Array.new(CODE_SIZE) { rand(INCLUDE_IN_GAME_NUMBERS) }
     end
   end
-end
+end

data/lib/codebreaker_vk/game_messages.rb

@@ -0,0 +1,79 @@
+# 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,43 +1,37 @@
 # frozen_string_literal: true
 
-require_relative 'config'
+require_relative 'difficulty'
 
 module CodebreakerVk
-  class GameProcess
-    attr_reader :matches
+  class GameProcess < ValidatingData
+    attr_reader :input, :errors
 
-    def initialize(secret_code, user_code)
-      @secret_code    = secret_code.clone
-      @user_code      = user_code
+    HINT = 'hint'
 
-      @exact_matches  = 0
-      @number_matches = 0
-
-      @matches        = obtain_matches
+    def initialize(input)
+      super()
+      @input = input
     end
 
-    private
-
-    def obtain_matches
-      calculate_matches unless @secret_code.empty?
+    def validate
+      return if hint?
 
-      EXACT_MATCH_SIGN * @exact_matches << NUMBER_MATCH_SIGN * @number_matches
+      @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 calculate_matches
-      @secret_code.zip(@user_code).each do |secret_code_number, user_code_number|
-        next unless @secret_code.include? user_code_number
-
-        next add_match(user_code_number, exact: true) if secret_code_number == user_code_number
+    def as_array_of_numbers
+      @as_array_of_numbers ||= @input.chars.map(&:to_i)
+    end
 
-        add_match(user_code_number)
-      end
+    def hint?
+      @input == HINT
     end
 
-    def add_match(matched_code_number, exact: false)
-      exact ? @exact_matches += 1 : @number_matches += 1
+    private
 
-      @secret_code.delete_at(@secret_code.index(matched_code_number))
+    def valid_numbers
+      Game::INCLUDE_IN_GAME_NUMBERS.map(&:to_s)
     end
   end
 end

data/lib/codebreaker_vk/game_user.rb

@@ -0,0 +1,18 @@
+# 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

@@ -0,0 +1,18 @@
+# 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

@@ -0,0 +1,21 @@
+# 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

@@ -0,0 +1,20 @@
+# 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

data/lib/codebreaker_vk/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: codebreaker_vk
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.1
 platform: ruby
 authors:
 - VKuzmich
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-05 00:00:00.000000000 Z
+date: 2019-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -161,6 +161,7 @@ files:
 - ".gitignore"
 - ".overcommit.yml"
 - ".rspec"
+- ".rubocop.yml"
 - ".ruby-gemset"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
@@ -169,21 +170,28 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- autoload.rb
 - bin/console
 - bin/setup
 - codebreaker_vk-0.1.0.gem
 - codebreaker_vk-0.2.0.gem
 - codebreaker_vk-0.2.1.gem
 - codebreaker_vk-0.2.2.gem
+- codebreaker_vk-0.2.3.gem
 - codebreaker_vk.gemspec
+- config/i18n.rb
+- config/locales/en.yml
 - lib/codebreaker_vk.rb
-- lib/codebreaker_vk/config.rb
-- lib/codebreaker_vk/errors/autoload.rb
-- lib/codebreaker_vk/errors/difficulty_level_error.rb
-- lib/codebreaker_vk/errors/format_error.rb
-- lib/codebreaker_vk/errors/max_hint_error.rb
+- lib/codebreaker_vk/check_errors.rb
+- lib/codebreaker_vk/console.rb
+- lib/codebreaker_vk/difficulty.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/version.rb
 homepage: https://github.com/VKuzmich/codebreaker_vk
 licenses:

data/lib/codebreaker_vk/config.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module CodebreakerVk
-  CODE_LENGTH = 4
-
-  EXACT_MATCH_SIGN = '+'
-  NUMBER_MATCH_SIGN = '-'
-
-  MIN_CODE_NUMBER = 1
-  MAX_CODE_NUMBER = 6
-
-  DIFFICULTIES = {
-      easy: { tries: 15, hints: 2 },
-      medium: { tries: 10, hints: 1 },
-      hell: { tries: 5, hints: 1 }
-  }.freeze
-end

data/lib/codebreaker_vk/errors/autoload.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'difficulty_level_error'
-require_relative 'format_error'
-require_relative 'max_hint_error'

data/lib/codebreaker_vk/errors/difficulty_level_error.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module CodebreakerVk
-  DifficultyLevelError = Class.new(StandardError)
-end

data/lib/codebreaker_vk/errors/format_error.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module CodebreakerVk
-  FormatError = Class.new(StandardError)
-end

data/lib/codebreaker_vk/errors/max_hint_error.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module CodebreakerVk
-  MaxHintError = Class.new(StandardError)
-end