keyword-ruby 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 433764acb546b2b35c3e05f56095ec7ba4642a8c67591d9466fb1a6a8ae47bdf
+  data.tar.gz: e83e1a3e1b454b584efccf44a592c7868e788ff756e946e4c7631e696982cc09
+SHA512:
+  metadata.gz: b5dbf9ec6be9a3b3b657c03b6397df41de8152a02ab8539f5b62c435de8dd51ba80ca6d16645f50971d5bb48e9c2e1351a9e63081d61f89251c2d257f23cef54
+  data.tar.gz: 0d51a0fe597f68dff3231881ac131d69b85ee210bf638cdb95d8e8e8d1b2cdfab4f4e50c8f15d4c6271e394d647e5f4778e8a104270ea17a851c70d88cafc942

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.0 (2026-03-09)
+
+- Initial release
+- RAKE keyword extraction algorithm
+- YAKE keyword extraction algorithm
+- TF-IDF keyword extraction algorithm
+- English and Indonesian stop word lists
+- Module-level `extract` and `extract_batch` API
+- Configuration DSL

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Johannes Dwi Cahyo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,34 @@
+# keyword-ruby
+
+Pure Ruby keyword and keyphrase extraction using RAKE, YAKE, and TF-IDF algorithms.
+
+## Installation
+
+```ruby
+gem "keyword-ruby", "~> 0.1"
+```
+
+## Usage
+
+```ruby
+require "keyword_ruby"
+
+# RAKE (default)
+keywords = KeywordRuby.extract("Your text here...")
+keywords.each { |kw| puts "#{kw.phrase}: #{kw.score}" }
+
+# YAKE
+keywords = KeywordRuby.extract(text, algorithm: :yake)
+
+# TF-IDF (with corpus)
+extractor = KeywordRuby::Extractors::Tfidf.new
+extractor.fit(corpus_documents)
+keywords = extractor.extract(text)
+
+# Batch extraction
+results = KeywordRuby.extract_batch(documents, algorithm: :rake, top_n: 5)
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test

data/keyword-ruby.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "lib/keyword_ruby/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "keyword-ruby"
+  spec.version = KeywordRuby::VERSION
+  spec.authors = ["Johannes Dwi Cahyo"]
+  spec.email = ["johannes@example.com"]
+  spec.summary = "Keyword extraction for Ruby using RAKE, YAKE, and TF-IDF"
+  spec.description = "Pure Ruby keyword and keyphrase extraction library. Implements RAKE, YAKE, and TF-IDF algorithms for extracting keywords from text."
+  spec.homepage = "https://github.com/johannesdwicahyo/keyword-ruby"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir[
+    "lib/**/*.rb",
+    "lib/**/*.txt",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "Rakefile",
+    "keyword-ruby.gemspec"
+  ]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+end

data/lib/keyword_ruby/configuration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module KeywordRuby
+  class Configuration
+    attr_accessor :default_algorithm, :default_language, :default_top_n,
+                  :max_phrase_length, :min_word_length
+
+    def initialize
+      @default_algorithm = :rake
+      @default_language = :en
+      @default_top_n = 10
+      @max_phrase_length = 4
+      @min_word_length = 2
+    end
+  end
+end

data/lib/keyword_ruby/extractors/base.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module KeywordRuby
+  module Extractors
+    class Base
+      SUPPORTED_LANGUAGES = %i[en id].freeze
+
+      def initialize(language: nil, top_n: nil, max_length: nil, min_word_length: nil, normalize: true)
+        config = KeywordRuby.configuration
+        @language = language || config.default_language
+        @top_n = top_n || config.default_top_n
+        @max_length = max_length || config.max_phrase_length
+        @min_word_length = min_word_length || config.min_word_length
+        @normalize = normalize
+
+        validate_params!
+
+        @stop_words = TextProcessing::StopWords.new(language: @language)
+      end
+
+      def extract(text)
+        raise NotImplementedError, "#{self.class}#extract not implemented"
+      end
+
+      private
+
+      def validate_params!
+        unless SUPPORTED_LANGUAGES.include?(@language)
+          raise ArgumentError, "Unsupported language: #{@language.inspect}. Supported: #{SUPPORTED_LANGUAGES.join(', ')}"
+        end
+
+        unless @top_n.is_a?(Integer) && @top_n > 0
+          raise ArgumentError, "top_n must be a positive integer, got: #{@top_n.inspect}"
+        end
+      end
+
+      def validate_text!(text)
+        raise ArgumentError, "text must be a String, got #{text.class}" unless text.is_a?(String) || text.nil?
+      end
+
+      def normalize_scores(keywords)
+        return keywords if keywords.empty? || !@normalize
+
+        scores = keywords.map(&:score)
+        min = scores.min
+        max = scores.max
+        range = max - min
+
+        if range.zero?
+          # All scores are equal -- normalize to 1.0
+          keywords.map { |kw| Keyword.new(phrase: kw.phrase, score: 1.0, position: kw.position) }
+        else
+          keywords.map do |kw|
+            normalized = (kw.score - min) / range
+            Keyword.new(phrase: kw.phrase, score: normalized, position: kw.position)
+          end
+        end
+      end
+
+      def stop_word?(word)
+        @stop_words.stop_word?(word)
+      end
+    end
+  end
+end

data/lib/keyword_ruby/extractors/rake.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module KeywordRuby
+  module Extractors
+    class Rake < Base
+      def extract(text)
+        validate_text!(text)
+        return [] if text.nil? || text.strip.empty?
+
+        sentences = TextProcessing::Tokenizer.sentences(text)
+        candidates = extract_candidates(sentences)
+        return [] if candidates.empty?
+
+        word_scores = calculate_word_scores(candidates)
+
+        keyword_scores = candidates.uniq.map do |phrase|
+          words = phrase.split(/\s+/)
+          score = words.sum { |w| word_scores[w] || 0.0 }
+          Keyword.new(phrase: phrase, score: score)
+        end
+
+        results = keyword_scores.sort.first(@top_n)
+        normalize_scores(results)
+      end
+
+      private
+
+      def extract_candidates(sentences)
+        candidates = []
+
+        sentences.each do |sentence|
+          words = TextProcessing::Tokenizer.tokenize(sentence)
+          current_phrase = []
+
+          words.each do |word|
+            if stop_word?(word) || word.length < @min_word_length
+              if current_phrase.any?
+                phrase = current_phrase.join(" ")
+                candidates << phrase if current_phrase.length <= @max_length
+                current_phrase = []
+              end
+            else
+              current_phrase << word
+            end
+          end
+
+          if current_phrase.any? && current_phrase.length <= @max_length
+            candidates << current_phrase.join(" ")
+          end
+        end
+
+        candidates
+      end
+
+      def calculate_word_scores(candidates)
+        word_frequency = Hash.new(0)
+        cooccurrence = Hash.new { |h, k| h[k] = Hash.new(0) }
+
+        candidates.each do |phrase|
+          words = phrase.split(/\s+/)
+          words.each do |w1|
+            word_frequency[w1] += 1
+            words.each do |w2|
+              cooccurrence[w1][w2] += 1
+            end
+          end
+        end
+
+        word_scores = {}
+        word_frequency.each do |word, freq|
+          deg = cooccurrence[word].values.sum
+          word_scores[word] = deg.to_f / freq
+        end
+
+        word_scores
+      end
+    end
+  end
+end

data/lib/keyword_ruby/extractors/tfidf.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module KeywordRuby
+  module Extractors
+    class Tfidf < Base
+      def initialize(**opts)
+        super
+        @idf = nil
+        @doc_count = 0
+      end
+
+      def fit(documents)
+        @doc_count = documents.size
+        doc_freq = Hash.new(0)
+
+        documents.each do |doc|
+          words = TextProcessing::Tokenizer.tokenize(doc)
+          words.uniq.each { |w| doc_freq[w] += 1 }
+        end
+
+        @idf = {}
+        doc_freq.each do |word, df|
+          @idf[word] = Math.log(@doc_count.to_f / (1 + df))
+        end
+
+        self
+      end
+
+      def extract(text)
+        validate_text!(text)
+        return [] if text.nil? || text.strip.empty?
+
+        words = TextProcessing::Tokenizer.tokenize(text)
+        return [] if words.empty?
+
+        tf = Hash.new(0)
+        words.each { |w| tf[w] += 1 }
+
+        total = words.size.to_f
+
+        # When no corpus has been fitted, use TF-only (IDF=1 for all terms)
+        scored = tf.map do |word, count|
+          next if stop_word?(word) || word.length < @min_word_length
+
+          tf_score = count / total
+          idf_score = if @idf
+                        @idf[word] || Math.log((@doc_count + 1).to_f / 1)
+                      else
+                        1.0
+                      end
+          score = tf_score * idf_score
+
+          Keyword.new(phrase: word, score: score)
+        end.compact
+
+        results = scored.sort.first(@top_n)
+        normalize_scores(results)
+      end
+    end
+  end
+end

data/lib/keyword_ruby/extractors/yake.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module KeywordRuby
+  module Extractors
+    class Yake < Base
+      def extract(text)
+        validate_text!(text)
+        return [] if text.nil? || text.strip.empty?
+
+        words = TextProcessing::Tokenizer.tokenize(text)
+        sentences = TextProcessing::Tokenizer.sentences(text)
+        return [] if words.empty?
+
+        word_stats = calculate_features(words, sentences)
+        candidates = generate_candidates(words)
+        return [] if candidates.empty?
+
+        scored = candidates.map do |phrase|
+          score = score_candidate(phrase, word_stats)
+          Keyword.new(phrase: phrase, score: score)
+        end
+
+        max_score = scored.map(&:score).max
+        inverted = scored.map do |kw|
+          Keyword.new(phrase: kw.phrase, score: max_score - kw.score + 0.001)
+        end
+
+        results = inverted.sort.first(@top_n)
+        normalize_scores(results)
+      end
+
+      private
+
+      def calculate_features(words, sentences)
+        total = words.size.to_f
+        stats = {}
+
+        word_freq = Hash.new(0)
+        words.each { |w| word_freq[w] += 1 }
+
+        first_positions = {}
+        words.each_with_index do |w, i|
+          first_positions[w] ||= i
+        end
+
+        word_freq.each do |word, freq|
+          next if stop_word?(word) || word.length < @min_word_length
+
+          tf = freq / total
+          pos = (first_positions[word] || 0) / total
+          len_norm = word.length > 3 ? 1.0 : 0.5
+
+          stats[word] = {
+            tf: tf,
+            position: pos,
+            frequency: freq,
+            score: tf * (1.0 + pos) / len_norm
+          }
+        end
+
+        stats
+      end
+
+      def generate_candidates(words)
+        candidates = Set.new
+
+        (1..@max_length).each do |n|
+          words.each_cons(n) do |gram|
+            phrase = gram.join(" ")
+            # First and last words must not be stop words
+            next if stop_word?(gram.first) || stop_word?(gram.last)
+            # First and last words must meet minimum length
+            next if gram.first.length < @min_word_length || gram.last.length < @min_word_length
+
+            candidates << phrase
+          end
+        end
+
+        candidates.to_a
+      end
+
+      def score_candidate(phrase, word_stats)
+        words = phrase.split(/\s+/)
+        # Only score non-stop words; stop words in the middle are neutral (score 1.0 in product)
+        scores = words.map do |w|
+          if stop_word?(w) || w.length < @min_word_length
+            1.0
+          else
+            word_stats.dig(w, :score) || 1.0
+          end
+        end
+
+        if scores.length == 1
+          scores.first
+        else
+          scores.reduce(:*)
+        end
+      end
+    end
+  end
+end

data/lib/keyword_ruby/keyword.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module KeywordRuby
+  class Keyword
+    attr_reader :phrase, :score, :position
+
+    def initialize(phrase:, score:, position: nil)
+      @phrase = phrase
+      @score = score
+      @position = position
+    end
+
+    def to_h
+      { phrase: @phrase, score: @score, position: @position }.compact
+    end
+
+    def to_s
+      "#{@phrase} (#{@score.round(2)})"
+    end
+
+    def <=>(other)
+      other.score <=> @score
+    end
+  end
+end

data/lib/keyword_ruby/stop_words/en.txt

@@ -0,0 +1,132 @@
+a
+about
+above
+after
+again
+against
+all
+am
+an
+and
+any
+are
+as
+at
+be
+because
+been
+before
+being
+below
+between
+both
+but
+by
+can
+could
+did
+do
+does
+doing
+down
+during
+each
+few
+for
+from
+further
+get
+got
+had
+has
+have
+having
+he
+her
+here
+hers
+herself
+him
+himself
+his
+how
+i
+if
+in
+into
+is
+it
+its
+itself
+just
+me
+might
+more
+most
+my
+myself
+no
+nor
+not
+of
+off
+on
+once
+only
+or
+other
+ought
+our
+ours
+ourselves
+out
+over
+own
+same
+shall
+she
+should
+so
+some
+such
+than
+that
+the
+their
+theirs
+them
+themselves
+then
+there
+these
+they
+this
+those
+through
+to
+too
+under
+until
+up
+us
+very
+was
+we
+were
+what
+when
+where
+which
+while
+who
+whom
+why
+will
+with
+won
+would
+you
+your
+yours
+yourself
+yourselves

data/lib/keyword_ruby/stop_words/id.txt

@@ -0,0 +1,242 @@
+ada
+adalah
+adanya
+agar
+akan
+akhirnya
+aku
+amat
+anda
+antara
+apa
+apabila
+apakah
+apalagi
+atas
+atau
+awal
+bahkan
+bahwa
+baik
+banyak
+baru
+bawah
+beberapa
+begini
+begitu
+belum
+benar
+berapa
+beri
+berikan
+berikut
+bersama
+besar
+betul
+biasa
+biasanya
+bila
+bisa
+boleh
+buat
+bukan
+bulan
+cukup
+cuma
+dalam
+dan
+dapat
+dari
+datang
+dekat
+demi
+demikian
+dengan
+depan
+dia
+diantara
+diri
+dong
+dua
+dulu
+empat
+guna
+hal
+hampir
+hanya
+hari
+harus
+hendak
+hingga
+ia
+ini
+itu
+jadi
+jangan
+jauh
+jelas
+jika
+juga
+kalau
+kami
+kamu
+kan
+kapan
+karena
+kata
+ke
+kebetulan
+kecil
+keluar
+kembali
+kemudian
+kenapa
+kepada
+kira
+kita
+kok
+kurang
+lagi
+lah
+lain
+lalu
+lama
+lanjut
+lebih
+lewat
+lima
+luar
+macam
+maka
+makin
+malah
+mampu
+mana
+masa
+masih
+masing
+mau
+maupun
+memang
+memberi
+membuat
+meminta
+mempergunakan
+mempunyai
+memulai
+menambahkan
+menanti
+mengatakan
+mengenai
+menggunakan
+menginginkan
+menjadi
+menjawab
+menuju
+menurut
+merasa
+mereka
+merupakan
+meski
+minta
+mungkin
+nah
+namun
+nanti
+nyaris
+oleh
+pada
+padahal
+paling
+panjang
+para
+pasti
+penting
+per
+pernah
+pertama
+pihak
+pula
+pun
+punya
+rasa
+rata
+rupanya
+saat
+saja
+salah
+sama
+sambil
+sampai
+sana
+sangat
+satu
+saya
+se
+sebab
+sebagai
+sebagian
+sebelum
+sebenarnya
+seberapa
+sebesar
+sebuah
+sedang
+sedikit
+segala
+segera
+sejak
+selain
+selalu
+selama
+seluruh
+semakin
+sementara
+sempat
+semua
+sendiri
+seorang
+seperti
+sering
+serta
+sesuatu
+setelah
+siapa
+siapapun
+sini
+soal
+sudah
+supaya
+tadi
+tak
+tambah
+tanya
+tapi
+tenang
+tengah
+tentang
+tentu
+tepat
+terakhir
+terdapat
+terhadap
+terlalu
+termasuk
+ternyata
+tertentu
+terus
+tetap
+tetapi
+tiap
+tiba
+tidak
+tiga
+toh
+turut
+untuk
+usai
+waduh
+wah
+waktu
+walaupun
+yang

data/lib/keyword_ruby/text_processing/sentence_splitter.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module KeywordRuby
+  module TextProcessing
+    class SentenceSplitter
+      def self.split(text)
+        sentences = text.split(/(?<=[.!?])\s+/)
+        sentences.map(&:strip).reject(&:empty?)
+      end
+    end
+  end
+end

data/lib/keyword_ruby/text_processing/stop_words.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module KeywordRuby
+  module TextProcessing
+    class StopWords
+      STOP_WORDS_DIR = File.join(__dir__, "..", "stop_words")
+
+      def initialize(language: :en)
+        @language = language
+        @words = load_stop_words
+      end
+
+      def stop_word?(word)
+        @words.include?(word.downcase)
+      end
+
+      def filter(words)
+        words.reject { |w| stop_word?(w) }
+      end
+
+      private
+
+      def load_stop_words
+        path = File.join(STOP_WORDS_DIR, "#{@language}.txt")
+        return Set.new unless File.exist?(path)
+
+        Set.new(File.readlines(path, chomp: true).map(&:downcase).reject(&:empty?))
+      end
+    end
+  end
+end

data/lib/keyword_ruby/text_processing/tokenizer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module KeywordRuby
+  module TextProcessing
+    class Tokenizer
+      # Common English contractions mapped to their expanded forms
+      CONTRACTIONS = {
+        "n't"  => " not",
+        "'re"  => " are",
+        "'ve"  => " have",
+        "'ll"  => " will",
+        "'d"   => " would",
+        "'m"   => " am",
+        "'s"   => "",        # possessive or "is" -- just remove
+      }.freeze
+
+      def self.tokenize(text)
+        normalized = text.downcase
+        # Normalize curly/smart apostrophes to straight
+        normalized = normalized.gsub(/[\u2018\u2019\u2032]/, "'")
+        # Expand contractions before stripping punctuation
+        CONTRACTIONS.each do |suffix, expansion|
+          normalized = normalized.gsub(suffix, expansion)
+        end
+        normalized
+          .gsub(/[^\p{L}\p{N}\s-]/, " ")
+          .split(/\s+/)
+          .reject(&:empty?)
+      end
+
+      def self.sentences(text)
+        text.split(/[.!?\n]+/)
+            .map(&:strip)
+            .reject(&:empty?)
+      end
+    end
+  end
+end

data/lib/keyword_ruby/version.rb

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

data/lib/keyword_ruby.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "keyword_ruby/version"
+require_relative "keyword_ruby/configuration"
+require_relative "keyword_ruby/keyword"
+require_relative "keyword_ruby/text_processing/stop_words"
+require_relative "keyword_ruby/text_processing/tokenizer"
+require_relative "keyword_ruby/text_processing/sentence_splitter"
+require_relative "keyword_ruby/extractors/base"
+require_relative "keyword_ruby/extractors/rake"
+require_relative "keyword_ruby/extractors/yake"
+require_relative "keyword_ruby/extractors/tfidf"
+
+module KeywordRuby
+  class Error < StandardError; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
+    def extract(text, algorithm: nil, language: nil, top_n: nil, normalize: true)
+      algo = algorithm || configuration.default_algorithm
+
+      extractor = case algo
+                  when :rake then Extractors::Rake.new(language: language, top_n: top_n, normalize: normalize)
+                  when :yake then Extractors::Yake.new(language: language, top_n: top_n, normalize: normalize)
+                  when :tfidf then Extractors::Tfidf.new(language: language, top_n: top_n, normalize: normalize)
+                  else raise ArgumentError, "Unknown algorithm: #{algo}. Supported: :rake, :yake, :tfidf"
+                  end
+
+      extractor.extract(text)
+    end
+
+    def extract_batch(documents, **opts)
+      documents.map { |doc| extract(doc, **opts) }
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: keyword-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Johannes Dwi Cahyo
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Pure Ruby keyword and keyphrase extraction library. Implements RAKE,
+  YAKE, and TF-IDF algorithms for extracting keywords from text.
+email:
+- johannes@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- keyword-ruby.gemspec
+- lib/keyword_ruby.rb
+- lib/keyword_ruby/configuration.rb
+- lib/keyword_ruby/extractors/base.rb
+- lib/keyword_ruby/extractors/rake.rb
+- lib/keyword_ruby/extractors/tfidf.rb
+- lib/keyword_ruby/extractors/yake.rb
+- lib/keyword_ruby/keyword.rb
+- lib/keyword_ruby/stop_words/en.txt
+- lib/keyword_ruby/stop_words/id.txt
+- lib/keyword_ruby/text_processing/sentence_splitter.rb
+- lib/keyword_ruby/text_processing/stop_words.rb
+- lib/keyword_ruby/text_processing/tokenizer.rb
+- lib/keyword_ruby/version.rb
+homepage: https://github.com/johannesdwicahyo/keyword-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/johannesdwicahyo/keyword-ruby
+  source_code_uri: https://github.com/johannesdwicahyo/keyword-ruby
+  changelog_uri: https://github.com/johannesdwicahyo/keyword-ruby/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Keyword extraction for Ruby using RAKE, YAKE, and TF-IDF
+test_files: []