lingua_rs 0.2.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c52e545860174c156f8e8276d25762293daa3235766fc88777e5d2b5d53f50f5
-  data.tar.gz: 90bb85fd278795e300b768e3e5079d465f9c5b85a7c3a62f61c4e45745b5ba96
+  metadata.gz: bd0dba860ee235a6acfc46afb3ba851ec08303df9499f403e47624c74b9396e7
+  data.tar.gz: b3d9faca1f0f12fb7abee0643b94f1f494ef02e6b4f2c92846fa88e94d503904
 SHA512:
-  metadata.gz: 82cc16c4f8b55d0345f3312675cbf6602365ea514b0f085f12cb9d4c8266601fcdf06d3195a06d74ef64a965ada7d9d79215ee44e70f6ac56e70c4f068cefdcd
-  data.tar.gz: eee0c6da2add0958dd836223f2a5d958e393a83f3b84b240598cf600ff0dbf73c3686e556486ad7b42e44f9781ad4905bcece9a59736e988e9532ec2d4174d4c
+  metadata.gz: 2cae21715d81d650c71df5d55b18fb7b09eb86bcfe1356e5ace3b526a48e9ff31be39d852ee43abe342dffed711c7ea08ad3a9342702960b04a864a674df6068
+  data.tar.gz: 221eb0c62f4b7158d5c95b4d7c28490a2bcabc3f4cffe64914bea62c413c0d35fc8ceab1a6b6dc81a4750e75f8d7deac522bab1d0aa97b5c02cfd7d49e9eab40

data/README.md

@@ -42,19 +42,18 @@ export PATH=/usr/lib/llvm21/bin:$PATH
 require 'lingua'
 
 lang = Lingua.detect('Bonjour le monde')
+lang.french?    # => true
 lang.to_s       # => 'French'
 lang.to_sym     # => :french
 lang.to_iso     # => 'fr'
-lang.to_iso6391 # => 'fr'
 lang.to_iso6393 # => 'fra'
-lang.inspect    # => '#<Lingua::Language French>'
 
 Lingua.detect('') # => nil
 ```
 
 ### Restricting languages
 
-Pass a `languages` option to limit detection to a subset of languages. Values can be full names, ISO 639-1 codes, or ISO 639-3 codes, and can be mixed freely.
+Pass a `languages` option to limit detection to a subset of languages. Values can be full names, ISO 639-1 codes, or ISO 639-3 codes, and can be mixed freely. Restricting the candidate set is also faster, since the detector has fewer languages to compare against.
 
 ```ruby
 # By full name
@@ -140,19 +139,37 @@ detector.detect_multiple(text)
 
 ### `Lingua::Language` methods
 
-`Lingua::Language` objects support equality (`==`) and can be used as Hash keys.
+`Lingua::Language` objects support equality (`==`) and can be used as Hash keys. You can look up a language by name, ISO 639-1 code, or ISO 639-3 code using `[]`:
+
+```ruby
+Lingua::Language['French']  # => #<Lingua::Language French>
+Lingua::Language[:fr]       # => #<Lingua::Language French>
+Lingua::Language['fra']     # => #<Lingua::Language French>
+Lingua::Language['xxx']     # => nil
+```
 
 | Method | Return type | Example |
 |---|---|---|
-| `to_s` | `String` | `'French'` |
+| `name` | `String` | `'French'` |
+| `to_s` | `String` | `'French'` (alias for `name`) |
 | `to_sym` | `Symbol` | `:french` |
+| `iso_code` | `String` | `'fr'` (alias for `to_iso6391`) |
 | `to_iso` | `String` | `'fr'` (alias for `to_iso6391`) |
 | `to_iso6391` | `String` | `'fr'` |
 | `to_iso6393` | `String` | `'fra'` |
+| `french?` | `Boolean` | `true` (works with name, ISO 639-1 or ISO 639-3: `fr?`, `fra?`) |
 | `inspect` | `String` | `'#<Lingua::Language French>'` |
 | `==` | `Boolean` | Compare two languages |
 | `hash` | `Integer` | Hash value (usable as Hash key) |
 
+Class methods:
+
+| Method | Return type | Description |
+|---|---|---|
+| `Lingua::Language.all` | `Array<Lingua::Language>` | All supported languages |
+| `Lingua::Language.names` | `Array<String>` | All language names (e.g. `'French'`) |
+| `Lingua::Language.iso_codes` | `Array<String>` | All ISO 639-1 codes (e.g. `'fr'`) |
+
 ### `Lingua::ConfidenceResult` methods
 
 Returned by `confidence_values`.
@@ -178,6 +195,60 @@ Returned by `detect_multiple`.
 | `to_s` | `String` | `'French (0-22): Parlez-vous français? '` |
 | `inspect` | `String` | `'#<Lingua::Segment French (0-22) "Parlez-vous français? ">'` |
 
+### Error handling
+
+`Lingua::UnknownLanguageError` (subclass of `ArgumentError`) is raised when an unrecognized language name or code is passed:
+
+```ruby
+Lingua.detect('Hello', languages: %w[en zzzz])
+# => Lingua::UnknownLanguageError: unknown language: "zzzz"
+
+# Can also be rescued as ArgumentError
+begin
+  Lingua.detect('Hello', languages: %w[zzzz])
+rescue ArgumentError => e
+  puts e.message
+end
+```
+
+## Optimization: selecting languages
+
+By default, all 75 languages are compiled into the native extension (~278 MB). If you only need a subset, set the `LINGUA_LANGUAGES` environment variable before installing to reduce binary size and improve detection speed:
+
+```bash
+LINGUA_LANGUAGES=core bundle install
+```
+
+This compiles only the selected language models (~29 MB for the `core` bundle). You can use individual language names or predefined bundles, and you can mix both in the same build.
+
+This also works with `gem install`, for example:
+
+```bash
+LINGUA_LANGUAGES=french,english,german gem install lingua_rs
+```
+
+Available bundles:
+
+| Bundle | Languages |
+| --- | --- |
+| `core` | `english`, `french`, `german`, `spanish`, `italian`, `portuguese` |
+| `europe_common` | `core` + `dutch`, `polish`, `russian`, `turkish` |
+| `americas` | `english`, `spanish`, `portuguese`, `french` |
+| `mena` | `arabic`, `turkish`, `persian`, `hebrew` |
+| `south_asia` | `hindi`, `urdu`, `bengali`, `tamil`, `telugu`, `punjabi`, `marathi`, `gujarati` |
+| `east_asia` | `chinese`, `japanese`, `korean`, `vietnamese`, `thai` |
+| `africa_common` | `arabic`, `english`, `french`, `swahili`, `somali`, `yoruba`, `zulu` |
+
+Examples:
+
+```bash
+LINGUA_LANGUAGES=core bundle install
+LINGUA_LANGUAGES=europe_common,polish bundle install
+LINGUA_LANGUAGES=east_asia,english bundle install
+```
+
+Language and bundle names must match the Cargo features defined by this gem (lowercase, e.g. `french`, `english`, `german`, `core`, `europe_common`).
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake compile` to build the native extension and `rake test` to run the tests.

data/ext/lingua/Cargo.toml

@@ -11,4 +11,187 @@ crate-type = ["cdylib"]
 
 [dependencies]
 magnus = { version = "0.8.2" }
-lingua = "1.8.0"
+lingua = { version = "1.8.0", default-features = false }
+
+[features]
+default = ["full"]
+full = [
+  "europe_common",
+  "americas",
+  "mena",
+  "south_asia",
+  "east_asia",
+  "africa_common",
+  "afrikaans",
+  "albanian",
+  "armenian",
+  "azerbaijani",
+  "basque",
+  "belarusian",
+  "bokmal",
+  "bosnian",
+  "bulgarian",
+  "catalan",
+  "croatian",
+  "czech",
+  "danish",
+  "esperanto",
+  "estonian",
+  "finnish",
+  "ganda",
+  "georgian",
+  "greek",
+  "hungarian",
+  "icelandic",
+  "indonesian",
+  "irish",
+  "kazakh",
+  "latin",
+  "latvian",
+  "lithuanian",
+  "macedonian",
+  "malay",
+  "maori",
+  "mongolian",
+  "nynorsk",
+  "romanian",
+  "serbian",
+  "shona",
+  "slovak",
+  "slovene",
+  "sotho",
+  "swedish",
+  "tagalog",
+  "tsonga",
+  "tswana",
+  "welsh",
+  "xhosa",
+]
+core = [
+  "english",
+  "french",
+  "german",
+  "spanish",
+  "italian",
+  "portuguese",
+]
+europe_common = [
+  "core",
+  "dutch",
+  "polish",
+  "russian",
+  "turkish",
+]
+americas = [
+  "english",
+  "spanish",
+  "portuguese",
+  "french",
+]
+mena = [
+  "arabic",
+  "turkish",
+  "persian",
+  "hebrew",
+]
+south_asia = [
+  "hindi",
+  "urdu",
+  "bengali",
+  "tamil",
+  "telugu",
+  "punjabi",
+  "marathi",
+  "gujarati",
+]
+east_asia = [
+  "chinese",
+  "japanese",
+  "korean",
+  "vietnamese",
+  "thai",
+]
+africa_common = [
+  "arabic",
+  "english",
+  "french",
+  "swahili",
+  "somali",
+  "yoruba",
+  "zulu",
+]
+afrikaans = ["lingua/afrikaans"]
+albanian = ["lingua/albanian"]
+arabic = ["lingua/arabic"]
+armenian = ["lingua/armenian"]
+azerbaijani = ["lingua/azerbaijani"]
+basque = ["lingua/basque"]
+belarusian = ["lingua/belarusian"]
+bengali = ["lingua/bengali"]
+bokmal = ["lingua/bokmal"]
+bosnian = ["lingua/bosnian"]
+bulgarian = ["lingua/bulgarian"]
+catalan = ["lingua/catalan"]
+chinese = ["lingua/chinese"]
+croatian = ["lingua/croatian"]
+czech = ["lingua/czech"]
+danish = ["lingua/danish"]
+dutch = ["lingua/dutch"]
+english = ["lingua/english"]
+esperanto = ["lingua/esperanto"]
+estonian = ["lingua/estonian"]
+finnish = ["lingua/finnish"]
+french = ["lingua/french"]
+ganda = ["lingua/ganda"]
+georgian = ["lingua/georgian"]
+german = ["lingua/german"]
+greek = ["lingua/greek"]
+gujarati = ["lingua/gujarati"]
+hebrew = ["lingua/hebrew"]
+hindi = ["lingua/hindi"]
+hungarian = ["lingua/hungarian"]
+icelandic = ["lingua/icelandic"]
+indonesian = ["lingua/indonesian"]
+irish = ["lingua/irish"]
+italian = ["lingua/italian"]
+japanese = ["lingua/japanese"]
+kazakh = ["lingua/kazakh"]
+korean = ["lingua/korean"]
+latin = ["lingua/latin"]
+latvian = ["lingua/latvian"]
+lithuanian = ["lingua/lithuanian"]
+macedonian = ["lingua/macedonian"]
+malay = ["lingua/malay"]
+maori = ["lingua/maori"]
+marathi = ["lingua/marathi"]
+mongolian = ["lingua/mongolian"]
+nynorsk = ["lingua/nynorsk"]
+persian = ["lingua/persian"]
+polish = ["lingua/polish"]
+portuguese = ["lingua/portuguese"]
+punjabi = ["lingua/punjabi"]
+romanian = ["lingua/romanian"]
+russian = ["lingua/russian"]
+serbian = ["lingua/serbian"]
+shona = ["lingua/shona"]
+slovak = ["lingua/slovak"]
+slovene = ["lingua/slovene"]
+somali = ["lingua/somali"]
+sotho = ["lingua/sotho"]
+spanish = ["lingua/spanish"]
+swahili = ["lingua/swahili"]
+swedish = ["lingua/swedish"]
+tagalog = ["lingua/tagalog"]
+tamil = ["lingua/tamil"]
+telugu = ["lingua/telugu"]
+thai = ["lingua/thai"]
+tsonga = ["lingua/tsonga"]
+tswana = ["lingua/tswana"]
+turkish = ["lingua/turkish"]
+ukrainian = ["lingua/ukrainian"]
+urdu = ["lingua/urdu"]
+vietnamese = ["lingua/vietnamese"]
+welsh = ["lingua/welsh"]
+xhosa = ["lingua/xhosa"]
+yoruba = ["lingua/yoruba"]
+zulu = ["lingua/zulu"]

data/ext/lingua/extconf.rb

@@ -3,4 +3,13 @@
 require 'mkmf'
 require 'rb_sys/mkmf'
 
-create_rust_makefile('lingua/lingua')
+# Allow users to select specific languages to reduce binary size.
+# Example: LINGUA_LANGUAGES=french,english,german bundle install
+languages = ENV.fetch('LINGUA_LANGUAGES', '').split(',').map { |lang| lang.strip.downcase }
+
+create_rust_makefile('lingua/lingua') do |r|
+  unless languages.empty?
+    r.extra_cargo_args << '--no-default-features'
+    r.features = languages
+  end
+end

data/ext/lingua/src/confidence_result.rs

@@ -1,7 +1,18 @@
 use lingua::Language;
+use magnus::{Error, RModule, Ruby, method, prelude::*};
 
 use crate::language::WrappedLanguage;
 
+pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("ConfidenceResult", ruby.class_object())?;
+    class.undef_default_alloc_func();
+    class.define_method("language", method!(ConfidenceResult::language, 0))?;
+    class.define_method("confidence", method!(ConfidenceResult::confidence, 0))?;
+    class.define_method("to_s", method!(ConfidenceResult::to_s, 0))?;
+    class.define_method("inspect", method!(ConfidenceResult::inspect, 0))?;
+    Ok(())
+}
+
 #[magnus::wrap(class = "Lingua::ConfidenceResult")]
 pub struct ConfidenceResult {
     pub language: Language,

data/ext/lingua/src/detector.rs

@@ -1,11 +1,21 @@
 use lingua::{LanguageDetector, LanguageDetectorBuilder};
-use magnus::{Error, RArray, RHash, Ruby};
+use magnus::{Error, RArray, RHash, RModule, Ruby, function, method, prelude::*};
 
 use crate::confidence_result::ConfidenceResult;
 use crate::segment::Segment;
-use crate::helpers::{fetch_option, parse_language, value_to_string};
+use crate::helpers::{fetch_option, parse_language, unknown_language_error, value_to_string};
 use crate::language::WrappedLanguage;
 
+pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("Detector", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RubyDetector::new, -1))?;
+    class.define_method("detect", method!(RubyDetector::detect, 1))?;
+    class.define_method("confidence", method!(RubyDetector::confidence, 2))?;
+    class.define_method("confidence_values", method!(RubyDetector::confidence_values, 1))?;
+    class.define_method("detect_multiple", method!(RubyDetector::detect_multiple, 1))?;
+    Ok(())
+}
+
 pub fn compute_confidence(
     detector: &LanguageDetector,
     subject: String,
@@ -15,7 +25,7 @@ pub fn compute_confidence(
     let language_str = value_to_string(language)?;
     let lang = parse_language(&language_str).ok_or_else(|| {
         Error::new(
-            ruby.exception_arg_error(),
+            unknown_language_error(&ruby),
             format!("unknown language: \"{language_str}\""),
         )
     })?;
@@ -106,7 +116,7 @@ pub fn build_detector_from_options(
         for l in &raw_languages {
             let lang = parse_language(l).ok_or_else(|| {
                 Error::new(
-                    ruby.exception_arg_error(),
+                    unknown_language_error(ruby),
                     format!("unknown language: \"{l}\""),
                 )
             })?;

data/ext/lingua/src/helpers.rs

@@ -1,7 +1,23 @@
 use std::str::FromStr;
+use std::cell::Cell;
 
 use lingua::{IsoCode639_1, IsoCode639_3, Language};
-use magnus::{Error, Ruby, Symbol, prelude::*};
+use magnus::{ExceptionClass, Error, RModule, Ruby, Symbol, prelude::*};
+
+thread_local! {
+    static UNKNOWN_LANGUAGE_ERROR: Cell<Option<ExceptionClass>> = const { Cell::new(None) };
+}
+
+pub fn define_errors(module: &RModule) -> Result<(), Error> {
+    let ruby = Ruby::get().unwrap();
+    let class = module.define_error("UnknownLanguageError", ruby.exception_arg_error())?;
+    UNKNOWN_LANGUAGE_ERROR.set(Some(class));
+    Ok(())
+}
+
+pub fn unknown_language_error(ruby: &Ruby) -> ExceptionClass {
+    UNKNOWN_LANGUAGE_ERROR.get().unwrap_or_else(|| ruby.exception_arg_error())
+}
 
 pub fn parse_language(input: &str) -> Option<Language> {
     Language::from_str(input)

data/ext/lingua/src/language.rs

@@ -1,11 +1,72 @@
 use lingua::Language;
-use magnus::{Ruby, Symbol};
+use magnus::{Error, RArray, RModule, Ruby, Symbol, function, method, prelude::*};
+
+use crate::helpers::value_to_string;
+
+pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("Language", ruby.class_object())?;
+    class.undef_default_alloc_func();
+    class.define_method("name", method!(WrappedLanguage::name, 0))?;
+    class.define_method("to_s", method!(WrappedLanguage::name, 0))?;
+    class.define_method("to_iso6391", method!(WrappedLanguage::to_iso6391, 0))?;
+    class.define_method("to_iso", method!(WrappedLanguage::to_iso6391, 0))?;
+    class.define_method("iso_code", method!(WrappedLanguage::to_iso6391, 0))?;
+    class.define_method("to_iso6393", method!(WrappedLanguage::to_iso6393, 0))?;
+    class.define_method("to_sym", method!(WrappedLanguage::to_sym, 0))?;
+    class.define_method("inspect", method!(WrappedLanguage::inspect, 0))?;
+    class.define_method("==", method!(WrappedLanguage::eq, 1))?;
+    class.define_method("eql?", method!(WrappedLanguage::eq, 1))?;
+    class.define_method("hash", method!(WrappedLanguage::hash, 0))?;
+    class.define_singleton_method("[]", function!(WrappedLanguage::lookup, 1))?;
+    class.define_singleton_method("all", function!(WrappedLanguage::all, 0))?;
+    class.define_singleton_method("names", function!(WrappedLanguage::names, 0))?;
+    class.define_singleton_method("iso_codes", function!(WrappedLanguage::iso_codes, 0))?;
+    Ok(())
+}
 
 #[magnus::wrap(class = "Lingua::Language")]
 pub struct WrappedLanguage(pub Language);
 
 impl WrappedLanguage {
-    pub fn to_s(&self) -> String {
+    pub fn lookup(value: magnus::Value) -> Result<Option<WrappedLanguage>, Error> {
+        let input = value_to_string(value)?;
+        Ok(crate::helpers::parse_language(&input).map(WrappedLanguage))
+    }
+
+    pub fn all() -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
+        let mut langs: Vec<Language> = Language::all().into_iter().collect();
+        langs.sort_by(|a, b| a.to_string().cmp(&b.to_string()));
+        let array = ruby.ary_new_capa(langs.len());
+        for lang in langs {
+            array.push(WrappedLanguage(lang))?;
+        }
+        Ok(array)
+    }
+
+    pub fn names() -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
+        let mut langs: Vec<Language> = Language::all().into_iter().collect();
+        langs.sort_by(|a, b| a.to_string().cmp(&b.to_string()));
+        let array = ruby.ary_new_capa(langs.len());
+        for lang in langs {
+            array.push(lang.to_string())?;
+        }
+        Ok(array)
+    }
+
+    pub fn iso_codes() -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
+        let mut langs: Vec<Language> = Language::all().into_iter().collect();
+        langs.sort_by(|a, b| a.to_string().cmp(&b.to_string()));
+        let array = ruby.ary_new_capa(langs.len());
+        for lang in langs {
+            array.push(lang.iso_code_639_1().to_string())?;
+        }
+        Ok(array)
+    }
+
+    pub fn name(&self) -> String {
         self.0.to_string()
     }
 

data/ext/lingua/src/lib.rs

@@ -1,14 +1,12 @@
 mod confidence_result;
-mod segment;
 mod detector;
 mod helpers;
 mod language;
+mod segment;
 
-use magnus::{Error, RArray, RHash, Ruby, function, method, prelude::*};
+use magnus::{Error, RArray, RHash, Ruby, function, prelude::*};
 
-use confidence_result::ConfidenceResult;
-use segment::Segment;
-use detector::{RubyDetector, build_detector_from_options, compute_confidence, compute_confidence_values, compute_detect_multiple};
+use detector::{build_detector_from_options, compute_confidence, compute_confidence_values, compute_detect_multiple};
 use language::WrappedLanguage;
 
 fn detect(ruby: &Ruby, arguments: RArray) -> Result<Option<WrappedLanguage>, Error> {
@@ -47,47 +45,12 @@ fn detect_multiple(ruby: &Ruby, arguments: RArray) -> Result<RArray, Error> {
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("Lingua")?;
 
-    // Lingua::Language
-    let language_class = module.define_class("Language", ruby.class_object())?;
-    language_class.undef_default_alloc_func();
-    language_class.define_method("to_s", method!(WrappedLanguage::to_s, 0))?;
-    language_class.define_method("to_iso6391", method!(WrappedLanguage::to_iso6391, 0))?;
-    language_class.define_method("to_iso", method!(WrappedLanguage::to_iso6391, 0))?;
-    language_class.define_method("to_iso6393", method!(WrappedLanguage::to_iso6393, 0))?;
-    language_class.define_method("to_sym", method!(WrappedLanguage::to_sym, 0))?;
-    language_class.define_method("inspect", method!(WrappedLanguage::inspect, 0))?;
-    language_class.define_method("==", method!(WrappedLanguage::eq, 1))?;
-    language_class.define_method("eql?", method!(WrappedLanguage::eq, 1))?;
-    language_class.define_method("hash", method!(WrappedLanguage::hash, 0))?;
-
-    // Lingua::ConfidenceResult
-    let confidence_class = module.define_class("ConfidenceResult", ruby.class_object())?;
-    confidence_class.undef_default_alloc_func();
-    confidence_class.define_method("language", method!(ConfidenceResult::language, 0))?;
-    confidence_class.define_method("confidence", method!(ConfidenceResult::confidence, 0))?;
-    confidence_class.define_method("to_s", method!(ConfidenceResult::to_s, 0))?;
-    confidence_class.define_method("inspect", method!(ConfidenceResult::inspect, 0))?;
-
-    // Lingua::Segment
-    let segment_class = module.define_class("Segment", ruby.class_object())?;
-    segment_class.undef_default_alloc_func();
-    segment_class.define_method("language", method!(Segment::language, 0))?;
-    segment_class.define_method("start_index", method!(Segment::start_index, 0))?;
-    segment_class.define_method("end_index", method!(Segment::end_index, 0))?;
-    segment_class.define_method("word_count", method!(Segment::word_count, 0))?;
-    segment_class.define_method("text", method!(Segment::text, 0))?;
-    segment_class.define_method("to_s", method!(Segment::to_s, 0))?;
-    segment_class.define_method("inspect", method!(Segment::inspect, 0))?;
-
-    // Lingua::Detector
-    let detector_class = module.define_class("Detector", ruby.class_object())?;
-    detector_class.define_singleton_method("new", function!(RubyDetector::new, -1))?;
-    detector_class.define_method("detect", method!(RubyDetector::detect, 1))?;
-    detector_class.define_method("confidence", method!(RubyDetector::confidence, 2))?;
-    detector_class.define_method("confidence_values", method!(RubyDetector::confidence_values, 1))?;
-    detector_class.define_method("detect_multiple", method!(RubyDetector::detect_multiple, 1))?;
+    helpers::define_errors(&module)?;
+    language::define(ruby, &module)?;
+    confidence_result::define(ruby, &module)?;
+    segment::define(ruby, &module)?;
+    detector::define(ruby, &module)?;
 
-    // Functional API (module methods)
     module.define_singleton_method("detect", function!(detect, -2))?;
     module.define_singleton_method("confidence", function!(confidence, 2))?;
     module.define_singleton_method("confidence_values", function!(confidence_values, -2))?;

data/ext/lingua/src/segment.rs

@@ -1,7 +1,21 @@
 use lingua::Language;
+use magnus::{Error, RModule, Ruby, method, prelude::*};
 
 use crate::language::WrappedLanguage;
 
+pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("Segment", ruby.class_object())?;
+    class.undef_default_alloc_func();
+    class.define_method("language", method!(Segment::language, 0))?;
+    class.define_method("start_index", method!(Segment::start_index, 0))?;
+    class.define_method("end_index", method!(Segment::end_index, 0))?;
+    class.define_method("word_count", method!(Segment::word_count, 0))?;
+    class.define_method("text", method!(Segment::text, 0))?;
+    class.define_method("to_s", method!(Segment::to_s, 0))?;
+    class.define_method("inspect", method!(Segment::inspect, 0))?;
+    Ok(())
+}
+
 #[magnus::wrap(class = "Lingua::Segment")]
 pub struct Segment {
     pub language: Language,

data/lib/lingua/language.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lingua
+  # Represents a language returned by Lingua detection and lookup APIs.
+  class Language
+    private
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.end_with?('?') || super
+    end
+
+    def method_missing(method_name, *args)
+      if method_name.end_with?('?') && args.empty?
+        match = Lingua::Language[method_name.name.delete_suffix('?')]
+        !match.nil? && self == match
+      else
+        super
+      end
+    end
+  end
+end

data/lib/lingua/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lingua
-  VERSION = '0.2.0'
+  VERSION = '0.4.1'
 end

data/lib/lingua.rb

@@ -2,6 +2,7 @@
 
 require_relative 'lingua/version'
 require_relative 'lingua/lingua'
+require_relative 'lingua/language'
 
 module Lingua
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lingua_rs
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Sébastien Vrillaud
@@ -43,11 +43,9 @@ email:
 - kochka@gmail.com
 executables: []
 extensions:
-- ext/lingua/Cargo.toml
+- ext/lingua/extconf.rb
 extra_rdoc_files: []
 files:
-- Cargo.lock
-- Cargo.toml
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -61,6 +59,7 @@ files:
 - ext/lingua/src/lib.rs
 - ext/lingua/src/segment.rs
 - lib/lingua.rb
+- lib/lingua/language.rb
 - lib/lingua/version.rb
 - sig/lingua.rbs
 homepage: https://github.com/kochka/lingua_rs