gimei 0.1.0 → 0.5.1

data/lib/gimei.rb

@@ -1,141 +1,68 @@
-require "gimei/version"
+require 'forwardable'
 require 'yaml'
+require 'gimei/version'
+require 'gimei/name'
+require 'gimei/address'
+require 'gimei/unique_generator'
+require 'gimei/config'
 
 class Gimei
+  extend Forwardable
+
   NAMES = YAML.load_file(File.expand_path(File.join('..', 'data', 'names.yml'), __FILE__))
-  GENDER = [:male, :female].freeze
+  ADDRESSES = YAML.load_file(File.expand_path(File.join('..', 'data', 'addresses.yml'), __FILE__))
+  GENDERS = [:male, :female].freeze
 
-  class << self
-    def male
-      new(:male)
-    end
+  def_delegators :@name, :gender, :kanji, :hiragana, :katakana, :first, :last, :male?, :female?, :romaji
+  def_delegators :@address, :prefecture, :city, :town
+  alias_method :to_s, :kanji
 
-    def female
-      new(:female)
-    end
+  attr_reader :name, :address
 
-    def kanji
-      name = new
-      "#{name.last.kanji} #{name.first.kanji}"
-    end
+  class << self
+    extend Forwardable
 
-    def hiragana
-      name = new
-      "#{name.last.hiragana} #{name.first.hiragana}"
-    end
+    def_delegators Gimei::Name, :male, :female
+    def_delegators :address, :prefecture, :city, :town
 
-    def katakana
-      name = new
-      "#{name.last.katakana} #{name.first.katakana}"
+    def name(gender = nil)
+      Name.new(gender)
     end
 
-    def first
-      new.first
+    %i[kanji hiragana katakana romaji first last].each do |method_name|
+      define_method(method_name) do |gender = nil|
+        name(gender).public_send(method_name)
+      end
     end
 
-    def last
-      new.last
+    def address
+      Address.new
     end
-  end
-
-  def initialize(gender = nil)
-    @gender = gender || GENDER.sample
-    @first = First.new @gender
-    @last = Last.new
-  end
-
-  def kanji
-    "#{last.kanji} #{first.kanji}"
-  end
-
-  def hiragana
-    "#{last.hiragana} #{first.hiragana}"
-  end
-
-  def katakana
-    "#{last.katakana} #{first.katakana}"
-  end
-
-  def to_s
-    kanji
-  end
-
-  def first
-    @first
-  end
-
-  def last
-    @last
-  end
 
-  def male?
-    @gender == :male
-  end
+    def unique(max_retries = 10_000)
+      return @unique if defined? @unique
 
-  def female?
-    @gender == :female
-  end
+      @unique = UniqueGenerator.new(self, max_retries)
 
-  class First
-    class << self
-      def male
-        new(:male)
+      %i[name last first hiragana katakana romaji address prefecture city town].each do |method_name|
+        @unique.define_unique_method(method_name)
       end
 
-      def female
-        new(:female)
+      %i[male female kanji].each do |method_name|
+        @unique.define_unique_method(method_name, :name)
       end
-    end
-
-    def initialize(gender = nil)
-      @gender = gender || GENDER.sample
-      @name = NAMES['first_name'][@gender.to_s].sample
-    end
-
-    def male?
-      @gender == :male
-    end
-
-    def female?
-      @gender == :female
-    end
-
-    def kanji
-      @name[0]
-    end
 
-    def hiragana
-      @name[1]
+      @unique
     end
 
-    def katakana
-      @name[2]
-    end
-
-    def to_s
-      kanji
+    def config
+      @config ||= Config.new
     end
   end
 
-  class Last
-    def initialize
-      @name = NAMES['last_name'].sample
-    end
-
-    def kanji
-      @name[0]
-    end
 
-    def hiragana
-      @name[1]
-    end
-
-    def katakana
-      @name[2]
-    end
-
-    def to_s
-      kanji
-    end
+  def initialize(gender = nil)
+    @name = Name.new(gender)
+    @address = Address.new
   end
 end

data/lib/gimei/address.rb

@@ -0,0 +1,99 @@
+class Gimei::Address
+  attr_reader :prefecture, :city, :town
+
+  def initialize
+    @prefecture = Prefecture.new
+    @city = City.new
+    @town = Town.new
+  end
+
+  def kanji
+    "#{prefecture.kanji}#{city.kanji}#{town.kanji}"
+  end
+
+  def hiragana
+    "#{prefecture.hiragana}#{city.hiragana}#{town.hiragana}"
+  end
+
+  def katakana
+    "#{prefecture.katakana}#{city.katakana}#{town.katakana}"
+  end
+
+  def romaji
+    "#{prefecture.romaji} #{city.romaji} #{town.romaji}"
+  end
+
+  alias_method :to_s, :kanji
+
+  class Prefecture
+    def kanji
+      @prefectures[0]
+    end
+
+    def hiragana
+      @prefectures[1]
+    end
+
+    def katakana
+      @prefectures[2]
+    end
+
+    def romaji
+      Romaji.kana2romaji(hiragana).capitalize
+    end
+
+    def initialize
+      @prefectures = Gimei::ADDRESSES['addresses']['prefecture'].sample(random: Gimei.config.rng)
+    end
+
+    alias_method :to_s, :kanji
+  end
+
+  class City
+    def kanji
+      @cities[0]
+    end
+
+    def hiragana
+      @cities[1]
+    end
+
+    def katakana
+      @cities[2]
+    end
+
+    def romaji
+      Romaji.kana2romaji(hiragana).capitalize
+    end
+
+    def initialize
+      @cities = Gimei::ADDRESSES['addresses']['city'].sample(random: Gimei.config.rng)
+    end
+
+    alias_method :to_s, :kanji
+  end
+
+  class Town
+    def kanji
+      @towns[0]
+    end
+
+    def hiragana
+      @towns[1]
+    end
+
+    def katakana
+      @towns[2]
+    end
+
+    def romaji
+      Romaji.kana2romaji(hiragana).capitalize
+    end
+
+    def initialize
+      @towns = Gimei::ADDRESSES['addresses']['town'].sample(random: Gimei.config.rng)
+    end
+
+    alias_method :to_s, :kanji
+  end
+end

data/lib/gimei/config.rb

@@ -0,0 +1,9 @@
+class Gimei
+  class Config
+    attr_accessor :rng
+
+    def initialize(rng: Random.new)
+      @rng = rng
+    end
+  end
+end

data/lib/gimei/name.rb

@@ -0,0 +1,116 @@
+require 'romaji'
+
+class Gimei::Name
+  attr_reader :first, :last, :gender
+
+  class << self
+    extend Forwardable
+
+    def male
+      new(:male)
+    end
+
+    def female
+      new(:female)
+    end
+
+    %i[kanji hiragana katakana romaji first last].each do |method_name|
+      define_method(method_name) do |gender = nil|
+        new(gender).public_send(method_name)
+      end
+    end
+  end
+
+  def initialize(gender = nil)
+    @gender = gender || Gimei::GENDERS.sample(random: Gimei.config.rng)
+    @first = First.new @gender
+    @last = Last.new
+  end
+
+  def kanji
+    "#{last.kanji} #{first.kanji}"
+  end
+
+  def hiragana
+    "#{last.hiragana} #{first.hiragana}"
+  end
+
+  def katakana
+    "#{last.katakana} #{first.katakana}"
+  end
+
+  def romaji
+    "#{first.romaji} #{last.romaji}"
+  end
+
+  def male?
+    @gender == :male
+  end
+
+  def female?
+    @gender == :female
+  end
+
+  alias_method :to_s, :kanji
+
+  class First
+    class << self
+      def male
+        new(:male)
+      end
+
+      def female
+        new(:female)
+      end
+    end
+
+    extend Forwardable
+    def_delegators :@name, :kanji, :hiragana, :katakana, :to_s, :romaji
+
+    def initialize(gender = nil)
+      @gender = gender || Gimei::GENDERS.sample(random: Gimei.config.rng)
+      @name = NameWord.new(Gimei::NAMES['first_name'][@gender.to_s].sample(random: Gimei.config.rng))
+    end
+
+    def male?
+      @gender == :male
+    end
+
+    def female?
+      @gender == :female
+    end
+  end
+
+  class Last
+    extend Forwardable
+    def_delegators :@name, :kanji, :hiragana, :katakana, :to_s, :romaji
+
+    def initialize
+      @name = NameWord.new(Gimei::NAMES['last_name'].sample(random: Gimei.config.rng))
+    end
+  end
+
+  class NameWord
+    def initialize(name)
+      @name = name
+    end
+
+    def kanji
+      @name[0]
+    end
+
+    def hiragana
+      @name[1]
+    end
+
+    def katakana
+      @name[2]
+    end
+
+    def romaji
+      Romaji.kana2romaji(hiragana).capitalize
+    end
+
+    alias_method :to_s, :kanji
+  end
+end

data/lib/gimei/unique_generator.rb

@@ -0,0 +1,47 @@
+class Gimei
+  class RetryLimitExceeded < StandardError; end
+
+  class UniqueGenerator
+    class << self
+      def previous_results
+        @previous_results ||= Hash.new { |hash, key| hash[key] = Set.new }
+      end
+    end
+
+    def initialize(klass, max_retries)
+      @klass = klass
+      @max_retries = max_retries
+    end
+
+    def previous_results
+      self.class.previous_results
+    end
+
+    def clear(key = nil)
+      if key
+        previous_results[key.to_sym].clear
+      else
+        previous_results.clear
+      end
+    end
+
+    def define_unique_method(method_name, previous_result_key = method_name)
+      define_singleton_method method_name do |*args|
+        max_retries.times do
+          result = klass.public_send(method_name, *args)
+
+          next if previous_results[previous_result_key].include?(result.to_s)
+
+          previous_results[previous_result_key] << result.to_s
+          return result
+        end
+
+        raise RetryLimitExceeded, "Retry limit exceeded for #{method_name}"
+      end
+    end
+
+    private
+
+    attr_reader :klass, :max_retries
+  end
+end