lingua_rs 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c52e545860174c156f8e8276d25762293daa3235766fc88777e5d2b5d53f50f5
-  data.tar.gz: 90bb85fd278795e300b768e3e5079d465f9c5b85a7c3a62f61c4e45745b5ba96
+  metadata.gz: e301297292f2de86fd62416f6f06765c7ccd373c81020e2ad365e0c0151a55bf
+  data.tar.gz: fe961910a3e44fa7df10580100b4aecef6f2552c08a7faba278a84eaf7ae89fc
 SHA512:
-  metadata.gz: 82cc16c4f8b55d0345f3312675cbf6602365ea514b0f085f12cb9d4c8266601fcdf06d3195a06d74ef64a965ada7d9d79215ee44e70f6ac56e70c4f068cefdcd
-  data.tar.gz: eee0c6da2add0958dd836223f2a5d958e393a83f3b84b240598cf600ff0dbf73c3686e556486ad7b42e44f9781ad4905bcece9a59736e988e9532ec2d4174d4c
+  metadata.gz: 31e45f89765b5feb782a8b47f9574891c9ce826b5883f840b5f0d06c8715f26c9d9caa999a8e08349f475e307b2ccd28ecb303677ae8e51caa79920d94cc91fc
+  data.tar.gz: 6ace3072e3b7e8e044c55712879ea398dc7f009475cb058444070cd22834bb7f4fa6525ab4a66bab95417d57b1f57b9599cda02dd159be80603280c0646b6414

data/README.md

@@ -140,11 +140,19 @@ 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` |
 | `to_iso` | `String` | `'fr'` (alias for `to_iso6391`) |
 | `to_iso6391` | `String` | `'fr'` |
@@ -153,6 +161,14 @@ detector.detect_multiple(text)
 | `==` | `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`.

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::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,

data/ext/lingua/src/language.rs

@@ -1,11 +1,71 @@
 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("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,11 @@ 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))?;
+    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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lingua_rs
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Sébastien Vrillaud