rucaptcha 3.2.5-x86_64-linux → 3.3.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8dd3f1501e693e7a69ef7115f6d1ea3adb15caeef4e4649651344b61f303ccf9
-  data.tar.gz: 3ddb556df1cf4faeff1115a95304c394a32e88e2142f78fc98e150a750d17227
+  metadata.gz: 5578e26fd5d00a66f195d2b0e98c1b10cd738f4498e1b1f3e4229ffac024ef11
+  data.tar.gz: 4f8febfb4eeb129b6d80b03edf894d7bf0e0fa2385009c6c058301febdb3ca5d
 SHA512:
-  metadata.gz: 679431548e74a72c091077034c0eec66f92a39b50b602826187cf3ed99d8ea1df818a03cb3ad3f215f69682c9cefdfdce3720be667fdb76337ef119b636c6db2
-  data.tar.gz: 63dca6a6919f008481431c949a1d495a00f9daaed72d75ce2ff02165a3ba1aded07f5e145554a0376ecbca9144e9409691d6504b06f69734df895663f670724c
+  metadata.gz: d1bd86e3478886f669d483483931b09a72b6656454b5e43b8f044038495718f83be3043c8b2d3f4ea01dfa3ceb330db2a4085b01cdcdbf0120ac96d1c3bcd263
+  data.tar.gz: af51aadc047819524c0a228cd73089835def1525b54d4e0a78082538784e23818a197270f7029e4889c1492f8ab390020ba6c55bfd0f8f20a55e9a9b474fb5dc

data/README.md

@@ -59,6 +59,16 @@ RuCaptcha.configure do
   # Enable or disable noise, default: false
   # self.noise = false
 
+  # Enable or disable circle background, default: true
+  # self.circle = true
+
+  # Set the difficulty level, default: 5, allows: [1..10].
+  # Only valid when noise is enabled
+  # self.difficulty = 5
+
+  # Set the case sensitive, default: false
+  # self.case_sensitive = false
+
   # Set the image format, default: png, allows: [jpeg, png, webp]
   # self.format = 'png'
 
@@ -181,11 +191,13 @@ end
 
 ## Performance
 
+> Based on MacBook Pro (Apple M3)
+
 `rake benchmark` to run benchmark test.
 
 ```
 Warming up --------------------------------------
-      Generate image    51.000  i/100ms
+      Generate image    84.000 i/100ms
 Calculating -------------------------------------
-      Generate image    526.350  (± 2.5%) i/s -      2.652k in   5.041681s
+      Generate image    859.075 (± 1.5%) i/s    (1.16 ms/i) -      4.368k in   5.085775s
 ```

data/Rakefile

@@ -30,7 +30,7 @@ task default: :spec
 
 def create_captcha(length = 5, difficulty = 5)
   require "rucaptcha"
-  RuCaptchaCore.create(length, difficulty, false, false, "png")
+  RuCaptchaCore.create(length, difficulty, false, false, false, "png")
 end
 
 task :preview do
@@ -63,10 +63,10 @@ task :benchmark do
   require "rucaptcha"
   require "benchmark/ips"
 
-  RuCaptchaCore.create(5, 5, true, true, "png")
+  RuCaptchaCore.create(5, 5, true, true, true, "png")
 
   Benchmark.ips do |x|
-    x.report("Generate image") { RuCaptchaCore.create(5, 5, true, true, "png") }
+    x.report("Generate image") { RuCaptchaCore.create(5, 5, true, true, true, "png") }
     x.compare!
   end
 end

data/ext/rucaptcha/src/captcha.rs

@@ -1,7 +1,11 @@
 use image::{ImageBuffer, Rgba};
+use imageproc::{
+    drawing::{draw_cubic_bezier_curve_mut, draw_filled_ellipse_mut},
+    noise::gaussian_noise_mut,
+};
 use rand::{thread_rng, Rng};
 use rusttype::{Font, Scale};
-use std::io::Cursor;
+use std::{io::Cursor, sync::LazyLock};
 
 static BASIC_CHAR: [char; 54] = [
     '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'M',
@@ -9,9 +13,6 @@ static BASIC_CHAR: [char; 54] = [
     'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
 ];
 
-static FONT_BYTES1: &[u8; 145008] = include_bytes!("../fonts/FuzzyBubbles-Regular.ttf");
-static FONT_BYTES2: &[u8; 37792] = include_bytes!("../fonts/Handlee-Regular.ttf");
-
 // https://coolors.co/cc0b8f-7c0abe-5700c8-3c2ea4-3d56a8-3fa67e-45bb30-69d003-a0d003-d8db02
 static COLORS: [(u8, u8, u8, u8); 14] = [
     (197, 166, 3, 255),
@@ -33,32 +34,34 @@ static COLORS: [(u8, u8, u8, u8); 14] = [
 static SCALE_SM: u32 = 32;
 static SCALE_MD: u32 = 45;
 static SCALE_LG: u32 = 55;
+static FONT_0: LazyLock<Font> = LazyLock::new(|| {
+    Font::try_from_bytes(include_bytes!("../fonts/FuzzyBubbles-Regular.ttf")).unwrap()
+});
+static FONT_1: LazyLock<Font> =
+    LazyLock::new(|| Font::try_from_bytes(include_bytes!("../fonts/Handlee-Regular.ttf")).unwrap());
 
+#[inline(always)]
 fn rand_num(len: usize) -> usize {
     let mut rng = thread_rng();
     rng.gen_range(0..=len)
 }
 
-fn get_captcha(len: usize) -> Vec<String> {
-    let mut res = vec![];
+/// Generate a random captcha string with a given length
+#[inline]
+fn rand_captcha(len: usize) -> String {
+    let mut result = String::with_capacity(len);
+    let seed = BASIC_CHAR.len() - 1;
     for _ in 0..len {
-        let rnd = rand_num(53);
-        res.push(BASIC_CHAR[rnd].to_string())
+        let rnd = rand_num(seed);
+        result.push(BASIC_CHAR[rnd])
     }
-    res
-}
-
-#[allow(unused)]
-fn get_color() -> Rgba<u8> {
-    let rnd = rand_num(COLORS.len() - 1);
-    let c = COLORS[rnd];
-    Rgba([c.0, c.1, c.2, c.3])
+    result
 }
 
-fn get_colors(num: usize) -> Vec<Rgba<u8>> {
+fn get_colors(len: usize) -> Vec<Rgba<u8>> {
     let rnd = rand_num(COLORS.len());
-    let mut out = vec![];
-    for i in 0..num {
+    let mut out = Vec::with_capacity(len);
+    for i in 0..len {
         let c = COLORS[(rnd + i) % COLORS.len()];
         out.push(Rgba([c.0, c.1, c.2, c.3]))
     }
@@ -66,78 +69,11 @@ fn get_colors(num: usize) -> Vec<Rgba<u8>> {
     out
 }
 
+#[inline(always)]
 fn get_next(min: f32, max: u32) -> f32 {
     min + rand_num(max as usize - min as usize) as f32
 }
 
-fn get_font() -> Font<'static> {
-    match rand_num(2) {
-        0 => Font::try_from_bytes(FONT_BYTES1).unwrap(),
-        1 => Font::try_from_bytes(FONT_BYTES2).unwrap(),
-        _ => Font::try_from_bytes(FONT_BYTES1).unwrap(),
-    }
-}
-
-fn get_image(width: usize, height: usize) -> ImageBuffer<Rgba<u8>, Vec<u8>> {
-    ImageBuffer::from_fn(width as u32, height as u32, |_, _| {
-        image::Rgba([255, 255, 255, 255])
-    })
-}
-
-fn cyclic_write_character(res: &[String], image: &mut ImageBuffer<Rgba<u8>, Vec<u8>>, lines: bool) {
-    let c = (image.width() - 20) / res.len() as u32;
-    let y = image.height() / 3 - 15;
-
-    let h = image.height() as f32;
-
-    let scale = match res.len() {
-        1..=3 => SCALE_LG,
-        4..=5 => SCALE_MD,
-        _ => SCALE_SM,
-    } as f32;
-
-    let colors = get_colors(res.len());
-    let line_colors = get_colors(res.len());
-
-    let xscale = scale - rand_num((scale * 0.2) as usize) as f32;
-    let yscale = h as f32 - rand_num((h * 0.2) as usize) as f32;
-
-    // Draw line, ellipse first as background
-    for (i, _) in res.iter().enumerate() {
-        let line_color = line_colors[i];
-
-        if lines {
-            draw_interference_line(1, image, line_color);
-        }
-        draw_interference_ellipse(1, image, line_color);
-    }
-
-    // Draw text
-    for (i, _) in res.iter().enumerate() {
-        let text = &res[i];
-
-        let color = colors[i];
-        let font = get_font();
-
-        for j in 0..(rand_num(3) + 1) as i32 {
-            // Draw text again with offset
-            let offset = j * (rand_num(2) as i32);
-            imageproc::drawing::draw_text_mut(
-                image,
-                color,
-                10 + offset + (i as u32 * c) as i32,
-                y as i32 as i32,
-                Scale {
-                    x: xscale + offset as f32,
-                    y: yscale as f32,
-                },
-                &font,
-                text,
-            );
-        }
-    }
-}
-
 fn draw_interference_line(num: usize, image: &mut ImageBuffer<Rgba<u8>, Vec<u8>>, color: Rgba<u8>) {
     for _ in 0..num {
         let width = image.width();
@@ -154,7 +90,7 @@ fn draw_interference_line(num: usize, image: &mut ImageBuffer<Rgba<u8>, Vec<u8>>
         let ctrl_x2 = get_next((width / 12) as f32, width / 12 * 3);
         let ctrl_y2 = get_next(x1, height - 5);
         // Randomly draw bezier curves
-        imageproc::drawing::draw_cubic_bezier_curve_mut(
+        draw_cubic_bezier_curve_mut(
             image,
             (x1, y1),
             (x2, y2),
@@ -176,7 +112,7 @@ fn draw_interference_ellipse(
         let x = rand_num((image.width() - 25) as usize) as i32;
         let y = rand_num((image.height() - 15) as usize) as i32;
 
-        imageproc::drawing::draw_filled_ellipse_mut(image, (x, y), w, w, color);
+        draw_filled_ellipse_mut(image, (x, y), w, w, color);
     }
 }
 
@@ -187,16 +123,17 @@ pub struct Captcha {
 
 pub struct CaptchaBuilder {
     length: usize,
-    width: usize,
-    height: usize,
+    width: u32,
+    height: u32,
     complexity: usize,
     line: bool,
     noise: bool,
+    circle: bool,
     format: image::ImageFormat,
 }
 
-impl CaptchaBuilder {
-    pub fn new() -> Self {
+impl Default for CaptchaBuilder {
+    fn default() -> Self {
         CaptchaBuilder {
             length: 4,
             width: 220,
@@ -204,9 +141,16 @@ impl CaptchaBuilder {
             complexity: 5,
             line: true,
             noise: false,
+            circle: true,
             format: image::ImageFormat::Png,
         }
     }
+}
+
+impl CaptchaBuilder {
+    pub fn new() -> Self {
+        Self::default()
+    }
 
     pub fn length(mut self, length: usize) -> Self {
         self.length = length;
@@ -223,6 +167,11 @@ impl CaptchaBuilder {
         self
     }
 
+    pub fn circle(mut self, circle: bool) -> Self {
+        self.circle = circle;
+        self
+    }
+
     pub fn format(mut self, format: &str) -> Self {
         self.format = match format {
             "png" => image::ImageFormat::Png,
@@ -235,32 +184,89 @@ impl CaptchaBuilder {
     }
 
     pub fn complexity(mut self, complexity: usize) -> Self {
-        let mut complexity = complexity;
-        if complexity > 10 {
-            complexity = 10;
+        self.complexity = complexity.clamp(1, 10);
+        self
+    }
+
+    fn cyclic_write_character(
+        &self,
+        captcha: &str,
+        image: &mut ImageBuffer<Rgba<u8>, Vec<u8>>,
+        lines: bool,
+    ) {
+        let c = (image.width() - 20) / captcha.len() as u32;
+        let y = image.height() / 3 - 15;
+
+        let h = image.height() as f32;
+
+        let scale = match captcha.len() {
+            1..=3 => SCALE_LG,
+            4..=5 => SCALE_MD,
+            _ => SCALE_SM,
+        } as f32;
+
+        let colors = get_colors(captcha.len());
+        let line_colors = get_colors(captcha.len());
+
+        let xscale = scale - rand_num((scale * 0.2) as usize) as f32;
+        let yscale = h - rand_num((h * 0.2) as usize) as f32;
+
+        // Draw line, ellipse first as background
+        if self.circle {
+            (0..captcha.len()).for_each(|i| {
+                let line_color = line_colors[i];
+
+                if lines {
+                    draw_interference_line(1, image, line_color);
+                }
+                draw_interference_ellipse(1, image, line_color);
+            });
         }
-        if complexity < 1 {
-            complexity = 1;
+
+        let font = match rand_num(2) {
+            0 => &FONT_0,
+            1 => &FONT_1,
+            _ => &FONT_1,
+        };
+
+        // Draw text
+        for (i, ch) in captcha.chars().enumerate() {
+            let color = colors[i];
+
+            for j in 0..(rand_num(3) + 1) as i32 {
+                // Draw text again with offset
+                let offset = j * (rand_num(2) as i32);
+                imageproc::drawing::draw_text_mut(
+                    image,
+                    color,
+                    10 + offset + (i as u32 * c) as i32,
+                    y as i32,
+                    Scale {
+                        x: xscale + offset as f32,
+                        y: yscale as f32,
+                    },
+                    font,
+                    &ch.to_string(),
+                );
+            }
         }
-        self.complexity = complexity;
-        self
     }
 
     pub fn build(self) -> Captcha {
         // Generate an array of captcha characters
-        let res = get_captcha(self.length);
-
-        let text = res.join("");
+        let text = rand_captcha(self.length);
 
         // Create a white background image
-        let mut image = get_image(self.width, self.height);
+        let mut buf = ImageBuffer::from_fn(self.width, self.height, |_, _| {
+            image::Rgba([255, 255, 255, 255])
+        });
 
         // Loop to write the verification code string into the background image
-        cyclic_write_character(&res, &mut image, self.line);
+        self.cyclic_write_character(&text, &mut buf, self.line);
 
         if self.noise {
-            imageproc::noise::gaussian_noise_mut(
-                &mut image,
+            gaussian_noise_mut(
+                &mut buf,
                 (self.complexity - 1) as f64,
                 ((10 * self.complexity) - 10) as f64,
                 ((5 * self.complexity) - 5) as u64,
@@ -268,9 +274,8 @@ impl CaptchaBuilder {
         }
 
         let mut bytes: Vec<u8> = Vec::new();
-        image
-            .write_to(&mut Cursor::new(&mut bytes), image::ImageFormat::Png)
-            .unwrap();
+        buf.write_to(&mut Cursor::new(&mut bytes), image::ImageFormat::Png)
+            .expect("failed to write rucaptcha image into png");
 
         Captcha { text, image: bytes }
     }

data/ext/rucaptcha/src/lib.rs

@@ -7,6 +7,7 @@ pub fn create(
     difficulty: usize,
     line: bool,
     noise: bool,
+    circle: bool,
     format: String,
 ) -> (String, Vec<u8>) {
     let c = captcha::CaptchaBuilder::new();
@@ -15,6 +16,7 @@ pub fn create(
         .length(len)
         .line(line)
         .noise(noise)
+        .circle(circle)
         .format(&format)
         .build();
 
@@ -24,7 +26,7 @@ pub fn create(
 #[magnus::init]
 fn init() -> Result<(), Error> {
     let class = define_class("RuCaptchaCore", magnus::class::object())?;
-    class.define_singleton_method("create", function!(create, 5))?;
+    class.define_singleton_method("create", function!(create, 6))?;
 
     Ok(())
 }

data/lib/rucaptcha/configuration.rb

@@ -13,11 +13,15 @@ module RuCaptcha
     attr_accessor :line
     # Enable or disable noise on captcha image, default: false
     attr_accessor :noise
+    # Enable or disable circle background on captcha image, default: true
+    attr_accessor :circle
     # Image format allow: ['jpeg', 'png', 'webp'], default: 'png'
     attr_accessor :format
     # skip_cache_store_check, default: false
     attr_accessor :skip_cache_store_check
     # custom rucaptcha mount path， default： '/rucaptcha'
     attr_accessor :mount_path
+    # Enable or disable case sensitive, default: false
+    attr_accessor :case_sensitive
   end
 end

data/lib/rucaptcha/controller_helpers.rb

@@ -62,10 +62,17 @@ module RuCaptcha
       return add_rucaptcha_validation_error if (Time.now.to_i - store_info[:time]) > RuCaptcha.config.expires_in
 
       # Make sure parama have captcha
-      captcha = (opts[:captcha] || params[:_rucaptcha] || "").downcase.strip
+      captcha = (opts[:captcha] || params[:_rucaptcha] || "").strip
+      saved_code = store_info[:code]
+
       return add_rucaptcha_validation_error if captcha.blank?
 
-      return add_rucaptcha_validation_error if captcha != store_info[:code]
+      unless RuCaptcha.config.case_sensitive
+        captcha.downcase!
+        saved_code.downcase!
+      end
+
+      return add_rucaptcha_validation_error if captcha != saved_code
 
       true
     end

data/lib/rucaptcha/version.rb

@@ -1,3 +1,3 @@
 module RuCaptcha
-  VERSION = "3.2.5"
+  VERSION = "3.3.0"
 end

data/lib/rucaptcha.rb

@@ -29,9 +29,11 @@ module RuCaptcha
       @config.expires_in = 2.minutes
       @config.skip_cache_store_check = false
       @config.line = true
-      @config.noise = true
+      @config.noise = false
+      @config.circle = true
       @config.format = "png"
       @config.mount_path = "/rucaptcha"
+      @config.case_sensitive = false
 
       @config.cache_store = if Rails.application
                               Rails.application.config.cache_store
@@ -51,8 +53,12 @@ module RuCaptcha
 
       raise RuCaptcha::Errors::Configuration, "length config error, value must in 3..7" unless length.in?(3..7)
 
-      result = RuCaptchaCore.create(length, config.difficulty || 5, config.line, config.noise, config.format)
-      [result[0].downcase, result[1].pack("c*")]
+      result = RuCaptchaCore.create(length, config.difficulty || 5, config.line, config.noise, config.circle, config.format)
+      unless config.case_sensitive
+        result[0].downcase!
+      end
+
+      [result[0], result[1].pack("c*")]
     end
 
     def check_cache_store!

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rucaptcha
 version: !ruby/object:Gem::Version
-  version: 3.2.5
+  version: 3.3.0
 platform: x86_64-linux
 authors:
 - Jason Lee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-12-30 00:00:00.000000000 Z
+date: 2025-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -62,6 +62,7 @@ files:
 - ext/rucaptcha/src/lib.rs
 - lib/rucaptcha.rb
 - lib/rucaptcha/3.2/rucaptcha.so
+- lib/rucaptcha/3.3/rucaptcha.so
 - lib/rucaptcha/3.4/rucaptcha.so
 - lib/rucaptcha/cache.rb
 - lib/rucaptcha/configuration.rb