lingua_rb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cce8c73b05d7c7ded3928199e4f37454d4b0fbfc80ed83a3387b0d8a7b64458f
-  data.tar.gz: 62b140512e592b10fff2714f5d4a9c86bd0ee71cf00416ee92780ac4b5db168b
+  metadata.gz: 2b52fd46953ea949cc49052d39d9bb3db51bedbb0d00ef67b15c2ff719f87d33
+  data.tar.gz: c301b18948807f2280511addc927112a92f6f54f78bb5b80f76076284e8dae64
 SHA512:
-  metadata.gz: 39f1e4ce02afd74c856704dbad062b7ea5cbe9ccfc1f4b05ac7a6252aa36f4473218650728445258c0df64a0ff69f03b3334672507c2a6a77e9f9e16c9f16da5
-  data.tar.gz: 021e57cbb9366957ffab790ff6c7413312c68d68f2f3585e37b900a9ee0afb9db3a225384213b1c068f9b83aeb611814b0337bf2e070708d877c80abc18b7658
+  metadata.gz: 8dcbcd7372dcfa9b8946e5ece99ccca4043313ed718bfcaeac31667377272b6ad344c6556153a7854ee93cb1cbf169327cbdeb10982f6ec3dd35365693a4dc8a
+  data.tar.gz: 66ea01be4ea8a87ea088f4209e0babf86487dee721121688fd8432111579b1c4d1431591c6c046e9b517164214f93bba8bfee2b84b12417ce7f3ab6a6d245e6f

data/CHANGELOG.md

@@ -1,4 +1,8 @@
-## [Unreleased]
+## [Released]
+
+## [0.2.0] - 2024-05-24
+
+- Add support for builder options
 
 ## [0.1.0] - 2024-05-21
 

data/Cargo.lock

@@ -310,7 +310,7 @@ dependencies = [
 
 [[package]]
 name = "lingua"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "lingua 1.6.2",
  "magnus",

data/README.md

@@ -1,5 +1,10 @@
 # Lingua
 
+[![Gem Version](https://badge.fury.io/rb/lingua_rb.svg)](https://badge.fury.io/rb/lingua_rb)
+![CI](https://github.com/ShallmentMo/lingua_rb/actions/workflows/main.yml/badge.svg)
+![License](https://img.shields.io/github/license/ShallmentMo/lingua_rb)
+![Gems](https://img.shields.io/gem/dt/lingua_rb)
+
 Lingua is an [Ruby][0] wrapper for the [Rust][1] [lingua][2] crate with [magnus][3].
 
 ## Installation
@@ -17,8 +22,19 @@ If bundler is not being used to manage dependencies, install the gem by executin
 ```ruby
 irb> Lingua.detect("this is definitely English")
 => "English"
+
+irb> Lingua.detect("וזה בעברית")
+=> "Hebrew"
+
+irb> Lingua.detect("państwowych", languages: %w[english russian polish])
+=> "Polish"
+
+irb> Lingua.detect("כלב", languages: %w[english russian polish])
+=> nil
 ```
 
+**Note:** The value of `languages` option should be an array of String. An array of symbols will be ignored.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/ext/lingua/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lingua"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 authors = ["ShallmentMo <shallmentmo@gmail.com>"]
 license = "MIT"

data/ext/lingua/src/lib.rs

@@ -1,16 +1,83 @@
+use std::str::FromStr;
+
 use lingua::{Language, LanguageDetector, LanguageDetectorBuilder};
-use magnus::{function, prelude::*, Error, Ruby};
+use magnus::{function, prelude::*, Error, Ruby, Symbol};
+
+fn detect(arguments: magnus::RArray) -> Option<String> {
+    match arguments.len() {
+        1 => {
+            let subject = arguments.shift::<String>().unwrap();
+            let detector: LanguageDetector = LanguageDetectorBuilder::from_all_languages().build();
+            let detected_language: Option<Language> = detector.detect_language_of(subject);
 
-fn detect(subject: String) -> Option<String> {
-    let detector: LanguageDetector = LanguageDetectorBuilder::from_all_languages().build();
-    let detected_language: Option<Language> = detector.detect_language_of(subject);
+            detected_language.map(|language| language.to_string())
+        }
+        2 => {
+            let subject = arguments.shift::<String>().unwrap();
+            let options = arguments.shift::<magnus::RHash>().unwrap();
+            let mut builder = match options.fetch::<Symbol, Vec<String>>(Symbol::new("languages")) {
+                Ok(languages) => {
+                    let languages: Vec<Language> = languages
+                        .into_iter()
+                        .filter_map(|l| Language::from_str(&l).ok())
+                        .collect();
+                    Some(LanguageDetectorBuilder::from_languages(&languages))
+                }
+                Err(_) => None,
+            };
+            if builder.is_none() {
+                builder = match options.fetch::<&str, Vec<String>>("languages") {
+                    Ok(languages) => {
+                        let languages: Vec<Language> = languages
+                            .into_iter()
+                            .filter_map(|l| Language::from_str(&l).ok())
+                            .collect();
+                        Some(LanguageDetectorBuilder::from_languages(&languages))
+                    }
+                    Err(_) => None,
+                };
+            }
+            let mut builder = builder.unwrap_or_else(LanguageDetectorBuilder::from_all_languages);
+            if let Ok(minimum_relative_distance) =
+                options.fetch::<&str, f64>("minimum_relative_distance")
+            {
+                builder.with_minimum_relative_distance(minimum_relative_distance);
+            };
+            if let Ok(minimum_relative_distance) =
+                options.fetch::<Symbol, f64>(Symbol::new("minimum_relative_distance"))
+            {
+                builder.with_minimum_relative_distance(minimum_relative_distance);
+            };
+            if options
+                .fetch::<&str, bool>("is_every_language_model_preloaded")
+                .unwrap_or(false)
+                || options
+                    .fetch::<Symbol, bool>(Symbol::new("is_every_language_model_preloaded"))
+                    .unwrap_or(false)
+            {
+                builder.with_preloaded_language_models();
+            };
+            if options
+                .fetch::<&str, bool>("is_low_accuracy_mode_enabled")
+                .unwrap_or(false)
+                || options
+                    .fetch::<Symbol, bool>(Symbol::new("is_low_accuracy_mode_enabled"))
+                    .unwrap_or(false)
+            {
+                builder.with_low_accuracy_mode();
+            };
+            let detector = builder.build();
+            let detected_language: Option<Language> = detector.detect_language_of(subject);
 
-    detected_language.map(|language| language.to_string())
+            detected_language.map(|language| language.to_string())
+        }
+        _ => None,
+    }
 }
 
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("Lingua")?;
-    module.define_singleton_method("detect", function!(detect, 1))?;
+    module.define_singleton_method("detect", function!(detect, -2))?;
     Ok(())
 }

data/lib/lingua/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lingua_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - ShallmentMo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-21 00:00:00.000000000 Z
+date: 2024-05-24 00:00:00.000000000 Z
 dependencies: []
 description: An Ruby wrapper around the Rust Lingua language detection library.
 email: