alex_codebreaker 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31e7f606c615b97cc6f49e74138d611a9cbbff08e356bdda31b14c07d587d786
-  data.tar.gz: f8407fce826a3cc5be2ca8bb9faeee67df6b1dd121e62ce6d153d1417ff84865
+  metadata.gz: 9906ea2d8ba009f676ae54c4e40fe92a6c32c2027e925c75b2cc578139d0c0d0
+  data.tar.gz: e1b386d362478ee47deb158c476ed73fe38c33a85f7a2991967552009e399782
 SHA512:
-  metadata.gz: 43a221a965ad118e17e4a2356a89475a7d42480951c371251f1e8d236cba18f3bccf1f9b6008fbacbf4c2db959a383d198c6edb6c879b49b26a01d98f98735f0
-  data.tar.gz: 8c561f6bcdd0400b081b50c4607add61bf24c02391a2544f3fe5f6b35250b11563e488f031a8de4220d1ac5d2875585233639d77c1703d50e7f38e7a2472b96f
+  metadata.gz: b3bf4021bf22dbbfb4bde1d3e8a73898adc68eb7607c0c05511576e41661eb2032588a3a38cc5895f0be61ea19861c4487e294c97bf1f4fba101e243c11e1856
+  data.tar.gz: 61c34662972de0c1e127c3740a04e12b33f4ac2fba86c834661f85c55f8321fddcfda9ac97f749a88ef10d1645bbac0e0bca5491b0fa46226aa83ba868a77e4b

data/README.md

@@ -1,6 +1,6 @@
 # Codebreaker
 
-This pearl contains the business logic for codebreaker game.
+This gem contains the business logic for codebreaker game.
 
 ## Installation
 

data/lib/alex_codebreaker.rb

@@ -4,8 +4,9 @@ require_relative 'alex_codebreaker/version'
 require_relative 'alex_codebreaker/modules/files'
 require_relative 'alex_codebreaker/modules/settings'
 require_relative 'alex_codebreaker/modules/difficulty_levels'
-require_relative 'alex_codebreaker/modules/validators/validators'
-require_relative 'alex_codebreaker/modules/validators/arguments_validation'
+require_relative 'alex_codebreaker/modules/validators'
+require_relative 'alex_codebreaker/modules/arguments_validation'
+require_relative 'alex_codebreaker/secret_code_generator'
 require_relative 'alex_codebreaker/players_rating'
 require_relative 'alex_codebreaker/session'
 require_relative 'alex_codebreaker/game'

data/lib/alex_codebreaker/game.rb

@@ -1,87 +1,72 @@
-require_relative 'modules/validators/arguments_validation'
+module AlexCodebreaker
+  class Game
+    include AlexCodebreaker::Modules::ArgumentsValidation
 
-class Game
-  include ArgumentsValidation
+    attr_reader :secret_code, :session, :win_status
 
-  attr_reader :session, :win_status
-
-  def initialize
-    @secret_code = Array.new(Settings::CODE_LENGTH) { rand(Settings::CODE_MIN_DIGIT..Settings::CODE_MAX_DIGIT) }
-    @session = Session.new
-    @win_status = false
-  end
-
-  def add_player_name(given_name)
-    name_validation(given_name) ? @session.player_name = given_name : false
-  end
-
-  def choose_difficulty(chosen_difficulty)
-    @session.difficulty_manager(chosen_difficulty.to_sym)
-  end
-
-  def hint
-    return false if @session.hints_used >= @session.hints_total
-
-    @session.hints_used += 1
-    @secret_code_for_hint ||= @secret_code.clone.uniq
-    @secret_code_for_hint.delete(@secret_code_for_hint.sample)
-  end
-
-  def guess(user_input)
-    return false if !guess_validation(user_input) || check_attempts
+    def initialize
+      @secret_code = AlexCodebreaker::SecretCodeGenerator.new.secret_code
+      @secret_code_for_hint = @secret_code.clone.uniq
+      @session = Session.new
+    end
 
-    @session.attempts_used += 1
-    @win_status = true if user_input.to_i == @secret_code.join.to_i
-    comparator(user_input)
-  end
+    def hint
+      return unless @session.check_hints
 
-  def check_attempts
-    @session.attempts_used >= @session.attempts_total
-  end
+      hint_processing
+    end
 
-  def save_game
-    @session.save_session_statistic if @win_status
-  end
+    def guess(user_input)
+      return unless guess_validation(user_input) && @session.check_attempts
 
-  def show_secret_code
-    @secret_code.join
-  end
+      comparator(user_input)
+    end
 
-  private
+    private
 
-  def comparator(user_input)
-    user_input = user_input.chars.map!(&:to_i)
-    @secret_code_for_comparison = @secret_code.clone
-    user_input = matching_numbers_and_indexes(user_input)
+    def hint_processing
+      return @secret_code_for_hint.first if @secret_code_for_hint.one?
 
-    user_input = matching_only_numbers(user_input).sort
+      @secret_code_for_hint.delete(@secret_code_for_hint.sample)
+    end
 
-    user_input.rotate(user_input.count(Settings::MATCHING[:absent])).join
-  end
+    def comparator(user_input)
+      user_input = user_input.chars.map!(&:to_i)
+      secret_code_for_comparison = @secret_code.clone
+      user_input = matching_numbers_and_indexes(user_input, secret_code_for_comparison).compact
+      user_input = matching_only_numbers(user_input, secret_code_for_comparison).compact
+      matching_absent(user_input)
+    end
 
-  def matching_numbers_and_indexes(user_input)
-    user_input.map.with_index do |value, index|
-      if value == @secret_code_for_comparison[index]
-        @secret_code_for_comparison[index] = nil
-        Settings::MATCHING[:place]
-      elsif !@secret_code_for_comparison.include?(value)
-        Settings::MATCHING[:absent]
-      else
-        value
+    def matching_numbers_and_indexes(user_input, secret_code_for_comparison)
+      user_input.map.with_index do |value, index|
+        if value == secret_code_for_comparison[index]
+          secret_code_for_comparison[index] = nil
+          AlexCodebreaker::Modules::Settings::MATCHING[:place]
+        else
+          value
+        end
       end
     end
-  end
 
-  def matching_only_numbers(user_input)
-    user_input.map do |value|
-      if @secret_code_for_comparison.include?(value)
-        @secret_code_for_comparison.delete_at(@secret_code_for_comparison.index(value))
-        Settings::MATCHING[:presence]
-      elsif [Settings::MATCHING[:place], Settings::MATCHING[:absent]].include?(value)
-        value
-      else
-        Settings::MATCHING[:absent]
+    def matching_only_numbers(user_input, secret_code_for_comparison)
+      user_input.map do |value|
+        if secret_code_for_comparison.include?(value)
+          secret_code_for_comparison.delete_at(secret_code_for_comparison.index(value))
+          AlexCodebreaker::Modules::Settings::MATCHING[:presence]
+        elsif value == AlexCodebreaker::Modules::Settings::MATCHING[:place]
+          value
+        end
       end
     end
+
+    def matching_absent(user_input)
+      AlexCodebreaker::Modules::Settings::MATCHING[:place] *
+        user_input.count(AlexCodebreaker::Modules::Settings::MATCHING[:place]) +
+        AlexCodebreaker::Modules::Settings::MATCHING[:presence] *
+        user_input.count(AlexCodebreaker::Modules::Settings::MATCHING[:presence]) +
+        AlexCodebreaker::Modules::Settings::MATCHING[:absent] *
+        (AlexCodebreaker::Modules::Settings::CODE_LENGTH - user_input.length)
+    end
   end
 end

data/lib/alex_codebreaker/modules/arguments_validation.rb

@@ -0,0 +1,17 @@
+module AlexCodebreaker
+  module Modules
+    module ArgumentsValidation
+      include AlexCodebreaker::Modules::Validators
+      def name_validation(name)
+        argument_min_length_check(name, AlexCodebreaker::Modules::Settings::MIN_PLAYER_NAME_LENGTH) &&
+          argument_max_length_check(name, AlexCodebreaker::Modules::Settings::MAX_PLAYER_NAME_LENGTH)
+      end
+
+      def guess_validation(guess)
+        argument_length_check(guess, AlexCodebreaker::Modules::Settings::CODE_LENGTH) &&
+          digits_check(guess, AlexCodebreaker::Modules::Settings::CODE_MIN_DIGIT,
+                       AlexCodebreaker::Modules::Settings::CODE_MAX_DIGIT)
+      end
+    end
+  end
+end

data/lib/alex_codebreaker/modules/difficulty_levels.rb

@@ -1,22 +1,26 @@
-module DifficultyLevels
-  DIFFICULTY_LEVELS = {
-    Easy: {
-      name: :Easy,
-      level: 0,
-      attempts_total: 15,
-      hints_total: 2
-    },
-    Medium: {
-      name: :medium,
-      level: 1,
-      attempts_total: 10,
-      hints_total: 1
-    },
-    Hell: {
-      name: :hell,
-      level: 2,
-      attempts_total: 5,
-      hints_total: 1
-    }
-  }.freeze
+module AlexCodebreaker
+  module Modules
+    module DifficultyLevels
+      DIFFICULTY_LEVELS = {
+        easy: {
+          name: 'Easy',
+          level: 0,
+          attempts_total: 15,
+          hints_total: 2
+        },
+        medium: {
+          name: 'Medium',
+          level: 1,
+          attempts_total: 10,
+          hints_total: 1
+        },
+        hell: {
+          name: 'Hell',
+          level: 2,
+          attempts_total: 5,
+          hints_total: 1
+        }
+      }.freeze
+    end
+  end
 end

data/lib/alex_codebreaker/modules/files.rb

@@ -1,3 +1,7 @@
-module Files
-  STATS_FILE = 'stats.yml'.freeze
+module AlexCodebreaker
+  module Modules
+    module Files
+      STATS_FILE = 'stats.yml'.freeze
+    end
+  end
 end

data/lib/alex_codebreaker/modules/settings.rb

@@ -1,8 +1,12 @@
-module Settings
-  MATCHING = { place: '+', presence: '-', absent: ' ' }.freeze
-  CODE_MIN_DIGIT = 1
-  CODE_MAX_DIGIT = 6
-  CODE_LENGTH = 4
-  MIN_PLAYER_NAME_LENGTH = 3
-  MAX_PLAYER_NAME_LENGTH = 20
+module AlexCodebreaker
+  module Modules
+    module Settings
+      MATCHING = { place: '+', presence: '-', absent: ' ' }.freeze
+      CODE_MIN_DIGIT = 1
+      CODE_MAX_DIGIT = 6
+      CODE_LENGTH = 4
+      MIN_PLAYER_NAME_LENGTH = 3
+      MAX_PLAYER_NAME_LENGTH = 20
+    end
+  end
 end

data/lib/alex_codebreaker/modules/validators.rb

@@ -0,0 +1,21 @@
+module AlexCodebreaker
+  module Modules
+    module Validators
+      def argument_length_check(arg, length)
+        arg.to_s.length == length
+      end
+
+      def argument_max_length_check(arg, max)
+        arg.length <= max
+      end
+
+      def argument_min_length_check(arg, min)
+        arg.length >= min
+      end
+
+      def digits_check(arg, min_digit, max_digit)
+        arg.split('').all? { |value| value.to_i.between?(min_digit, max_digit) }
+      end
+    end
+  end
+end

data/lib/alex_codebreaker/players_rating.rb

@@ -1,26 +1,29 @@
-class PlayersRating
-  attr_accessor :stats
+module AlexCodebreaker
+  class PlayersRating
+    attr_accessor :stats
 
-  def initialize
-    stats_loader
-  end
+    def initialize
+      @stats = []
+      stats_loader
+    end
 
-  private
+    private
 
-  def stats_loader
-    return @stats = false unless File.exist?(Files::STATS_FILE)
+    def stats_loader
+      return unless File.exist?(AlexCodebreaker::Modules::Files::STATS_FILE)
 
-    load_stats
-    sort_players_rating
-  end
+      load_stats
+      sort_players_rating
+    end
 
-  def load_stats
-    File.open(Files::STATS_FILE) do |file|
-      @stats = Array.new(Psych.load_stream(file))
+    def load_stats
+      File.open(AlexCodebreaker::Modules::Files::STATS_FILE) do |file|
+        @stats = Array.new(Psych.load_stream(file))
+      end
     end
-  end
 
-  def sort_players_rating
-    @stats.sort_by! { |value| [-value.difficulty_level, value.attempts_used, value.hints_used] }
+    def sort_players_rating
+      @stats.sort_by! { |value| [-value.difficulty_level, value.attempts_used, value.hints_used] }
+    end
   end
 end

data/lib/alex_codebreaker/secret_code_generator.rb

@@ -0,0 +1,17 @@
+module AlexCodebreaker
+  class SecretCodeGenerator
+    attr_reader :secret_code
+
+    def initialize
+      @secret_code = generate_secret_code
+    end
+
+    private
+
+    def generate_secret_code
+      Array.new(AlexCodebreaker::Modules::Settings::CODE_LENGTH) do
+        rand(AlexCodebreaker::Modules::Settings::CODE_MIN_DIGIT..AlexCodebreaker::Modules::Settings::CODE_MAX_DIGIT)
+      end
+    end
+  end
+end

data/lib/alex_codebreaker/session.rb

@@ -1,34 +1,47 @@
-class Session
-  INITIAL_ATTEMPTS_USED = 0
-  INITIAL_HINTS_USED = 0
+module AlexCodebreaker
+  class Session
+    include AlexCodebreaker::Modules::ArgumentsValidation
 
-  attr_accessor :player_name, :attempts_used, :hints_used, :hints_total,
+    INITIAL_ATTEMPTS_USED = 0
+    INITIAL_HINTS_USED = 0
+
+    attr_reader :hints_used, :attempts_used, :player_name, :hints_total,
                 :difficulty_name, :attempts_total, :difficulty_level
 
-  def initialize
-    @attempts_used = INITIAL_ATTEMPTS_USED
-    @hints_used = INITIAL_HINTS_USED
-  end
+    def initialize
+      @attempts_used = INITIAL_ATTEMPTS_USED
+      @hints_used = INITIAL_HINTS_USED
+    end
 
-  def difficulty_manager(difficulty)
-    if DifficultyLevels::DIFFICULTY_LEVELS.include?(difficulty)
-      add_difficulty(DifficultyLevels::DIFFICULTY_LEVELS[difficulty])
+    def add_name(given_name)
+      @player_name = given_name if name_validation(given_name)
     end
-    return false unless DifficultyLevels::DIFFICULTY_LEVELS.include?(difficulty)
-  end
 
-  def save_session_statistic
-    File.open(Files::STATS_FILE, 'a') do |file|
-      file.write(to_yaml)
+    def add_difficulty(difficulty)
+      return unless AlexCodebreaker::Modules::DifficultyLevels::DIFFICULTY_LEVELS.include?(difficulty.downcase.to_sym)
+
+      difficulty(AlexCodebreaker::Modules::DifficultyLevels::DIFFICULTY_LEVELS[difficulty.downcase.to_sym])
     end
-  end
 
-  private
+    def check_hints
+      @hints_used += 1 if @hints_used < @hints_total
+    end
 
-  def add_difficulty(difficulty)
-    @difficulty_name = difficulty[:name]
-    @difficulty_level = difficulty[:level]
-    @attempts_total = difficulty[:attempts_total]
-    @hints_total = difficulty[:hints_total]
+    def check_attempts
+      @attempts_used += 1 if @attempts_used < @attempts_total - 1
+    end
+
+    def save_statistic
+      File.open(AlexCodebreaker::Modules::Files::STATS_FILE, 'a') { |file| file.write(to_yaml) }
+    end
+
+    private
+
+    def difficulty(difficulty)
+      @difficulty_name = difficulty[:name]
+      @difficulty_level = difficulty[:level]
+      @attempts_total = difficulty[:attempts_total]
+      @hints_total = difficulty[:hints_total]
+    end
   end
 end

data/lib/alex_codebreaker/version.rb

@@ -1,3 +1,5 @@
 module AlexCodebreaker
-  VERSION = '0.1.6'.freeze
+  module Version
+    VERSION = '0.1.7'.freeze
+  end
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: alex_codebreaker
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Oleksandr Loza
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-09 00:00:00.000000000 Z
+date: 2019-12-16 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: i18n
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.7'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +136,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.17.1
+- !ruby/object:Gem::Dependency
+  name: solargraph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.38.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.38.0
 description: Codebreaker game business logic
 email:
 - alexwebq@gmail.com
@@ -161,12 +161,13 @@ files:
 - README.md
 - lib/alex_codebreaker.rb
 - lib/alex_codebreaker/game.rb
+- lib/alex_codebreaker/modules/arguments_validation.rb
 - lib/alex_codebreaker/modules/difficulty_levels.rb
 - lib/alex_codebreaker/modules/files.rb
 - lib/alex_codebreaker/modules/settings.rb
-- lib/alex_codebreaker/modules/validators/arguments_validation.rb
-- lib/alex_codebreaker/modules/validators/validators.rb
+- lib/alex_codebreaker/modules/validators.rb
 - lib/alex_codebreaker/players_rating.rb
+- lib/alex_codebreaker/secret_code_generator.rb
 - lib/alex_codebreaker/session.rb
 - lib/alex_codebreaker/version.rb
 homepage: https://github.com/Alexwell/codebreaker/tree/feature/initial-gem-settings

data/lib/alex_codebreaker/modules/validators/arguments_validation.rb

@@ -1,13 +0,0 @@
-module ArgumentsValidation
-  include Validators
-
-  def name_validation(name)
-    argument_min_length_check(name, Settings::MIN_PLAYER_NAME_LENGTH) && \
-      argument_max_length_check(name, Settings::MAX_PLAYER_NAME_LENGTH)
-  end
-
-  def guess_validation(guess)
-    argument_fixed_length_check(guess, Settings::CODE_LENGTH) && \
-      digits_check(guess, min_digit: Settings::CODE_MIN_DIGIT, max_digit: Settings::CODE_MAX_DIGIT)
-  end
-end

data/lib/alex_codebreaker/modules/validators/validators.rb

@@ -1,17 +0,0 @@
-module Validators
-  def argument_fixed_length_check(arg, fixed_length)
-    arg.to_s.length == fixed_length
-  end
-
-  def argument_max_length_check(arg, max)
-    arg.length <= max
-  end
-
-  def argument_min_length_check(arg, min)
-    arg.length >= min
-  end
-
-  def digits_check(arg, min_digit: 1, max_digit: 6)
-    arg.to_s.split('').map { |value| value unless value.to_i.between?(min_digit, max_digit) }.compact.empty?
-  end
-end