codebreker_manfly 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b4b8e740c8829e5bc0f3356d56f39509e1283eec9c5d336248d8b68a33e01ac
-  data.tar.gz: 5b1e41c437bc790388e712fb80f0f607db13334819a3c3cc04edaeadd7076923
+  metadata.gz: b780227d68e66b178bd1c3250207c3123f569ba0a8b9e42d105471181ed314e5
+  data.tar.gz: 2109e9aa4fcda81c129b4fd4ab1016177b9bb20fb0d307961b5bc1921d7b6867
 SHA512:
-  metadata.gz: 3830612519d9d4dbba120cd9684c19b138b0a033e6e340ea95e6330a7015c7b2c70a15153acbfb63ff3afb136a0639af8488e56989cb504bea75e3838fba67fc
-  data.tar.gz: 3b1002781ecdc3ebcc76cc0cbf32400f9a9c4d44b998e1e6cfcfa9ad352d1acf52abb6439e309b505a061926e8ba0255f99a209f62d6f45f8e81f9d1dfac0b02
+  metadata.gz: 230708b78d9578af1432eeae02e0af6574ff908a6ad63e530215937c1fbf92ff6499273ab735fc9e10721b434ceaf03bacbc1e3b499acb67acc260c563383bbe
+  data.tar.gz: 59a978e957a7e2486c9f4ebef56e7c81df44e82e765fb047f2c81bf6f7f8cd5183bbf57cf2b1d1168828594df457148a9f4d6b8f0d1f84976718e6f5bae54e59

data/Gemfile.lock

@@ -0,0 +1,117 @@
+PATH
+  remote: .
+  specs:
+    codebreker_manfly (0.1.0)
+      i18n
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    backport (1.2.0)
+    benchmark (0.2.0)
+    colorize (0.8.1)
+    concurrent-ruby (1.1.9)
+    diff-lcs (1.4.4)
+    docile (1.4.0)
+    e2mmap (0.1.0)
+    faker (2.19.0)
+      i18n (>= 1.6, < 2)
+    fasterer (0.9.0)
+      colorize (~> 0.7)
+      ruby_parser (>= 3.14.1)
+    i18n (1.8.11)
+      concurrent-ruby (~> 1.0)
+    jaro_winkler (1.5.4)
+    kramdown (2.3.1)
+      rexml
+    kramdown-parser-gfm (1.1.0)
+      kramdown (~> 2.0)
+    lefthook (0.7.7)
+    nokogiri (1.12.5-x86_64-linux)
+      racc (~> 1.4)
+    parallel (1.21.0)
+    parser (3.0.3.2)
+      ast (~> 2.4.1)
+    racc (1.6.0)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    regexp_parser (2.2.0)
+    reverse_markdown (2.1.1)
+      nokogiri
+    rexml (3.2.5)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.3)
+    rubocop (1.23.0)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.12.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.15.0)
+      parser (>= 3.0.1.1)
+    rubocop-rspec (2.6.0)
+      rubocop (~> 1.19)
+    ruby-progressbar (1.11.0)
+    ruby_parser (3.18.1)
+      sexp_processor (~> 4.16)
+    sexp_processor (4.16.0)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.3)
+    solargraph (0.44.2)
+      backport (~> 1.2)
+      benchmark
+      bundler (>= 1.17.2)
+      diff-lcs (~> 1.4)
+      e2mmap
+      jaro_winkler (~> 1.5)
+      kramdown (~> 2.3)
+      kramdown-parser-gfm (~> 1.1)
+      parser (~> 3.0)
+      reverse_markdown (>= 1.0.5, < 3)
+      rubocop (>= 0.52)
+      thor (~> 1.0)
+      tilt (~> 2.0)
+      yard (~> 0.9, >= 0.9.24)
+    thor (1.1.0)
+    tilt (2.0.10)
+    unicode-display_width (2.1.0)
+    webrick (1.7.0)
+    yard (0.9.27)
+      webrick (~> 1.7.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  codebreker_manfly!
+  faker
+  fasterer
+  lefthook
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.21)
+  rubocop-rspec
+  simplecov
+  solargraph
+
+BUNDLED WITH
+   2.2.33

data/config/locales/errors.yml

@@ -0,0 +1,8 @@
+en:
+  empty_string_error: "can't be blank"
+  negative_integer_error: "can't be negative number"
+  no_numeric_string_error: "can contain only digits"
+  non_positive_integer_error: "can't be less than 1"
+  string_max_length_error: 'is too long'
+  string_min_length_error: 'is too short'
+  unexpected_class_error: 'contains unexpeted type'

data/lib/codebreker_manfly/autoload.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'yaml/store'
+require 'date'
+
+require 'i18n'
+require_relative 'config/i18n_config'
+
+require_relative 'version'
+require_relative 'modules/validator'
+require_relative 'entities/validatable_entity'
+require_relative 'entities/code_generator'
+require_relative 'entities/difficulty'
+require_relative 'entities/user'
+require_relative 'entities/guess'
+require_relative 'entities/user_statistics'
+require_relative 'entities/codebreaker_store'
+require_relative 'entities/code_matcher'
+require_relative 'entities/game'

data/lib/codebreker_manfly/config/i18n_config.rb

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

data/lib/codebreker_manfly/entities/code_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module CodebrekerManfly
+  class CodeGenerator < ValidatableEntity
+    DEFAULT_CODE_RANGE = (1..6).freeze
+    DEFAULT_CODE_LENGTH = 4
+
+    def initialize(range: DEFAULT_CODE_RANGE, amount: DEFAULT_CODE_LENGTH)
+      super()
+      @range = range
+      @amount = amount
+    end
+
+    def generate
+      Array.new(@amount) { rand(@range) }
+    end
+
+    private
+
+    def validate
+      add_error(:range, I18n.t(:unexpected_class_error)) unless valid_class?(Range, @range)
+      return add_error(:amount, I18n.t(:unexpected_class_error)) unless valid_class?(Integer, @amount)
+
+      add_error(:amount, I18n.t(:non_positive_integer_error)) unless valid_positive_integer?(@amount)
+    end
+  end
+end

data/lib/codebreker_manfly/entities/code_matcher.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module CodebrekerManfly
+  class CodeMatcher < ValidatableEntity
+    attr_reader :answer
+
+    STRONG_MATCH_SYMBOL = '+'
+    SOFT_MATCH_SYMBOL = '-'
+
+    def initialize(secret_code, guess_code)
+      super()
+      @secret_code = secret_code
+      @guess_code = guess_code
+    end
+
+    def match_codes
+      secret_code = @secret_code.clone
+      guess_code = @guess_code.clone
+
+      strong_match(secret_code, guess_code) + soft_match(secret_code, guess_code)
+    end
+
+    def codes_match?
+      @secret_code == @guess_code
+    end
+
+    private
+
+    def strong_match(secret_code, guess_code)
+      guess_answer = ''
+
+      guess_code.count.times do |index|
+        next unless secret_code[index] == guess_code[index]
+
+        guess_answer += STRONG_MATCH_SYMBOL
+        secret_code[index] = nil
+        guess_code[index] = nil
+      end
+
+      guess_answer
+    end
+
+    def soft_match(secret_code, guess_code)
+      guess_answer = ''
+
+      guess_code.count.times do |index|
+        next unless guess_code[index] && secret_code.include?(guess_code[index])
+
+        guess_answer += SOFT_MATCH_SYMBOL
+        secret_code.delete_at(secret_code.index(guess_code[index]))
+        guess_code[index] = nil
+      end
+
+      guess_answer
+    end
+
+    def validate
+      add_error(:secret_code, I18n.t(:unexpected_class_error)) unless valid_class?(Array, @secret_code)
+      add_error(:guess_code, I18n.t(:unexpected_class_error)) unless valid_class?(Array, @guess_code)
+    end
+  end
+end

data/lib/codebreker_manfly/entities/codebreaker_store.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module CodebrekerManfly
+  class CodebreakerStore
+    STORAGE_DIRECTORY = 'db'
+    STORAGE_FILE = 'db.yml'
+    attr_accessor :data
+
+    def initialize
+      @data = db_initialized? ? load : initialize_db
+    end
+
+    def save
+      store = YAML::Store.new(storage_path)
+      store.transaction { @data.each { |key, value| store[key] = value } }
+    end
+
+    private
+
+    def db_initialized?
+      Dir.exist?(STORAGE_DIRECTORY) && File.file?(File.join(STORAGE_DIRECTORY, STORAGE_FILE))
+    end
+
+    def initialize_db
+      Dir.mkdir(STORAGE_DIRECTORY)
+
+      store = YAML::Store.new(File.join(STORAGE_DIRECTORY, STORAGE_FILE))
+      store.transaction { default_data.each { |key, value| store[key] = value } }
+
+      default_data
+    end
+
+    def default_data
+      {
+        user_statistics: []
+      }
+    end
+
+    def storage_path
+      File.join(STORAGE_DIRECTORY, STORAGE_FILE)
+    end
+
+    def load
+      store = YAML::Store.new(storage_path)
+      store.transaction { store.roots.to_h { |key| [key, store[key]] } }
+    end
+  end
+end

data/lib/codebreker_manfly/entities/difficulty.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module CodebrekerManfly
+  class Difficulty < ValidatableEntity
+    attr_reader :name, :attempts, :hints
+
+    EASY = :easy
+    MEDIUM = :medium
+    HELL = :hell
+
+    def initialize(name:, attempts:, hints:)
+      super()
+      @name = name
+      @attempts = attempts
+      @hints = hints
+    end
+
+    def <=>(other)
+      [attempts, hints] <=> [other.attempts, other.hints]
+    end
+
+    def self.difficulties(keyword)
+      case keyword
+      when EASY then CodebrekerManfly::Difficulty.new(name: 'Easy', attempts: 15, hints: 2)
+      when MEDIUM then CodebrekerManfly::Difficulty.new(name: 'Medium', attempts: 10, hints: 1)
+      when HELL then CodebrekerManfly::Difficulty.new(name: 'Hell', attempts: 5, hints: 1)
+      end
+    end
+
+    private
+
+    def validate
+      validate_name
+      validate_attempts
+      validate_hints
+    end
+
+    def validate_name
+      return add_error(:name, I18n.t(:unexpected_class_error)) unless valid_class?(String, name)
+
+      add_error(:name, I18n.t(:empty_string_error)) unless valid_non_empty_string?(name)
+    end
+
+    def validate_attempts
+      return add_error(:attempts, I18n.t(:unexpected_class_error)) unless valid_class?(Integer, attempts)
+
+      add_error(:attempts, I18n.t(:non_positive_integer_error)) unless valid_positive_integer?(attempts)
+    end
+
+    def validate_hints
+      return add_error(:hints, I18n.t(:unexpected_class_error)) unless valid_class?(Integer, hints)
+
+      add_error(:hints, I18n.t(:negative_integer_error)) unless valid_non_negative_integer?(hints)
+    end
+  end
+end

data/lib/codebreker_manfly/entities/game.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module CodebrekerManfly
+  class Game < ValidatableEntity
+    attr_reader :difficulty, :user, :attempts_amount, :hints_amount, :code
+
+    def initialize(difficulty, user)
+      super()
+      @difficulty = difficulty
+      @user = user
+    end
+
+    def start
+      prepare_game
+    end
+
+    def self.user_statistic
+      store = CodebrekerManfly::CodebreakerStore.new
+      store.data[:user_statistics].sort_by { |stats| [stats.difficulty, stats.attempts, stats.hints] }
+    end
+
+    def save_statistic
+      store = CodebrekerManfly::CodebreakerStore.new
+      store.data[:user_statistics] << current_statistic
+      store.save
+    end
+
+    def take_hint
+      @hints_amount -= 1
+      @hints.pop
+    end
+
+    def make_turn(guess)
+      @guess = guess
+      @attempts_amount -= 1
+
+      matcher = CodebrekerManfly::CodeMatcher.new(code, guess.code)
+      matcher.match_codes
+    end
+
+    def win?
+      code == @guess&.code
+    end
+
+    def lose?
+      attempts_amount < 1 && !win?
+    end
+
+    def restart
+      prepare_game
+    end
+
+    private
+
+    def current_statistic
+      CodebrekerManfly::UserStatistics.new(user: user, difficulty: difficulty,
+                                            attempts: difficulty.attempts - attempts_amount,
+                                            hints: difficulty.hints - hints_amount)
+    end
+
+    def validate
+      add_error(:user, I18n.t(:unexpected_class_error)) unless valid_class?(User, user)
+      add_error(:difficulty, I18n.t(:unexpected_class_error)) unless valid_class?(Difficulty, difficulty)
+    end
+
+    def prepare_game
+      @attempts_amount = difficulty.attempts
+      @hints_amount = difficulty.hints
+      @code = CodebrekerManfly::CodeGenerator.new.generate
+      @hints = code.sample(hints_amount)
+    end
+  end
+end

data/lib/codebreker_manfly/entities/guess.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module CodebrekerManfly
+  class Guess < ValidatableEntity
+    CODE_LENGTH = 4
+
+    def initialize(string_code)
+      super()
+      @string_code = string_code
+    end
+
+    def code
+      @code ||= parse_code
+    end
+
+    private
+
+    def parse_code
+      @string_code.chars.map { |number| Integer(number) }
+    end
+
+    def validate
+      return add_error(:code, I18n.t(:unexpected_class_error)) unless valid_class?(String, @string_code)
+
+      validate_code_length
+      return add_error(:code, I18n.t(:non_numeric_string_error)) unless valid_only_numeric_string?(@string_code)
+
+      add_error(:code, I18n.t(:invalid_range)) unless valid_range?(
+        CodebrekerManfly::CodeGenerator::DEFAULT_CODE_RANGE, parse_code
+      )
+    end
+
+    def validate_code_length
+      add_error(:code, I18n.t(:string_min_length_error)) unless valid_string_min_length?(@string_code, CODE_LENGTH)
+      add_error(:code, I18n.t(:string_max_length_error)) unless valid_string_max_length?(@string_code, CODE_LENGTH)
+    end
+  end
+end

data/lib/codebreker_manfly/entities/user.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CodebrekerManfly
+  class User < ValidatableEntity
+    attr_reader :name
+
+    USERNAME_MIN_LENGTH = 3
+    USERNAME_MAX_LENGTH = 20
+
+    def initialize(name)
+      super()
+      @name = name
+    end
+
+    private
+
+    def validate
+      return add_error(:name, I18n.t(:unexpected_class_error)) unless valid_class?(String, name)
+
+      add_error(:name, I18n.t(:string_min_length_error)) unless valid_string_min_length?(name, USERNAME_MIN_LENGTH)
+      add_error(:name, I18n.t(:string_max_length_error)) unless valid_string_max_length?(name, USERNAME_MAX_LENGTH)
+    end
+  end
+end

data/lib/codebreker_manfly/entities/user_statistics.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module CodebreakerManflu
+  class UserStatistics < ValidatableEntity
+    include Validator
+    attr_reader :user, :difficulty, :attempts, :hints, :date
+
+    def initialize(user:, difficulty:, attempts:, hints:)
+      super()
+      @user = user
+      @difficulty = difficulty
+      @attempts = attempts
+      @hints = hints
+      @date = DateTime.now
+    end
+
+    private
+
+    def validate
+      add_error(:user, I18n.t(:unexpected_class_error)) unless valid_class?(CodebreakerManflu::User, user)
+      add_error(:difficulty, I18n.t(:unexpected_class_error)) unless valid_class?(CodebreakerManflu::Difficulty,
+                                                                                  difficulty)
+      validate_attempts
+      validate_hints
+    end
+
+    def validate_attempts
+      return add_error(:attempts, I18n.t(:unexpected_class_error)) unless valid_class?(Integer, attempts)
+
+      add_error(:attempts, I18n.t(:negative_integer_error)) unless valid_non_negative_integer?(attempts)
+    end
+
+    def validate_hints
+      return add_error(:hints, I18n.t(:unexpected_class_error)) unless valid_class?(Integer, hints)
+
+      add_error(:hints, I18n.t(:negative_integer_error)) unless valid_non_negative_integer?(hints)
+    end
+  end
+end

data/lib/codebreker_manfly/entities/validatable_entity.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module CodebrekerManfly
+  class ValidatableEntity
+    include Validator
+
+    attr_reader :errors
+
+    def initialize
+      @errors = {}
+    end
+
+    def valid?
+      validate
+      errors.empty?
+    end
+
+    private
+
+    def validate; end
+
+    def add_error(attribute, error)
+      @errors[attribute] = @errors[attribute].nil? ? [error] : @errors[attribute] << error
+    end
+  end
+end

data/lib/codebreker_manfly/modules/validator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module CodebrekerManfly
+  module Validator
+    def valid_class?(expected_class, instance)
+      instance.is_a?(expected_class)
+    end
+
+    def valid_non_empty_string?(string)
+      !string.empty?
+    end
+
+    def valid_positive_integer?(number)
+      number.positive?
+    end
+
+    def valid_non_negative_integer?(number)
+      !number.negative?
+    end
+
+    def valid_string_min_length?(string, min_length)
+      string.length >= min_length
+    end
+
+    def valid_string_max_length?(string, max_length)
+      string.length <= max_length
+    end
+
+    def valid_only_numeric_string?(string)
+      /\A\d+\Z/.match?(string)
+    end
+
+    def valid_range?(range, code)
+      code.each { |digit| return false unless range.cover?(digit) }
+      true
+    end
+  end
+end

data/lib/codebreker_manfly/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CodebrekerManfly
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: codebreker_manfly
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Manfly1
@@ -161,12 +161,27 @@ files:
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
+- codebreker_manfly-0.1.0.gem
+- config/locales/errors.yml
 - lib/codebreker_manfly.rb
+- lib/codebreker_manfly/autoload.rb
+- lib/codebreker_manfly/config/i18n_config.rb
+- lib/codebreker_manfly/entities/code_generator.rb
+- lib/codebreker_manfly/entities/code_matcher.rb
+- lib/codebreker_manfly/entities/codebreaker_store.rb
+- lib/codebreker_manfly/entities/difficulty.rb
+- lib/codebreker_manfly/entities/game.rb
+- lib/codebreker_manfly/entities/guess.rb
+- lib/codebreker_manfly/entities/user.rb
+- lib/codebreker_manfly/entities/user_statistics.rb
+- lib/codebreker_manfly/entities/validatable_entity.rb
+- lib/codebreker_manfly/modules/validator.rb
 - lib/codebreker_manfly/version.rb
 - sig/codebreker_manfly.rbs
 homepage: