rucaptcha 3.1.4.pre-x86_64-darwin → 3.2.1-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 390fae83a511f8119a8089dbaff5314a53ce0881d222b5b3b5b37bdcd7fae8c0
-  data.tar.gz: 96fd0cb19fba08045eee2b679ebcad82ca8d93f8729dab02b515c98298e8b147
+  metadata.gz: 2a1a13794617c31afe6ea7158f8f787073696736d575c1481348e9e924737f6b
+  data.tar.gz: ce7f6ad01ba473d8408e2f1b5a50e181a720dab17ae6ffb45a6d2645b13d6abf
 SHA512:
-  metadata.gz: 2ef95f48d73878fdce82729083b69dd96bbbf6b153cc3d6a0b49a6ea088977c8b84a589668c0a78ef2017aef84e978d81b02debf0a190de6bb24d0fffa313b51
-  data.tar.gz: ab104ca5faa21f4c98ca7bb6e857ee29b69e97b052d2a625ac5ce7efc0fb25efd5908254066d4f9a1ad8381d8937088cb6ad765b1a57baec72f1693cd2ab94be
+  metadata.gz: 6a4cca70dfb333b9e80f1e85ddf2f04ba0df6fd93930c6523754046b3b697c06c767f9f40ccb61e283da1618fbefb0dc198eb77e4f3e36c556db2cf8268341b9
+  data.tar.gz: 3f51f5d5bf53f115c9f96783e8f9dfcaee46bc408ce987f41a17d3f5547538a1af96b16d2c42a1173aa1314656779a60214aad2d6484a1e2b084f817849cd08d

data/README.md

@@ -37,6 +37,7 @@ Create `config/initializers/rucaptcha.rb`
 RuCaptcha.configure do
   # Custom captcha code expire time if you need, default: 2 minutes
   # self.expires_in = 120
+
   # [Requirement / 重要]
   # Store Captcha code where, this config more like Rails config.cache_store
   # default: Read config info from `Rails.application.config.cache_store`
@@ -44,10 +45,22 @@ RuCaptcha.configure do
   # 默认：会从 Rails 配置的 cache_store 里面读取相同的配置信息，并尝试用可以运行的方式，用于存储验证码字符
   # 但如果是 [:null_store, :memory_store, :file_store] 之类的，你可以通过下面的配置项单独给 RuCaptcha 配置 cache_store
   self.cache_store = :mem_cache_store
+
+  # If you wants disable `cache_store` check warning, you can do it, default: false
   # 如果想要 disable cache_store 的 warning，就设置为 true，default false
   # self.skip_cache_store_check = true
+
   # Chars length, default: 5, allows: [3 - 7]
   # self.length = 5
+
+  # Enable or disable Strikethrough, default: true
+  # self.line = true
+
+  # Enable or disable noise, default: false
+  # self.noise = false
+
+  # Set the image format, default: png, allows: [jpeg, png, webp]
+  # self.format = 'png'
 end
 ```
 

data/Rakefile

@@ -27,9 +27,14 @@ end
 RSpec::Core::RakeTask.new(:spec)
 task default: :spec
 
+def create_captcha(length = 5, difficulty = 5)
+  require "rucaptcha"
+  RuCaptchaCore.create(length, difficulty, false, false, "png")
+end
+
 task :preview do
   require "rucaptcha"
-  res = RuCaptchaCore.create(5, 5)
+  res = create_captcha()
   warn "-------------------------\n#{res[0]}"
   puts res[1].pack("c*")
 end
@@ -38,11 +43,11 @@ task :memory do
   require "rucaptcha"
   require "memory_profiler"
 
-  RuCaptchaCore.create(5, 5)
+  create_captcha()
 
   report = MemoryProfiler.report do
     1000.times do
-      RuCaptchaCore.create(5, 5)
+      create_captcha()
     end
   end
 
@@ -57,10 +62,10 @@ task :benchmark do
   require "rucaptcha"
   require "benchmark/ips"
 
-  RuCaptchaCore.create(5, 5)
+  RuCaptchaCore.create(5, 5, true, true, "png")
 
   Benchmark.ips do |x|
-    x.report("Generate image") { RuCaptchaCore.create(5, 5) }
+    x.report("Generate image") { RuCaptchaCore.create(5, 5, true, true, "png") }
     x.compare!
   end
 end

data/ext/rucaptcha/src/captcha.rs

@@ -1,6 +1,4 @@
-use image::{ImageBuffer, Rgb};
-use imageproc::drawing::{draw_cubic_bezier_curve_mut, draw_text_mut};
-use imageproc::noise::gaussian_noise_mut;
+use image::{ImageBuffer, Rgba};
 use rand::{thread_rng, Rng};
 use rusttype::{Font, Scale};
 use std::io::Cursor;
@@ -15,21 +13,21 @@ static FONT_BYTES1: &[u8; 145008] = include_bytes!("../fonts/FuzzyBubbles-Regula
 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); 14] = [
-    (197, 166, 3),
-    (187, 87, 5),
-    (176, 7, 7),
-    (186, 9, 56),
-    (204, 11, 143),
-    (124, 10, 190),
-    (87, 0, 200),
-    (61, 86, 168),
-    (63, 166, 126),
-    (69, 187, 48),
-    (105, 208, 3),
-    (160, 208, 3),
-    (216, 219, 2),
-    (50, 50, 50),
+static COLORS: [(u8, u8, u8, u8); 14] = [
+    (197, 166, 3, 255),
+    (187, 87, 5, 255),
+    (176, 7, 7, 255),
+    (186, 9, 56, 255),
+    (204, 11, 143, 255),
+    (124, 10, 190, 255),
+    (87, 0, 200, 255),
+    (61, 86, 168, 255),
+    (63, 166, 126, 255),
+    (69, 187, 48, 255),
+    (105, 208, 3, 255),
+    (160, 208, 3, 255),
+    (216, 219, 2, 255),
+    (50, 50, 50, 255),
 ];
 
 static SCALE_SM: u32 = 32;
@@ -51,18 +49,18 @@ fn get_captcha(len: usize) -> Vec<String> {
 }
 
 #[allow(unused)]
-fn get_color() -> Rgb<u8> {
+fn get_color() -> Rgba<u8> {
     let rnd = rand_num(COLORS.len() - 1);
     let c = COLORS[rnd];
-    Rgb([c.0, c.1, c.2])
+    Rgba([c.0, c.1, c.2, c.3])
 }
 
-fn get_colors(num: usize) -> Vec<Rgb<u8>> {
+fn get_colors(num: usize) -> Vec<Rgba<u8>> {
     let rnd = rand_num(COLORS.len());
     let mut out = vec![];
     for i in 0..num {
         let c = COLORS[(rnd + i) % COLORS.len()];
-        out.push(Rgb([c.0, c.1, c.2]))
+        out.push(Rgba([c.0, c.1, c.2, c.3]))
     }
 
     out
@@ -80,13 +78,13 @@ fn get_font() -> Font<'static> {
     }
 }
 
-fn get_image(width: usize, height: usize) -> ImageBuffer<Rgb<u8>, Vec<u8>> {
+fn get_image(width: usize, height: usize) -> ImageBuffer<Rgba<u8>, Vec<u8>> {
     ImageBuffer::from_fn(width as u32, height as u32, |_, _| {
-        image::Rgb([255, 255, 255])
+        image::Rgba([255, 255, 255, 255])
     })
 }
 
-fn cyclic_write_character(res: &[String], image: &mut ImageBuffer<Rgb<u8>, Vec<u8>>) {
+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;
 
@@ -107,7 +105,10 @@ fn cyclic_write_character(res: &[String], image: &mut ImageBuffer<Rgb<u8>, Vec<u
     // Draw line, ellipse first as background
     for (i, _) in res.iter().enumerate() {
         let line_color = line_colors[i];
-        draw_interference_line(1, image, line_color);
+
+        if lines {
+            draw_interference_line(1, image, line_color);
+        }
         draw_interference_ellipse(1, image, line_color);
     }
 
@@ -121,7 +122,7 @@ fn cyclic_write_character(res: &[String], image: &mut ImageBuffer<Rgb<u8>, Vec<u
         for j in 0..(rand_num(3) + 1) as i32 {
             // Draw text again with offset
             let offset = j * (rand_num(2) as i32);
-            draw_text_mut(
+            imageproc::drawing::draw_text_mut(
                 image,
                 color,
                 10 + offset + (i as u32 * c) as i32,
@@ -137,7 +138,7 @@ fn cyclic_write_character(res: &[String], image: &mut ImageBuffer<Rgb<u8>, Vec<u
     }
 }
 
-fn draw_interference_line(num: usize, image: &mut ImageBuffer<Rgb<u8>, Vec<u8>>, color: Rgb<u8>) {
+fn draw_interference_line(num: usize, image: &mut ImageBuffer<Rgba<u8>, Vec<u8>>, color: Rgba<u8>) {
     for _ in 0..num {
         let width = image.width();
         let height = image.height();
@@ -153,7 +154,7 @@ fn draw_interference_line(num: usize, image: &mut ImageBuffer<Rgb<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
-        draw_cubic_bezier_curve_mut(
+        imageproc::drawing::draw_cubic_bezier_curve_mut(
             image,
             (x1, y1),
             (x2, y2),
@@ -166,8 +167,8 @@ fn draw_interference_line(num: usize, image: &mut ImageBuffer<Rgb<u8>, Vec<u8>>,
 
 fn draw_interference_ellipse(
     num: usize,
-    image: &mut ImageBuffer<Rgb<u8>, Vec<u8>>,
-    color: Rgb<u8>,
+    image: &mut ImageBuffer<Rgba<u8>, Vec<u8>>,
+    color: Rgba<u8>,
 ) {
     for _ in 0..num {
         // max cycle width 20px
@@ -189,6 +190,9 @@ pub struct CaptchaBuilder {
     width: usize,
     height: usize,
     complexity: usize,
+    line: bool,
+    noise: bool,
+    format: image::ImageFormat,
 }
 
 impl CaptchaBuilder {
@@ -198,6 +202,9 @@ impl CaptchaBuilder {
             width: 220,
             height: 70,
             complexity: 5,
+            line: true,
+            noise: false,
+            format: image::ImageFormat::Png,
         }
     }
 
@@ -206,15 +213,26 @@ impl CaptchaBuilder {
         self
     }
 
-    // pub fn width(mut self, width: usize) -> Self {
-    //     self.width = width;
-    //     self
-    // }
+    pub fn line(mut self, line: bool) -> Self {
+        self.line = line;
+        self
+    }
+
+    pub fn noise(mut self, noise: bool) -> Self {
+        self.noise = noise;
+        self
+    }
+
+    pub fn format(mut self, format: &str) -> Self {
+        self.format = match format {
+            "png" => image::ImageFormat::Png,
+            "jpg" | "jpeg" => image::ImageFormat::Jpeg,
+            "webp" => image::ImageFormat::WebP,
+            _ => image::ImageFormat::Png,
+        };
 
-    // pub fn height(mut self, height: usize) -> Self {
-    //     self.height = height;
-    //     self
-    // }
+        self
+    }
 
     pub fn complexity(mut self, complexity: usize) -> Self {
         let mut complexity = complexity;
@@ -238,20 +256,86 @@ impl CaptchaBuilder {
         let mut image = get_image(self.width, self.height);
 
         // Loop to write the verification code string into the background image
-        cyclic_write_character(&res, &mut image);
-
-        gaussian_noise_mut(
-            &mut image,
-            (self.complexity - 1) as f64,
-            ((10 * self.complexity) - 10) as f64,
-            ((5 * self.complexity) - 5) as u64,
-        );
+        cyclic_write_character(&res, &mut image, self.line);
+
+        if self.noise {
+            imageproc::noise::gaussian_noise_mut(
+                &mut image,
+                (self.complexity - 1) as f64,
+                ((10 * self.complexity) - 10) as f64,
+                ((5 * self.complexity) - 5) as u64,
+            );
+        }
 
         let mut bytes: Vec<u8> = Vec::new();
         image
-            .write_to(&mut Cursor::new(&mut bytes), image::ImageFormat::Jpeg)
+            .write_to(&mut Cursor::new(&mut bytes), image::ImageFormat::Png)
             .unwrap();
 
         Captcha { text, image: bytes }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_format() {
+        let mut builder = CaptchaBuilder::new();
+        assert_eq!(builder.format, image::ImageFormat::Png);
+
+        builder = builder.format("jpg");
+        assert_eq!(builder.format, image::ImageFormat::Jpeg);
+        builder = builder.format("jpeg");
+        assert_eq!(builder.format, image::ImageFormat::Jpeg);
+        builder = builder.format("webp");
+        assert_eq!(builder.format, image::ImageFormat::WebP);
+        builder = builder.format("png");
+        assert_eq!(builder.format, image::ImageFormat::Png);
+        builder = builder.format("gif");
+        assert_eq!(builder.format, image::ImageFormat::Png);
+    }
+
+    #[test]
+    fn test_line() {
+        let mut builder = CaptchaBuilder::new();
+        assert!(builder.line);
+
+        builder = builder.line(false);
+        assert!(!builder.line);
+    }
+
+    #[test]
+    fn test_noise() {
+        let mut builder = CaptchaBuilder::new();
+        assert!(!builder.noise);
+
+        builder = builder.noise(true);
+        assert!(builder.noise);
+    }
+
+    #[test]
+    fn test_difficulty() {
+        let mut builder = CaptchaBuilder::new();
+        assert_eq!(builder.complexity, 5);
+
+        builder = builder.complexity(10);
+        assert_eq!(builder.complexity, 10);
+
+        builder = builder.complexity(11);
+        assert_eq!(builder.complexity, 10);
+
+        builder = builder.complexity(0);
+        assert_eq!(builder.complexity, 1);
+    }
+
+    #[test]
+    fn test_length() {
+        let mut builder = CaptchaBuilder::new();
+        assert_eq!(builder.length, 4);
+
+        builder = builder.length(10);
+        assert_eq!(builder.length, 10);
+    }
+}

data/ext/rucaptcha/src/lib.rs

@@ -2,9 +2,21 @@ use magnus::{define_class, function, Error, Object};
 
 mod captcha;
 
-pub fn create(len: usize, difficulty: usize) -> (String, Vec<u8>) {
+pub fn create(
+    len: usize,
+    difficulty: usize,
+    line: bool,
+    noise: bool,
+    format: String,
+) -> (String, Vec<u8>) {
     let c = captcha::CaptchaBuilder::new();
-    let out = c.complexity(difficulty).length(len).build();
+    let out = c
+        .complexity(difficulty)
+        .length(len)
+        .line(line)
+        .noise(noise)
+        .format(&format)
+        .build();
 
     (out.text, out.image)
 }
@@ -12,7 +24,7 @@ pub fn create(len: usize, difficulty: usize) -> (String, Vec<u8>) {
 #[magnus::init]
 fn init() -> Result<(), Error> {
     let class = define_class("RuCaptchaCore", Default::default())?;
-    class.define_singleton_method("create", function!(create, 2))?;
+    class.define_singleton_method("create", function!(create, 5))?;
 
     Ok(())
 }

data/lib/rucaptcha/configuration.rb

@@ -9,6 +9,12 @@ module RuCaptcha
     attr_accessor :length
     # Hard mode, default: 5, allows: [1..10]
     attr_accessor :difficulty
+    # Enable or disable strikethrough lines on captcha image, default: true
+    attr_accessor :line
+    # Enable or disable noise on captcha image, default: false
+    attr_accessor :noise
+    # Image format allow: ['jpeg', 'png', 'webp'], default: 'png'
+    attr_accessor :format
     # skip_cache_store_check, default: false
     attr_accessor :skip_cache_store_check
   end

data/lib/rucaptcha/version.rb

@@ -1,3 +1,3 @@
 module RuCaptcha
-  VERSION = "3.1.4.pre"
+  VERSION = "3.2.1"
 end

data/lib/rucaptcha.rb

@@ -28,6 +28,9 @@ module RuCaptcha
       @config.difficulty = 3
       @config.expires_in = 2.minutes
       @config.skip_cache_store_check = false
+      @config.line = true
+      @config.noise = true
+      @config.format = "png"
 
       @config.cache_store = if Rails.application
                               Rails.application.config.cache_store
@@ -47,7 +50,7 @@ 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)
+      result = RuCaptchaCore.create(length, config.difficulty || 5, config.line, config.noise, config.format)
       [result[0].downcase, result[1].pack("c*")]
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rucaptcha
 version: !ruby/object:Gem::Version
-  version: 3.1.4.pre
+  version: 3.2.1
 platform: x86_64-darwin
 authors:
 - Jason Lee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-11 00:00:00.000000000 Z
+date: 2023-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -89,11 +89,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.3.dev
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.4.3
+rubygems_version: 3.4.4
 signing_key: 
 specification_version: 4
 summary: Captcha Gem for Rails, which generates captcha image by Rust.