Updated to run against the most recent version

.gitignore

@@ -4,7 +4,8 @@
 .LSOverride
 
 # Icon must end with two \r
-Icon
+Icon
+
 
 # Thumbnails
 ._*
@@ -39,3 +40,12 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+
+# Intellij IDEA
+.idea
+.idea_modules
+*.iml
+*.ipr
+*.iws
+*.sc
+.history

.rubocop.yml

@@ -0,0 +1,9 @@
+AllCops:
+  Exclude:
+    - spec/**/*
+    - exe/*
+
+#inherit_from: .rubocop_todo.yml
+
+Style/FileName:
+  Enabled: false

.travis.yml

@@ -0,0 +1,20 @@
+language: ruby
+
+sudo: false
+
+rvm:
+  - 2.1
+  - 2.2.1
+  - ruby-head
+
+cache: bundler
+
+before_install:
+  - gem install bundler -v '1.8.6'
+
+script: bundle exec rake test
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+  fast_finish: true

Rakefile

@@ -1,15 +1,31 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "yard"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+require 'yard'
 
 RSpec::Core::RakeTask.new
-task :default => :spec
-task :test => :spec
+task test: :spec
+
+# Testing with rspec
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = %w(--color --format documentation)
+end
+task test: :spec
+
+# Use RuboCop to check for code/style offenses
+desc 'Run RuboCop to validate/lint code'
+RuboCop::RakeTask.new(:rubocop) do |task|
+  # don't abort rake on failure
+  task.fail_on_error = false
+end
 
 # Documentation
+desc "Generate gem documentation (same as running 'rake yard')"
 YARD::Rake::YardocTask.new do |t|
-	t.files   = ['lib/**/*.rb']   # optional
+  t.files = %w(lib/**/*.rb)
+  t.stats_options = %w(--list-undoc --compact)
 end
+task doc: :yard
 
-# desc "Generate gem documentation (same as running 'rake yard')"
-task :doc => :yard
+# Default Rake task
+task default: [:rubocop, :spec]

bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'faker_japanese'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# Use Pry by default
+require 'pry'
+Pry.start

bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

faker_japanese.gemspec

@@ -4,24 +4,34 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'faker_japanese/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "faker_japanese"
-  spec.version       = Faker::Japanese::VERSION
-  spec.authors       = ["Denis Vazhenin"]
-  spec.email         = ["denis.vazhenin@me.com"]
-  spec.description   = %q{Faker extension providing japanese names}
-  spec.summary       = %q{Faker extension for japanese names}
-  spec.license       = "MIT"
+  spec.name = 'faker_japanese'
+  spec.version = Faker::Japanese::VERSION
+  spec.authors = ['Denis Vazhenin']
+  spec.email = ['denis.vazhenin@me.com']
+  spec.description = 'Faker extension providing japanese names'
+  spec.summary = 'Faker extension for japanese names'
+  spec.license = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.bindir = 'exe'
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency "faker"
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-	spec.add_development_dependency "rspec"
-  spec.add_development_dependency "rspec-expectations"
-  spec.add_development_dependency "fuubar"
-	spec.add_development_dependency "yard"
+  spec.add_development_dependency 'bundler', '~> 1.8'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.2.0'
+  spec.add_development_dependency 'rspec-expectations', '~> 3.2.0'
+  spec.add_development_dependency 'rspec-mocks', '~> 3.2.1'
+  spec.add_development_dependency 'awesome_print', '~> 1.6.1'
+  spec.add_development_dependency 'looksee', '~> 3.1.0'
+  spec.add_development_dependency 'pry', '~> 0.10.1'
+  spec.add_development_dependency 'yard', '~> 0.8.7.6'
+  spec.add_development_dependency 'fuubar'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'rubocop'
+
+  spec.add_runtime_dependency 'faker'
 end

lib/faker/japanese.rb

@@ -0,0 +1 @@
+require_relative '../faker_japanese'

lib/faker_japanese.rb

@@ -1,68 +1,101 @@
 require 'faker'
+require 'yaml'
 
+# Faker
 module Faker
-	module Japanese
-		SELFDIR = File.expand_path(File.dirname(__FILE__))
+  # Japanese localization for Faker
+  module Japanese
+    # Location on the disk of this script
+    SELFDIR = File.expand_path(File.dirname(__FILE__))
 
-		class Kanji < String
-			attr_reader :yomi, :kana, :romaji
+    # Kanji string
+    class Kanji < String
+      attr_reader :yomi, :kana, :romaji
 
-			def initialize(kanji, yomi, kana, romaji)
-				super(kanji)
-				@yomi = yomi
-				@kana = kana
-				@romaji = romaji
-			end
-		end
+      # Create new Kanji string instance
+      # @param [String] kanji string in kanji from
+      # @param [String] yomi string with hiragana readings
+      # @param [String] kana string with katakana readings
+      # @param [String] romaji romanized string
+      def initialize(kanji, yomi, kana, romaji)
+        super(kanji)
+        @yomi = yomi
+        @kana = kana
+        @romaji = romaji
+      end
+    end
 
-		class Base
-			class << self
+    # Faker Base class
+    class Base
+      class << self
+        # Using callback to store loaded data when subclass is created
+        # @param [Class] klass class name
+        def inherited(klass)
+          fail("#{klass} should be Class") unless klass.is_a? Class
+          klass.class_variable_set '@@data', load_data(klass)
+        end
 
-				# Using callback to store loaded data when subclass is created
-				def inherited(klass)
-					klass.class_variable_set "@@data", load_data(klass)
-				end
+        # Convert full class name to lower case string with class name only
+        # @param [Class] klass class name
+        # @return [String]
+        def demodulize(klass)
+          klass.to_s.split('::').last.downcase
+        end
 
-				# Load fake data from yml file
-				def load_data(klass)
-					datafile = File.join(SELFDIR, 'faker_japanese',
-						'data', "#{klass.to_s.split('::').last.downcase}.yml")
-					if datafile && File.readable?(datafile)
-            data = YAML.load_file(datafile).each_with_object({}){|(k,v), h| h[k.to_sym] = v}
-            data.inject({}) do |res, item|
-            	key, values, = item
-            	res.update(key => values.map! { |v| Kanji.new(*v) })
-            end
-					else
-						nil
-					end
-				end
+        # Load yml file with minor pre-processing
+        # @param [String] filepath full path to the file
+        # @return [Hash]
+        def load_raw_yaml(filepath)
+          return nil unless filepath && File.readable?(filepath)
+          YAML.load_file(filepath).each_with_object({}) do |(k, v), h|
+            h[k.to_sym] = v
+          end
+        end
 
-				# Search
-				def fetch(key)
-					val = self.class_variable_get("@@data")[key]
-					ret = val[rand(val.size)]
-				end
+        # Created dictionary with loaded data
+        # @param [Module] klass class name
+        def load_data(klass)
+          datafile = File.join(SELFDIR,
+                               'faker_japanese',
+                               'data', "#{demodulize(klass)}.yml")
+          data = load_raw_yaml(datafile)
+          return data if data.nil?
+          data.inject({}) do |res, item|
+            key, values = item
+            res.update(key => values.map! { |v| Kanji.new(*v) })
+          end
+          data
+        end
 
-				# Swap method if block was evaluated to true
-				def swap_method(klass, name)
-					original_method 	=klass.method(name)
-					new_method				=method(name)
-					klass.singleton_class.send :define_method, name, proc {
-						yield ? new_method.call : original_method.call
-					}
-				end
+        # Fetch random value from name dictionary
+        # @param [String] key in the @@data
+        # @return [Kanji]
+        def fetch(key)
+          val = class_variable_get('@@data')[key]
+          val[rand(val.size)]
+        end
 
-				# Decide which method to use based on value of Faker::Config.locale
-				def use_japanese_method(klass, name)
-					swap_method(klass, name) do
-						Faker::Config.locale == "ja"
-					end
-				end
+        # Swap method if block was evaluated to true
+        # @param [Class] klass name of the class
+        # @param [Symbol] name method name
+        def swap_method(klass, name)
+          original_method = klass.method(name)
+          new_method = method(name)
+          proc = proc { yield ? new_method.call : original_method.call }
+          klass.singleton_class.send(:define_method, name, proc)
+        end
 
-			end # << self
-		end # Base
-	end # Japanese
+        # Decide which method to use based on value of Faker::Config.locale
+        # @param [Class] klass name of the class
+        # @param [Symbol] name method name
+        def use_japanese_method(klass, name)
+          swap_method(klass, name) do
+            Faker::Config.locale == :ja
+          end
+        end
+      end # << self
+    end # Base
+  end # Japanese
 end # Faker
 
 require 'faker_japanese/version'

lib/faker_japanese/name.rb

@@ -1,26 +1,30 @@
 module Faker
+  # Japanese localization for Faker
   module Japanese
+    # Name localization
     class Name < Base
       class << self
-
-        # Return fake first name
+        # Fake first name
+        # @return [Kanji]
         def first_name
           fetch(:first_name)
         end
 
-        # Return fake last name
+        # Fake last name
+        # @return [Kanji]
         def last_name
           fetch(:last_name)
         end
 
-        # Return fake name, which is a string combining last and first name
+        # Fake full name
+        # @return [Kanji] string combining last and first name
         def name
-          first_name  =fetch(:first_name)
-          last_name   =fetch(:last_name)
-          name_kanji  ="#{last_name} #{first_name}"
-          name_yomi   ="#{last_name.yomi} #{first_name.yomi}"
-          name_kana   ="#{last_name.kana} #{first_name.kana}"
-          name_romaji ="#{last_name.romaji} #{first_name.romaji}"
+          first_name = fetch(:first_name)
+          last_name = fetch(:last_name)
+          name_kanji = "#{last_name} #{first_name}"
+          name_yomi = "#{last_name.yomi} #{first_name.yomi}"
+          name_kana = "#{last_name.kana} #{first_name.kana}"
+          name_romaji = "#{last_name.romaji} #{first_name.romaji}"
           Kanji.new(name_kanji, name_yomi, name_kana, name_romaji)
         end
       end

lib/faker_japanese/version.rb

@@ -1,5 +1,7 @@
 module Faker
-	module Japanese
-		VERSION = "0.2.0"
-	end
+  # Japanese localization for Faker
+  module Japanese
+    # Current version
+    VERSION = '0.2.1'
+  end
 end