codebreaker-rg-te 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 436e0b032eb6a771ebd9f04ae5771921a342e810
-  data.tar.gz: 92b0a42323b4787184e8ad7e735b5aed80e8cfca
+  metadata.gz: 95180783a53441f9238daf38e89e7818b2eb51e2
+  data.tar.gz: 97dbc87d1f613e04071b3e8c1d419d796ebd7535
 SHA512:
-  metadata.gz: d2d5d0218c3a5525236f0b866c74ba83d2d1bf44da7e1cdf3dd44596358b6efedce80e38051c073582bfc8828b6733bc279da74423b796c1d014e98e6a66efbf
-  data.tar.gz: a2b66d0e87963c04450587d26652908d4dd259920c7c8e258098ee5fdb1cf80535bddd240d1127554da0bfef39d90c64e4bba87b896b666255b6cfac6ee4ea51
+  metadata.gz: b8bb7985bb6db6152e9ffadc330a7dd3f739b1ac53d63d3f2f36e199011cfacfe5cbcc1ce5565ce0ec91fc2bdea313da0e5882a0faaf2710f88deb2b331c0acb
+  data.tar.gz: 5cd985bf9e82107998fddb8275209b540ddf9fb32e1d465b3cac1a07895a647dd9df2146c318538447e9722f63971dd558d6d8867d1ce515608aa4894ba260f0

data/lib/codebreaker.rb

@@ -1,10 +1,10 @@
 require 'i18n'
 require 'yaml'
-require 'codebreaker/storage/StorageInterceptor.rb'
+require 'codebreaker/storage/storage_interceptor.rb'
 require 'codebreaker/console.rb'
 require 'codebreaker/localization.rb'
 require 'codebreaker/validation.rb'
-require 'codebreaker/stats.rb'
+require 'codebreaker/statistics.rb'
 require 'codebreaker/game.rb'
 require 'codebreaker.rb'
 

data/lib/codebreaker/console.rb

@@ -1,29 +1,29 @@
+# frozen_string_literal: true
+
 module Codebreaker
-class Console
-    YES = 'yes'.freeze
-    HINT = 'hint'.freeze
-    START = 'start'.freeze
-    RULES = 'rules'.freeze
-    STATS = 'stats'.freeze
-    EXIT = 'exit'.freeze
+  class Console
+    COMMANDS = {
+      start: 'start',
+      rules: 'rules',
+      stats: 'stats',
+      exit: 'exit'
+    }.freeze
 
-    DIFFICULTIES = %w[easy medium hard].freeze
+    HINT = 'hint'
 
-    def initialize
-      @game = Codebreaker::Game.new
-      @stat = Codebreaker::Stats.new
-    end
+    ANSWERS = { yes: 'yes' }.freeze
 
     def launch
       loop do
         message(:start_game)
-        message(:wel_instruct, start: START, rules: RULES, stats: STATS, exit: EXIT)
+        message(:wel_instruct, COMMANDS)
         @answer = read_from_console
-        check_answer
+        return check_answer
       end
     end
 
     def start_game
+      @game = Codebreaker::Game.new
       enter_name
       enter_level
       @game.new_game
@@ -31,36 +31,30 @@ class Console
     end
 
     def round_game
-      loop do
-        return loose if @game.attempts.zero?
-
-        message(:question_num, attempts: @game.attempts, hints: @game.hints)
-        user_answer = read_from_console
-        hint_show if user_answer == HINT
-        next message(:invalid_number) unless @game.validate_answer(user_answer)
+      while @game.attempts.positive?
+        user_answer = message_game_read_console
+        next hint_show if user_answer == HINT
+        next message(:invalid_number) unless @game.validate_code(user_answer)
 
-        @game.take_attempts
-        @game.set_user_code(user_answer)
+        @game.handle_guess(user_answer)
         return win if @game.equal_codes?(user_answer)
 
-        puts @game.game_result
+        message_game_result
       end
+      loose
     end
 
     def hint_show
-      if @game.hints.zero?
-        message(:over_hint)
-        round_game
-      end
+      return message(:over_hint) if @game.hints.zero?
+
       puts @game.show_hints
       @game.take_hints
-      round_game
     end
 
     def win
       message(:win)
       message(:progress)
-      @game.save if read_from_console.eql? YES
+      @game.save if read_from_console.eql? ANSWERS[:yes]
       continue_game? ? start_game : exit
     end
 
@@ -71,20 +65,19 @@ class Console
 
     def continue_game?
       message(:new_game)
-      read_from_console.eql? YES
+      read_from_console.eql? ANSWERS[:yes]
     end
 
     def stats_show
-      data = @stat.stats
-
-      return message(:empty_stat) unless data
+      @stat = Codebreaker::Statistics.new
+      return message(:empty_stat) unless data = @stat.stats
 
       message(:stats)
       message(:col_table)
-      data.each_with_index do |val, index|
+      data.each_with_index do |row, index|
         print "#{index}\t"
-        val.each do |_key, value|
-          print "#{value}\t"
+        row.each do |_key, cell|
+          print "#{cell}\t"
         end
         print "\n"
       end
@@ -94,10 +87,10 @@ class Console
 
     def check_answer
       case @answer
-      when START then start_game
-      when RULES then message(:rulegame)
-      when STATS then stats_show
-      when EXIT then exit
+      when COMMANDS[:start] then start_game
+      when COMMANDS[:rules] then message(:rulegame)
+      when COMMANDS[:stats] then stats_show
+      when COMMANDS[:exit] then exit
       end
     end
 
@@ -109,17 +102,25 @@ class Console
       gets.chomp
     end
 
+    def message_game_read_console
+      message(:question_num, attempts: @game.attempts, hints: @game.hints)
+      read_from_console
+    end
+
+    def message_game_result
+      puts @game.game_result
+    end
+
     def enter_name
       message(:username)
-      name = read_from_console
-      return enter_name unless @game.enter_name(name)
+      return enter_name unless @game.enter_name(read_from_console)
 
-      message(:hello, name: name)
+      message(:hello, name: @game.name)
     end
 
     def enter_level
-      message(:choose_difficulty, difficulties: DIFFICULTIES.join(' '))
-      return input_level unless @game.enter_level(read_from_console)
+      message(:choose_difficulty, difficulties: Codebreaker::Game::GAME_LEVELS.keys.join(' '))
+      return enter_level unless @game.enter_level(read_from_console)
     end
   end
 end

data/lib/codebreaker/game.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Codebreaker
   class Game
     include Validation
@@ -13,29 +14,27 @@ module Codebreaker
       hard: { attempts: 10, hints: 1, level_num: 2 }
     }.freeze
 
+    COUNTS_OF_HINTS = (0..3).freeze
     DIGITS_COUNT = 4
+    USER_ANSWER_REX = /^[1-6]{4}$/.freeze
 
     def new_game
       @secret_code = Array.new(DIGITS_COUNT) { rand(RANGE) }
     end
 
-    def set_user_code(enter_code)
-      @user_code = enter_code.each_char.map(&:to_i)
-    end
-
     def enter_level(level)
-      return unless validate_level(level)
+      return unless GAME_LEVELS.key?(level.to_sym)
 
       @level = level
 
       @attempts = GAME_LEVELS.dig(level.to_sym, :attempts)
       @hints = GAME_LEVELS.dig(level.to_sym, :hints)
       @level_num = GAME_LEVELS.dig(level.to_sym, :level_num)
-      @hints_index = (0..3).to_a.sample @hints
+      @hints_index = COUNTS_OF_HINTS.to_a.sample @hints
     end
 
     def enter_name(name)
-      return unless validate_name(name)
+      return unless validate_length(name)
 
       @name = name
     end
@@ -56,27 +55,48 @@ module Codebreaker
       secret_code[hints_index.shift]
     end
 
+    def set_user_code(enter_code)
+      @user_code = enter_code.each_char.map(&:to_i)
+    end
+
+    def handle_guess(user_answer)
+      take_attempts
+      set_user_code(user_answer)
+    end
+
     def game_result
+      return '++++' if equal_codes?(@user_code.join)
+
       result = ''
-      (0..3).each do |index|
-        result += '+' if @user_code[index] == @secret_code[index]
+      @secret_code_clone = @secret_code.clone
+      @user_code.each_with_index do |digit, index|
+        next unless digit == @secret_code_clone[index]
+
+        result += '+'
+        @secret_code_clone[index] = nil
+        @user_code[index] = nil
       end
-      return result if result.eql?('++++')
 
-      (0..3).each do |index|
-        result += '-' if @secret_code.include?(@user_code[index]) && @user_code[index] != @secret_code[index]
+      @user_code.compact.each_with_index do |digit, _index|
+        next unless @secret_code_clone.include?(digit)
+
+        result += '-'
+        @secret_code_clone[@secret_code_clone.index(digit)] = nil
       end
       result
     end
 
-    def save
-      di = StorageInterceptor.new
-      codebreaker_data = di.read_database || []
+    def storage_data(codebreaker_data)
       attempts_used = GAME_LEVELS.dig(level.to_sym, :attempts) - attempts
       hints_used = GAME_LEVELS.dig(level.to_sym, :hints) - hints
       hash_stat = { name: @name, level: @level, level_num: @level_num, attempts: @attempts, attempts_used: attempts_used, hints: @hints, hints_used: hints_used }
       codebreaker_data << hash_stat
-      di.write_database(codebreaker_data)
+    end
+
+    def save
+      storage = StorageInterceptor.new
+      codebreaker_data = storage.read_database || []
+      storage.write_database(storage_data(codebreaker_data))
     end
   end
-end
+end

data/lib/codebreaker/{stats.rb → statistics.rb}

@@ -1,10 +1,8 @@
 module Codebreaker
-class Stats
+  class Statistics
     def stats
-      di = StorageInterceptor.new
-      codebreaker_data = di.read_database
-
-      return unless codebreaker_data
+      storage = StorageInterceptor.new
+      return unless codebreaker_data = storage.read_database
 
       codebreaker_data.sort_by! { |stat| [stat[:level_num], stat[:hints], stat[:attempts]] }
       codebreaker_data.each { |stat| stat.delete_if { |key, _value| key == :level_num } }

data/lib/codebreaker/storage/{StorageInterceptor.rb → storage_interceptor.rb}

@@ -1,5 +1,5 @@
 module Codebreaker
-class StorageInterceptor
+  class StorageInterceptor
     DEFAULT_PATH_TO_FILE = './data/stat.yml'.freeze
 
     def initialize(path_to_file = DEFAULT_PATH_TO_FILE)
@@ -10,8 +10,8 @@ class StorageInterceptor
       YAML.load_file(@path_to_file) if File.exist?(@path_to_file)
     end
 
-    def write_database(library)
-      File.open(@path_to_file, 'w') { |file| file.write(library.to_yaml) }
+    def write_database(data)
+      File.open(@path_to_file, 'w') { |file| file.write(data.to_yaml) }
     end
   end
 end

data/lib/codebreaker/validation.rb

@@ -1,15 +1,9 @@
 module Validation
-  USER_ANSWER_REX = /^[1-6]{4}$/
-
-  def validate_name(name)
-    name.size > 2 && name.size < 21
-  end
-
-  def validate_level(level)
-    %w[easy medium hard].include? level
+  def validate_length(word)
+    word.size > 2 && word.size < 21
   end
 
-  def validate_answer(user_answer)
-    user_answer =~ USER_ANSWER_REX
+  def validate_code(code)
+    code =~ Codebreaker::Game::USER_ANSWER_REX
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: codebreaker-rg-te
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Eugene Tereschenko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-06 00:00:00.000000000 Z
+date: 2019-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.1
+        version: 1.16.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.1
+        version: 1.16.1
 - !ruby/object:Gem::Dependency
   name: fasterer
   requirement: !ruby/object:Gem::Requirement
@@ -161,8 +161,8 @@ files:
 - lib/codebreaker/console.rb
 - lib/codebreaker/game.rb
 - lib/codebreaker/localization.rb
-- lib/codebreaker/stats.rb
-- lib/codebreaker/storage/StorageInterceptor.rb
+- lib/codebreaker/statistics.rb
+- lib/codebreaker/storage/storage_interceptor.rb
 - lib/codebreaker/validation.rb
 homepage: https://github.com/EugeneTereschenko/codebreaker
 licenses: []