new_super_codebreaker_2021 0.4.1 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75669bd5b9508401f9d4392343606ee771717cec9e5a9d1549bc961640807e61
-  data.tar.gz: 6b805d7ada72e527238e0855753b173e73bf2c3da90ece4dea51e81b07617467
+  metadata.gz: e6e66f5272359e959f412ca6dc0d7363d7ede198844dcdbcd9878701b90347cf
+  data.tar.gz: 450d2f983d577a9ccc0c979cb29b8ae8364c3542d809db80dec89482910604c5
 SHA512:
-  metadata.gz: fc7468aad2c2075fe1fc48819cfe1c01235f452e9ae564e272d5ca8bef53fad71566f229d7c84a5d114ab9b04121af05263a96ae042ae522ea8f442d9d593551
-  data.tar.gz: 0dbfc3426a92d5d0502b047f9a2d86300a19a171221e584a6b2579fca532ce5dd64a31f2162da91b3ce6459b0a9db60b9a709c5e6d7637abcf503551d84a3ae1
+  metadata.gz: 15def3bd39bf2b810370cf2310d1ac613013a3179da4565459214f2533fe057222b16b4f27bbea189e236f13f4eb022cce560c8983420c0f5a7fa41ff89392f1
+  data.tar.gz: 12586743080a5fc9dff5b8e32155f327a95de55ca7355f982f70b530f548daadc8098c268777a78bc6e35a631d7febe1e8d1da309fd933ca272863e388640fae

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    new_super_codebreaker_2021 (0.1.0)
+    new_super_codebreaker_2021 (0.4.4)
 
 GEM
   remote: https://rubygems.org/
@@ -13,6 +13,7 @@ GEM
     fasterer (0.9.0)
       colorize (~> 0.7)
       ruby_parser (>= 3.14.1)
+    ffaker (2.19.0)
     parallel (1.20.1)
     parser (3.0.2.0)
       ast (~> 2.4.1)
@@ -54,6 +55,8 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.3)
+    terminal-table (3.0.1)
+      unicode-display_width (>= 1.1.1, < 3)
     unicode-display_width (2.0.0)
 
 PLATFORMS
@@ -61,11 +64,13 @@ PLATFORMS
 
 DEPENDENCIES
   fasterer (~> 0.9.0)
+  ffaker
   new_super_codebreaker_2021!
   rake (~> 13.0)
   rspec (~> 3.10.0)
   rubocop (~> 1.7)
-  simplecov
+  simplecov (~> 0.21.2)
+  terminal-table (~> 3.0.1)
 
 BUNDLED WITH
    2.2.26

data/lib/game.rb

@@ -5,12 +5,15 @@ require_relative 'db_methods'
 require_relative 'user'
 module NewSuperCodebreaker2021
   class Game
+    attr_reader :code
+
     include Validate
     include ShowContent
     include DBMethods
 
     def initialize
       @code = generate_code
+      @code_copy = @code.dup
     end
 
     GUESS_COMMANDS = %i[hint rules exit].freeze
@@ -36,22 +39,18 @@ module NewSuperCodebreaker2021
     end
 
     def user_guess(code)
-      if code.to_i != 0
-        validate_user_code(code)
-      elsif GUESS_COMMANDS.include?(code.to_sym)
-        code.to_sym
-      else false
-      end
+      return validate_user_code(code) unless code.to_i.zero?
+
+      symbol_code = code.to_sym
+      GUESS_COMMANDS.include?(symbol_code) ? symbol_code : nil
     end
 
-    def take_hint(user, code, used_hints)
-      if user.hints_total > user.hints_used
-        user.hints_used += 1
-        used_hints.each { |hint| code.delete(hint) }
-        code.sample
-      else
-        false
-      end
+    def take_hint(user, used_hints)
+      return unless user.hints_total > user.hints_used
+
+      user.hints_used += 1
+      used_hints.each { |hint| @code_copy.delete(hint) }
+      @code_copy.sample
     end
 
     def after_game_commands(command)
@@ -63,27 +62,34 @@ module NewSuperCodebreaker2021
     end
 
     def compare_codes(user_code)
-      matches, u_char = number_on_right_place(user_code)
-      number_in_secret_code(user_code, matches, u_char)
+      matches, user_code, code_copy = number_on_right_place(user_code)
+      number_in_secret_code(user_code, matches, code_copy)
     end
 
     private
 
     def number_on_right_place(user_code)
+      code_copy = @code.dup
       matches = []
-      u_char = []
       user_code.each_index do |i|
-        if @code[i] == user_code[i]
-          matches.unshift('+')
-          u_char << user_code[i]
-        end
+        next unless @code[i] == user_code[i]
+
+        matches.unshift('+')
+        user_code[i] = nil
+        code_copy[i] = false
       end
-      [matches, u_char]
+      [matches, user_code, code_copy]
     end
 
-    def number_in_secret_code(user_code, matches, u_char)
+    def number_in_secret_code(user_code, matches, code_copy)
+      amount_numbers_in_secret_code = Hash.new(0)
+      amount_numbers_in_user_code = Hash.new(0)
+      code_copy.each { |number| amount_numbers_in_secret_code[number] += 1 }
       user_code.each do |element|
-        matches.push('-') if @code.include?(element) && !u_char.include?(element)
+        if code_copy.include?(element) && amount_numbers_in_user_code[element] < amount_numbers_in_secret_code[element]
+          matches.push('-')
+          amount_numbers_in_user_code[element] += 1
+        end
       end
       matches
     end

data/lib/new_super_codebreaker_2021/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NewSuperCodebreaker2021
-  VERSION = '0.4.1'
+  VERSION = '0.4.5'
 end

data/lib/show_content.rb

@@ -1,32 +1,10 @@
 require 'terminal-table'
 
 module ShowContent
-  DIFFICULTY = {
-    easy: { attempts: 15, hints: 2 },
-    medium: { attempts: 10, hints: 1 },
-    hell: { attempts: 5, hints: 1 }
-  }.freeze
-
   def show_stats(file)
     data = YAML.load_file(file) || []
-    data.sort_by(&:hints_used).sort_by(&:attempts_used).sort_by { |game| -game.difficulty }
-    create_table(data)
+    data.sort_by! { |game| [-game.difficulty, game.attempts_used, game.hints_used] }
   rescue Errno::ENOENT
     []
   end
-
-  private
-
-  def create_table(users)
-    table = Terminal::Table.new(headings: ['Rating', 'Name', 'Difficulty', 'Attempts Total',
-                                           'Attempts Used', 'Hints Total', 'Hints Used'])
-    rate = 1
-
-    users.each do |user|
-      table.add_row([rate, user.name, DIFFICULTY.keys[user.difficulty],
-                     user.attempts_total, user.attempts_used, user.hints_used, user.hints_total])
-      rate += 1
-    end
-    table
-  end
 end

data/lib/user.rb

@@ -1,32 +1,28 @@
+require_relative 'show_content'
+
 class User
   attr_reader :name, :difficulty, :hints_total, :attempts_total
   attr_accessor :hints_used, :attempts_used
 
+  DIFFICULTY = {
+    easy: { attempts: 15, hints: 2 },
+    medium: { attempts: 10, hints: 1 },
+    hell: { attempts: 5, hints: 1 }
+  }.freeze
+
   def initialize(name, difficulty)
     @name = name
     @difficulty = difficulty
     @hints_used = 0
     @attempts_used = 0
-    check_difficulty(difficulty)
+    set_total_fields
   end
 
   private
 
-  def check_difficulty(difficulty)
-    case difficulty
-    when 0
-      set_total_fields(2, 15)
-    when 1
-      set_total_fields(1, 10)
-    when 2
-      set_total_fields(1, 5)
-    else
-      false
-    end
-  end
-
-  def set_total_fields(hints_total, attempts_total)
-    @hints_total = hints_total
-    @attempts_total = attempts_total
+  def set_total_fields
+    difficulty = DIFFICULTY.keys[@difficulty]
+    @hints_total = DIFFICULTY[difficulty][:hints]
+    @attempts_total = DIFFICULTY[difficulty][:attempts]
   end
 end

data/lib/validate.rb

@@ -1,35 +1,32 @@
 module Validate
   def validate_name(name)
-    if name.length >= 3 && name.length <= 20
-      name
-    else
-      false
-    end
+    name if valid_name?(name)
   end
 
   def validate_user_code(us_code)
-    arr_code = check_splitting(us_code)
-    if valid_number?(arr_code)
-      arr_code
-    else
-      false
-    end
+    arr_code = split_to_integer_array(us_code)
+    return unless valid_number?(arr_code)
+
+    arr_code
   end
 
   def check_input(input, command_list)
-    if input.to_i.zero? && command_list.include?(input.to_sym)
-      input.to_sym
-    else false
-    end
+    return unless valid_input?(input, command_list)
+
+    input.to_sym
   end
 
   private
 
+  def valid_input?(input, command_list)
+    input.to_i.zero? && command_list.include?(input.to_sym)
+  end
+
   def valid_number?(arr_code)
-    arr_code && check_length?(arr_code) && check_numbers?(arr_code)
+    arr_code && check_code_length?(arr_code) && check_numbers?(arr_code)
   end
 
-  def check_splitting(code)
+  def split_to_integer_array(code)
     code.chars.map!(&:to_i) if integer?(code)
   end
 
@@ -37,14 +34,15 @@ module Validate
     code.to_i.to_s == code
   end
 
-  def check_length?(code)
+  def check_code_length?(code)
     code.length == 4
   end
 
   def check_numbers?(code)
-    code.each do |number|
-      return if number < 1 || number > 6
-    end
-    true
+    code.all? { |value| value.between?(1, 6) }
+  end
+
+  def valid_name?(name)
+    name.length >= 3 && name.length <= 20
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: new_super_codebreaker_2021
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.5
 platform: ruby
 authors:
 - Nazar Dakhno
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-06 00:00:00.000000000 Z
+date: 2021-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fasterer
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: ffaker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.19.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.19.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement