gem_codebreaker_amidasd 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65f81d2ecb7263634807f5d042e8d513534dcf7420dd8469e77672078860060b
-  data.tar.gz: c30e98b582e54cf7adea32993e74e9033359b532183a98de51f95b6a2025b2a0
+  metadata.gz: 0451e0d4dca3b9dc06d00238a954f85785a5d22ddc1152eec280a0232b114ef3
+  data.tar.gz: ecd2f7224e7498e9cb21efc75ff8b1fb0f745ad8b6fc749cee68e3d11b921c4e
 SHA512:
-  metadata.gz: 3677c98735935df4d0cb7b48c864a59489138eec00bc7370aa54ae4fe4a2c5927f4087710840a352416d1d9ef4cbd2484aa26b91c21e4be55f836b2b6a6efe6e
-  data.tar.gz: d5d987b906b62309208b98ca1339c29cd867809e6ff468d873a006e9bee5fd549748af18aab2c341868c2ffa0bfe7ebe11ce5153650ad329ef5e93d7b85fb786
+  metadata.gz: 913273f23abb4115d12a5989afd1acf6efbf4a96cf4349c118df2b6e746ecd4abaa575b55058e25bbe4ff8624d02cb8a72ceaed8e08846eb742425f70d00c808
+  data.tar.gz: 38221ef02935867890bdd3f494888c235861928103febd5605bda1fd280e5fc390ef14a8568fd9e9a515456aba70ccd73662ac529512aa2f6d5361cf6e7e2428

data/Gemfile.lock

@@ -0,0 +1,73 @@
+PATH
+  remote: .
+  specs:
+    gem_codebreaker_amidasd (0.1.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.0)
+    coderay (1.1.2)
+    colorize (0.8.1)
+    diff-lcs (1.3)
+    docile (1.3.2)
+    fasterer (0.5.1)
+      colorize (~> 0.7)
+      ruby_parser (>= 3.13.0)
+    jaro_winkler (1.5.3)
+    json (2.2.0)
+    method_source (0.9.2)
+    parallel (1.17.0)
+    parser (2.6.3.0)
+      ast (~> 2.4.0)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rainbow (3.0.0)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.2)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.2)
+    rubocop (0.69.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.6)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 1.7)
+    ruby-progressbar (1.10.1)
+    ruby_parser (3.13.1)
+      sexp_processor (~> 4.9)
+    sexp_processor (4.12.1)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    unicode-display_width (1.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  fasterer (~> 0.5.1)
+  gem_codebreaker_amidasd!
+  pry (~> 0.12.2)
+  rake (~> 10.0)
+  rspec (~> 3.8)
+  rubocop (~> 0.69.0)
+  simplecov (~> 0.16.1)
+
+BUNDLED WITH
+   2.0.2

data/lib/gem_codebreaker_amidasd.rb

@@ -1,4 +1,7 @@
 require 'gem_codebreaker_amidasd/version'
 require 'gem_codebreaker_amidasd/db_utility'
 require 'gem_codebreaker_amidasd/user'
-require 'gem_codebreaker_amidasd/gem_codebreaker'
+require 'gem_codebreaker_amidasd/game'
+require 'gem_codebreaker_amidasd/statistic'
+module Codebreaker
+end

data/lib/gem_codebreaker_amidasd/db_utility.rb

@@ -2,23 +2,22 @@ module GemCodebreakerAmidasd
   require 'yaml'
 
   class DbUtility
+    PATH_CODEBREAKER_DB = './db/codebreaker_db.yml'.freeze
+
     class << self
-      def save_yaml_db(user, yml_db)
-        File.write(yml_db, user.to_yaml)
+      def save_yaml_db(array, yml_db = PATH_CODEBREAKER_DB)
+        File.write(yml_db, array.to_yaml)
       end
 
-      def load_yaml_db(yml_db)
-        return unless File.exist?(yml_db)
+      def load_yaml_db(yml_db = PATH_CODEBREAKER_DB)
+        return YAML.load_file(yml_db) if File.exist?(yml_db)
 
-        YAML.load_file(yml_db)
+        []
       end
 
-      def add_db(user, path)
-        db = load_yaml_db(path)
-        db ||= []
-        db << user
-        db = db.sort_by { |value| [value.total_count_attempt, value.count_attempt, value.count_hint] }
-        save_yaml_db(db, path)
+      def add_in_db(array:, user:, game:)
+        stats = Statistic.new(user: user, game: game)
+        array << stats
       end
     end
   end

data/lib/gem_codebreaker_amidasd/game.rb

@@ -0,0 +1,113 @@
+module GemCodebreakerAmidasd
+  DIFFICULTY_HASH = { easy: { total_count_attempt: 15, total_count_hints: 2 },
+                      medium: { total_count_attempt: 10, total_count_hints: 1 },
+                      hell: { total_count_attempt: 5, total_count_hints: 1 } }.freeze
+
+  ERRORS = { WrongCode: :WrongCode,
+             HintsEnd: :HintsEnd,
+             NoCluesAvailable: :NoCluesAvailable }.freeze
+
+  STATUS = { process_game: :process_game,
+             win: :win,
+             lose: :lose }.freeze
+
+  class Game
+    attr_reader :difficulty_hash, :difficulty
+    attr_reader :length_code, :max_num, :min_num
+    attr_reader :total_count_attempt, :total_count_hints, :error, :count_plus, :count_minus, :hint
+    attr_reader :count_attempt, :secret_code, :secret_code_rand, :count_hints, :status
+
+    def initialize(other_difficulty: {})
+      @difficulty_hash = DIFFICULTY_HASH.merge(other_difficulty)
+      @array_hints = []
+      @length_code = 4
+      @min_num = 1
+      @max_num = 6
+      @count_attempt = 0
+      @count_hints = 0
+      @status = STATUS[:process_game]
+    end
+
+    def string_secretcode
+      secret_code.join('')
+    end
+
+    def setDifficulty(difficulty)
+      return unless @difficulty_hash.key? difficulty
+
+      generate_secret_code
+      secret_code_shuffle
+      @difficulty = difficulty
+      @total_count_attempt = @difficulty_hash[difficulty][:total_count_attempt]
+      @total_count_hints = @difficulty_hash[difficulty][:total_count_hints]
+    end
+
+    def gets_hint
+      empty_result
+      return add_error(ERRORS[:HintsEnd]) unless @total_count_hints > @count_hints
+      return add_error(ERRORS[:NoCluesAvailable]) unless @secret_code_rand
+
+      @count_hints += 1
+      @hint = @secret_code_rand.pop
+    end
+
+    def secret_code_shuffle
+      @secret_code_rand = @secret_code.clone
+      @secret_code_rand.shuffle!
+      @secret_code_rand.uniq!
+    end
+
+    def generate_secret_code
+      @secret_code = []
+      @length_code.times do
+        @secret_code << rand(@min_num..@max_num)
+      end
+    end
+
+    def guess_code(code_attempt)
+      empty_result
+      input_code = to_array(code_attempt)
+      return add_error(ERRORS[:WrongCode]) unless valid_code? input_code
+
+      cache_secret_code = secret_code.clone
+      prepare_arrays(input_code, cache_secret_code)
+      status = STATUS[:win] unless cache_secret_code
+      @count_attempt += 1
+      @status = STATUS[:lose] if @total_count_attempt <= @count_attempt && status == STATUS[:process_game]
+    end
+
+    def prepare_arrays(input_code, cache_secret_code)
+      del_index = []
+      @secret_code.each_with_index do |val, index|
+        del_index << index if val == input_code[index]
+        @count_plus += 1
+      end
+      del_index.each do |index|
+        input_code.delete_at(index)
+        cache_secret_code.delete_at(index)
+      end
+      cache_secret_code.each { |value| @count_minus += 1 if input_code.include?(value) }
+    end
+
+    private
+
+    def empty_result
+      @error = nil
+      @count_plus = 0
+      @count_minus = 0
+      @hint = 0
+    end
+
+    def add_error(error)
+      (@error = error) && nil
+    end
+
+    def valid_code?(input)
+      input.size == length_code && input.all? { |number| number.between? min_num, max_num }
+    end
+
+    def to_array(str)
+      str.to_i.digits.reverse
+    end
+  end
+end

data/lib/gem_codebreaker_amidasd/statistic.rb

@@ -0,0 +1,13 @@
+module GemCodebreakerAmidasd
+  class Statistic
+    attr_reader :user, :game
+    def initialize(user:, game:)
+      @user = user
+      @game = game
+    end
+
+    def self.sort_array(array)
+      array.sort_by! { |value| [value.game.total_count_attempt, value.game.count_attempt, value.game.count_hints] }
+    end
+  end
+end

data/lib/gem_codebreaker_amidasd/user.rb

@@ -1,26 +1,16 @@
 module GemCodebreakerAmidasd
   class User
-    attr_accessor :name,
-                  :difficulty,
-                  :total_count_attempt,
-                  :count_attempt,
-                  :total_count_hints,
-                  :count_hint
+    MIN_LENGTH_NAME = 3
+    MAX_LENGTH_NAME = 20
+
+    attr_reader :name
 
     def initialize(name:)
       @name = name
     end
 
-    def set_params(difficulty:, total_count_attempt:, count_attempt:, total_count_hints:, count_hint:)
-      @difficulty = difficulty
-      @total_count_attempt = total_count_attempt
-      @count_attempt = count_attempt
-      @total_count_hints = total_count_hints
-      @count_hint = count_hint
-    end
-
-    def self.validtion_name(name)
-      name.is_a?(String) && !name.empty? && name.length.between?(3, 20)
+    def self.valid_name?(name:)
+      name.is_a?(String) && !name.empty? && name.length.between?(MIN_LENGTH_NAME, MAX_LENGTH_NAME)
     end
   end
 end

data/lib/gem_codebreaker_amidasd/version.rb

@@ -1,3 +1,3 @@
 module GemCodebreakerAmidasd
-  VERSION = '0.1.5'.freeze
+  VERSION = '0.1.6'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gem_codebreaker_amidasd
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Amidasd
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-14 00:00:00.000000000 Z
+date: 2019-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,7 @@ files:
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -133,10 +134,12 @@ files:
 - gem_codebreaker_amidasd-0.1.2.gem
 - gem_codebreaker_amidasd-0.1.3.gem
 - gem_codebreaker_amidasd-0.1.4.gem
+- gem_codebreaker_amidasd-0.1.5.gem
 - gem_codebreaker_amidasd.gemspec
 - lib/gem_codebreaker_amidasd.rb
 - lib/gem_codebreaker_amidasd/db_utility.rb
-- lib/gem_codebreaker_amidasd/gem_codebreaker.rb
+- lib/gem_codebreaker_amidasd/game.rb
+- lib/gem_codebreaker_amidasd/statistic.rb
 - lib/gem_codebreaker_amidasd/user.rb
 - lib/gem_codebreaker_amidasd/version.rb
 homepage: https://github.com/Amidasd/gem_codebreaker_amidasd
@@ -158,8 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Codebreaker game

data/lib/gem_codebreaker_amidasd/gem_codebreaker.rb

@@ -1,118 +0,0 @@
-module GemCodebreakerAmidasd
-  DIFFICULTY_HASH = { easy: { total_count_attempt: 15, total_count_hints: 2 },
-                      medium: { total_count_attempt: 10, total_count_hints: 1 },
-                      hell: { total_count_attempt: 5, total_count_hints: 1 } }.freeze
-
-  class GemCodebreaker
-    attr_accessor :difficulty_hash, :difficulty
-    attr_accessor :length_code, :max_num, :min_num
-    attr_reader :total_count_attempt, :total_count_hints, :error, :win, :count_plus, :count_minus, :hint
-    attr_reader :count_attempt, :secret_code, :array_hints
-
-    def initialize(other_difficulty: {})
-      @difficulty_hash = DIFFICULTY_HASH.merge(other_difficulty)
-      @array_hints = []
-      @length_code = 4
-      @min_num = 1
-      @max_num = 6
-      @count_attempt = 0
-      generate_secret_code
-      empty_result
-    end
-
-    def string_secretcode
-      @secret_code.join('')
-    end
-
-    def set_difficulty(difficulty)
-      return unless @difficulty_hash.key? difficulty
-
-      @difficulty = difficulty
-      @total_count_attempt = @difficulty_hash[difficulty][:total_count_attempt]
-      @total_count_hints = @difficulty_hash[difficulty][:total_count_hints]
-    end
-
-    def gets_hint
-      return_hint
-    end
-
-    def generate_secret_code
-      @secret_code = []
-      @length_code.times do
-        @secret_code << rand(@min_num..@max_num)
-      end
-    end
-
-    def guess_code(code_attempt)
-      check_code(code_attempt)
-    end
-
-    private
-
-    def empty_result
-      @error = nil
-      @count_plus = 0
-      @count_minus = 0
-      @hint = 0
-    end
-
-    def return_hint
-      empty_result
-      cache_array = search_hint
-      return unless @error.nil?
-
-      max = cache_array.length
-      rand_index = rand(0..(max - 1))
-      @hint = cache_array[rand_index]
-      @array_hints << @hint
-      @hint
-    end
-
-    def search_hint
-      cache_array = []
-      @secret_code.each { |val| cache_array << val if !@array_hints.include?(val) && !cache_array.include?(val) }
-      @error = :HintsEnd unless @total_count_hints > @array_hints.size
-      @error = :NoCluesAvailable if cache_array.empty?
-      cache_array
-    end
-
-    def check_code(code_attempt)
-      correct_code = to_array(code_attempt)
-      empty_result
-      @error = :WrongCode unless code_attempt.match(/[1-6]+$/)
-      @error = :WrongCode unless correct_code.size == @length_code
-      return nil if @error == :WrongCode
-
-      status_game(correct_code)
-      @count_attempt += 1
-      @win = false if @total_count_attempt <= @count_attempt && @win.nil?
-      nil
-    end
-
-    def status_game(correct_code)
-      cache_code = correct_code
-      cache_secret_code = @secret_code.clone
-      prepare_arrays(correct_code, cache_code, cache_secret_code)
-      @win = true if cache_secret_code.empty?
-      @count_plus = @length_code - cache_secret_code.size
-      count_minus = 0
-      cache_secret_code.each { |value| count_minus += 1 if cache_code.include?(value) }
-      @count_minus = count_minus
-    end
-
-    def prepare_arrays(correct_code, cache_code, cache_secret_code)
-      num = @secret_code.size
-      while num >= 0
-        if @secret_code[num] == correct_code[num]
-          cache_code.delete_at(num)
-          cache_secret_code.delete_at(num)
-        end
-        num -= 1
-      end
-    end
-
-    def to_array(str)
-      str.to_i.digits.reverse
-    end
-  end
-end