tenpai_wakaru_man 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b743170bdc05f43954be6f9a5812e3df3f20024b
+  data.tar.gz: b6937aea8c54e68a5005037b84b6f2aa4f526051
+SHA512:
+  metadata.gz: fa943324ec7da63a27f9a3e61be038c16599b88c21ebe45c3694320b61d44ac0996a89776bc0e34e535167421a202abd1f86f7021b3164335f23d79f1b7eade6
+  data.tar.gz: e20af9aceae4f7941c1a411915f402708e35c342b7996ec174b27c8a33dcebf7a120cc3f72a944fdbfdc5f6f51fc93f46165e7ace7cacb315d1ab6ed0b9c280a

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.11.2
+notifications:
+  webhooks:
+    - https://idobata.io/hook/travis_ci/f210b102-e60f-4a48-97de-9cf9c299751e

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tenpai_wakaru_man.gemspec
+gemspec

data/README.md

@@ -0,0 +1,32 @@
+# TenpaiWakaruMan
+[![Build Status](https://travis-ci.org/flada-auxv/tenpai_wakaru_man.svg?branch=master)](https://travis-ci.org/flada-auxv/tenpai_wakaru_man)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tenpai_wakaru_man'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tenpai_wakaru_man
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[flada-auxv]/tenpai_wakaru_man.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/benchmark.rb

@@ -0,0 +1,10 @@
+require 'benchmark/ips'
+require 'tenpai_wakaru_man'
+
+Benchmark.ips do |x|
+  x.config(:time => 10, :warmup => 2)
+
+  x.report {
+    TenpaiWakaruMan::Hand.parse_from("11122233445555m").meld_combination()
+  }
+end

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tenpai_wakaru_man"
+
+# 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.
+
+require "pry"
+Pry.start

data/bin/setup

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

data/lib/tenpai_wakaru_man/calculator.rb

@@ -0,0 +1,34 @@
+require 'tenpai_wakaru_man/ten'
+require 'tenpai_wakaru_man/fu_counter'
+
+module TenpaiWakaruMan
+  class Calculator
+    class << self
+      def calculate(tiles)
+        new.calculate(tiles)
+      end
+    end
+
+    def initialize
+    end
+
+    def calculate(tiles, options = {})
+      return nil if (hands = Parser.parse(tiles).winning_hands).empty?
+
+      hands.map {|hand|
+        options[:tsumo_or_ron] = :ron
+
+        fu = FuCounter.count(hand)
+        han = HanCounter.count(hand)
+
+        {fu: fu, han: han, ten: TEN[han.size][fu][options[:tsumo_or_ron].to_s]}
+      }.max {|hash| hash[:ten] }
+    end
+
+    class HanCounter
+      def self.count(hand)
+        %i(pinfu)
+      end
+    end
+  end
+end

data/lib/tenpai_wakaru_man/errors.rb

@@ -0,0 +1,3 @@
+module TenpaiWakaruMan
+  class TileCountError < StandardError; end
+end

data/lib/tenpai_wakaru_man/fu_counter.rb

@@ -0,0 +1,64 @@
+module TenpaiWakaruMan
+  class FuCounter
+    HUTEI = 20
+    MENZEN_KAFU = 10
+    MELDS = {
+      pair: 0,
+      run: 0,
+      open_triplet: 2,
+      closed_triplet: 4,
+      open_quad: 8,
+      closed_quad: 16
+    }
+
+    class << self
+      def count(hand, options)
+        new(hand).count(options)
+      end
+    end
+
+    def initialize(hand)
+      @hand = hand
+    end
+
+    # tsumo_or_ron: [:tsumo, :ron]
+    # prevailing_wind: ["Ew", "Sw", "Ww", "Nw"]
+    # seat_wind: ["Ew", "Sw", "Ww", "Nw"]
+    # waits: [:ryanmen, :kanchan, :penchan, :tanki, :shanpon]
+    def count(options = {})
+      fu = HUTEI +
+          count_by_win_kind(options[:tsumo_or_ron]) +
+          count_by_melds +
+          count_by_head(prevailing_wind: options[:prevailing_wind], seat_wind: options[:seat_wind]) +
+          count_by_waits(options[:waits])
+
+      (fu / 10.0).ceil * 10
+    end
+
+    def count_by_win_kind(tsumo_or_ron)
+      fu = 0
+      fu += MENZEN_KAFU if tsumo_or_ron == :ron && @hand.closed?
+      fu += 2 if tsumo_or_ron == :tsumo
+      fu
+    end
+
+    def count_by_melds
+      @hand.melds.map {|meld|
+        fu = MELDS[meld.type]
+        fu *= 2 if meld.include_terminal_or_honor?
+        fu
+      }.inject(&:+)
+    end
+
+    def count_by_head(prevailing_wind:, seat_wind:)
+      fu = 0
+      fu += 2 if @hand.head == prevailing_wind
+      fu += 2 if @hand.head == seat_wind
+      fu
+    end
+
+    def count_by_waits(waits)
+      %i(kanchan penchan tanki).include?(waits) ? 2 : 0
+    end
+  end
+end

data/lib/tenpai_wakaru_man/hand.rb

@@ -0,0 +1,164 @@
+require 'tenpai_wakaru_man/errors'
+
+module TenpaiWakaruMan
+  class Hand
+    attr_accessor :head, :tiles, :melds
+
+    class << self
+      def build(head: nil, tiles: [], melds: [])
+        new(head: head, tiles: tiles, melds: melds)
+      rescue TileCountError
+        nil
+      end
+
+      def parse_from(tile_str)
+        Parser.parse(tile_str)
+      end
+    end
+
+    def initialize(head: nil, tiles: [], melds: [])
+      @head  = head
+      @tiles = tiles.sort_by {|tile| TILES[tile] }
+      @melds  = melds.sort
+
+      check_tile_count!
+    end
+
+    def ==(other)
+      head == other.head && tiles == other.tiles && melds == other.melds
+    end
+
+    def dup
+      self.class.new(head: head&.dup, tiles: tiles.dup, melds: melds.dup)
+    end
+
+    def inspect
+      "#<#{self.class.name}:\"#{to_msp_notation}\", @head=#{@head.inspect}, @melds=#{@melds.map(&:to_s)}, @tiles=#{@tiles}>"
+    end
+
+    def to_msp_notation
+      ([Meld.new(@tiles)] + @melds).sort.map(&:msp_notation).join
+    end
+    alias :to_s :to_msp_notation
+
+    def winning?
+      !winning_hands.empty?
+    end
+
+    def winning_hands
+      detect_special_form!
+
+      @winning_hands ||= head_candidates.map {|head| dup.set_head(head) }.map {|hand| hand.detect_winning_hands }.reject(&:empty?).flatten
+    end
+
+    def detect_winning_hands
+      meld_combination.map {|melds| self.class.build(head: @head.dup, melds: melds) }.compact.select {|hand| hand.all_tiles == all_tiles }
+    end
+
+    def ready?
+      TILES.each_key.any? {|tile|
+        hand = dup
+        hand.tiles << tile
+        hand.winning?
+      }
+    end
+
+    def set_head(tile)
+      self.head = tile
+      @tiles.slice!(@tiles.index(tile), 2)
+
+      self
+    end
+
+    def closed?
+      melds.all?(&:closed?)
+    end
+
+    def open?
+      !closed?
+    end
+
+    def all_tiles
+      (tiles + melds.map(&:tiles)).flatten.sort_by {|tile| TILES[tile] }
+    end
+
+    def seven_pairs?
+      count_by.keys.count == 7 && count_by.values.all? {|i| i == 2 }
+    end
+
+    def thirteen_orphans?
+      count_by.keys.count == 13 && all_tiles.all? {|tile| tile[/[#{Parser::HONOR_SYMBOLS}]/] || tile[/[19]/] }
+    end
+
+    def meld_combination
+      each_with_rest((@melds + meld_candidates)).with_object([]) {|(meld, rest_candidates), result|
+        rest_tiles = extract_meld(all_tiles, meld)
+        result.push(*_combination(rest_candidates, Array(meld), rest_tiles))
+      }.uniq {|meld_arr| meld_arr.map(&:tiles).hash }
+    end
+
+    private
+
+    def _combination(candidates, current_result, tiles, result = [])
+      return [] if (candidates.count + current_result.count) < 4
+
+      each_with_rest(candidates).with_object(result) {|(meld, rest_candidates), result|
+        next unless rest_tiles = extract_meld(tiles, meld)
+
+        _current_result = current_result.dup << meld
+
+        if _current_result.count == 4
+          result << _current_result
+        else
+          _combination(rest_candidates, _current_result, rest_tiles, result)
+        end
+      }
+    end
+
+    def each_with_rest(array)
+      if block_given?
+        array.each_with_index {|elem, i| yield elem, array[i+1..-1] }
+      else
+        array.map.with_index {|elem, i| [elem, array[i+1..-1]] }.each
+      end
+    end
+
+    def extract_meld(tiles, meld)
+      copied = tiles.dup
+
+      deleted = meld.tiles.map {|tile|
+        (index = copied.find_index(tile)) ? copied.delete_at(index) : nil
+      }
+
+      deleted.compact.count == meld.tiles.count ? copied : nil
+    end
+
+    def head_candidates
+      @tiles.uniq.select {|t| @tiles.count(t) >= 2 }
+    end
+
+    def meld_candidates
+      (triplet_candidates + run_candidates).sort
+    end
+
+    def triplet_candidates
+      count_by.select {|tile, count| count >= 3 }.keys.map {|t| Meld.new([t, t, t]) }
+    end
+
+    def run_candidates
+      @tiles.combination(3).map {|tiles| Meld.new(tiles) }.select {|meld| meld.run? }
+    end
+
+    def count_by
+      all_tiles.group_by {|tile| tile }.each_with_object({}) {|(k,v), hash| hash[k] = v.count }
+    end
+
+    def detect_special_form!
+      @winning_hands = Array(dup) if thirteen_orphans? || seven_pairs?
+    end
+
+    def check_tile_count!
+      raise TileCountError.new('some tiles existing than four.') if count_by.any? {|key, count| count > 4 }
+    end
+  end
+end

data/lib/tenpai_wakaru_man/meld.rb

@@ -0,0 +1,93 @@
+require "tenpai_wakaru_man/tiles"
+require "tenpai_wakaru_man/parser"
+
+module TenpaiWakaruMan
+  class Meld
+    attr_accessor :tiles, :msp_notation
+
+    def initialize(tiles)
+      case tiles
+      when String
+        @msp_notation = tiles
+        @tiles = Parser.split(@msp_notation)
+      when Array
+        @tiles = tiles.sort_by {|tile| TILES[tile] }
+        @msp_notation = to_msp_notation
+      end
+
+      @unique_count = @tiles.uniq.count
+      @count = @tiles.count
+    end
+
+    def ==(other)
+      @msp_notation == other.msp_notation
+    end
+
+    def <=>(other)
+      msp_notation <=> other.msp_notation
+    end
+
+    def inspect
+      "#<#{self.class.name}:\"#{@msp_notation}\">"
+    end
+
+    def to_s
+      @msp_notation
+    end
+
+    def open?; !!@msp_notation[/[#{Parser::OPEN_MELDED_SYMBOLS}]/] end
+    def closed?; !open? end
+    def revealed?; @revealed ||= open? || closed_quad? end
+
+    def pair?;    @unique_count == 1 && @count == 2 end
+    def triplet?; @unique_count == 1 && @count == 3 end
+    def quad?;    @unique_count == 1 && @count == 4 end
+    def run?
+      return false unless @tiles.map {|tile| tile[-1] }.uniq.count == 1
+
+      chow_candidates = @tiles.map {|tile| TILES[tile] }.select {|tile| tile > 6 }
+
+      return false unless chow_candidates.uniq.count == 3
+
+      [chow_candidates[0] + 2,  chow_candidates[1] + 1, chow_candidates[2]].uniq.count == 1
+    end
+
+    def open_triplet?;   open?   && triplet? end
+    def closed_triplet?; closed? && triplet? end
+    def open_quad?;      open?   && quad? end
+    def closed_quad?;    closed? && quad? end
+
+    def type
+      case
+      when pair?;           :pair
+      when run?;            :run
+      when open_triplet?;   :open_triplet
+      when closed_triplet?; :closed_triplet
+      when open_quad?;      :open_quad
+      when closed_quad?;    :closed_quad
+      end
+    end
+
+    def include_honor?
+      !!@msp_notation[/[#{Parser::HONOR_SYMBOLS}]/]
+    end
+
+    def include_terminal?
+      !!@msp_notation[/[19]/]
+    end
+
+    def include_terminal_or_honor?
+      include_honor? || include_terminal?
+    end
+
+    def exclude_terminal_or_honor?
+      !include_terminal_or_honor?
+    end
+
+    private
+
+    def to_msp_notation
+      @tiles.sort_by {|tile| TILES[tile] }.map {|tile| tile.split("") }.chunk {|_, suite| suite }.map {|key, arr| arr.map(&:first).join << key }.join
+    end
+  end
+end

data/lib/tenpai_wakaru_man/parser.rb

@@ -0,0 +1,36 @@
+require 'tenpai_wakaru_man/hand'
+require 'tenpai_wakaru_man/meld'
+
+module TenpaiWakaruMan
+  class Parser
+    SUITED_SYMBOLS = "msp"
+    DRAGON_SYMBOL = "d"
+    WIND_SYMBOL = "w"
+    OPEN_MELDED_SYMBOLS = "lar"
+    HONOR_SYMBOLS = DRAGON_SYMBOL + WIND_SYMBOL
+    MELD_SYMBOLS = SUITED_SYMBOLS + HONOR_SYMBOLS + OPEN_MELDED_SYMBOLS
+
+    MELD_REGEXP = /((\d+[#{SUITED_SYMBOLS}]|[PFC]+#{DRAGON_SYMBOL}|[ESWN]+#{WIND_SYMBOL})[#{OPEN_MELDED_SYMBOLS}]?)/
+
+    class << self
+      def scan(tile_str)
+        tile_str.scan(MELD_REGEXP).map {|tile_with_suite, _| tile_with_suite }
+      end
+
+      def split(tile_str)
+        scan(tile_str).map {|tile|
+          meld_type = tile[/[#{MELD_SYMBOLS}]/]
+          tile.delete(MELD_SYMBOLS).chars.map {|str| str + meld_type }
+        }.flatten.sort_by {|tile| TILES[tile] }
+      end
+
+      def parse(tile_str)
+        args = scan(tile_str).map {|tiles| Meld.new(tiles) }.chunk {|meld| meld.revealed? }.each_with_object({melds: [], tiles: []}) {|(bool, value), hash|
+          bool ? hash[:melds] += value : hash[:tiles] += value.map(&:tiles).flatten
+        }
+
+        Hand.build(args)
+      end
+    end
+  end
+end

data/lib/tenpai_wakaru_man/ten.rb

@@ -0,0 +1,5 @@
+require 'yaml'
+
+module TenpaiWakaruMan
+  TEN = YAML.load_file('lib/tenpai_wakaru_man/ten.yml')
+end

data/lib/tenpai_wakaru_man/ten.yml

@@ -0,0 +1,30 @@
+1:
+  20:
+    tsumo: [400, 700]
+  30:
+    ron: 1000
+    tsumo: [300, 500]
+  40:
+    ron: 1300
+    tsumo: [400, 700]
+  50:
+    ron: 1600
+    tsumo: [400, 800]
+  60:
+    ron: 2000
+    tsumo: [500, 1000]
+  70:
+    ron: 2300
+    tsumo: [600, 1200]
+  80:
+    ron: 2600
+    tsumo: [700, 1300]
+  90:
+    ron: 2900
+    tsumo: [800, 1500]
+  100:
+    ron: 3200
+    tsumo: [800, 1600]
+  110:
+    ron: 3600
+    tsumo: [900, 1800]

data/lib/tenpai_wakaru_man/tiles.rb

@@ -0,0 +1,9 @@
+module TenpaiWakaruMan
+  TILES = {
+    "Ew" => 0,  "Sw" => 1,  "Ww" => 2,  "Nw" => 3,
+    "Cd" => 4,  "Fd" => 5,  "Pd" => 6,
+    "1m" => 7,  "2m" => 8,  "3m" => 9,  "4m" => 10, "5m" => 11, "6m" => 12, "7m" => 13, "8m" => 14, "9m" => 15,
+    "1s" => 16, "2s" => 17, "3s" => 18, "4s" => 19, "5s" => 20, "6s" => 21, "7s" => 22, "8s" => 23, "9s" => 24,
+    "1p" => 25, "2p" => 26, "3p" => 27, "4p" => 28, "5p" => 29, "6p" => 30, "7p" => 31, "8p" => 32, "9p" => 33
+  }.freeze
+end

data/lib/tenpai_wakaru_man/version.rb

@@ -0,0 +1,3 @@
+module TenpaiWakaruMan
+  VERSION = "1.0.0"
+end

data/lib/tenpai_wakaru_man.rb

@@ -0,0 +1,29 @@
+require "tenpai_wakaru_man/version"
+require "tenpai_wakaru_man/errors"
+require "tenpai_wakaru_man/parser"
+require "tenpai_wakaru_man/calculator"
+
+module TenpaiWakaruMan
+  class Detector
+    class << self
+      def winning?(str)
+        new.winning?(str)
+      end
+
+      def ready?(str)
+        new.ready?(str)
+      end
+    end
+
+    def initialize
+    end
+
+    def winning?(tiles)
+      Parser.parse(tiles).winning?
+    end
+
+    def ready?(tiles)
+      Parser.parse(tiles).ready?
+    end
+  end
+end

data/stackprof.rb

@@ -0,0 +1,9 @@
+# bundle exec ruby stackprof.rb
+# bundle exec stackprof tmp/stackprof-cpu-myapp.dump --text --limit 5
+
+require 'stackprof'
+require 'tenpai_wakaru_man'
+
+StackProf.run(mode: :cpu, out: 'tmp/stackprof-cpu-myapp.dump') do
+  TenpaiWakaruMan::Detector.winning?("11122233445555m")
+end

data/tenpai_wakaru_man.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tenpai_wakaru_man/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tenpai_wakaru_man"
+  spec.version       = TenpaiWakaruMan::VERSION
+  spec.authors       = ["flada-auxv"]
+  spec.email         = ["aseknock@gmail.com"]
+
+  spec.summary       = %q{TenpaiWakaruMan}
+  spec.description   = %q{TenpaiWakaruMan}
+  spec.homepage      = "https://github.com/flada-auxv/tenpai_wakaru_man"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.10.0"
+  spec.add_development_dependency "stackprof"
+  spec.add_development_dependency "benchmark-ips"
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: tenpai_wakaru_man
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- flada-auxv
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-08-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: stackprof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: TenpaiWakaruMan
+email:
+- aseknock@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- benchmark.rb
+- bin/console
+- bin/setup
+- lib/tenpai_wakaru_man.rb
+- lib/tenpai_wakaru_man/calculator.rb
+- lib/tenpai_wakaru_man/errors.rb
+- lib/tenpai_wakaru_man/fu_counter.rb
+- lib/tenpai_wakaru_man/hand.rb
+- lib/tenpai_wakaru_man/meld.rb
+- lib/tenpai_wakaru_man/parser.rb
+- lib/tenpai_wakaru_man/ten.rb
+- lib/tenpai_wakaru_man/ten.yml
+- lib/tenpai_wakaru_man/tiles.rb
+- lib/tenpai_wakaru_man/version.rb
+- stackprof.rb
+- tenpai_wakaru_man.gemspec
+homepage: https://github.com/flada-auxv/tenpai_wakaru_man
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: TenpaiWakaruMan
+test_files: []