berns 3.1.2 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6695ba5e81eb15efa63f6a0fe44f6b9a7815e72e2f559ea95215705e9071cb7
-  data.tar.gz: 58abfcecba13d9629cac48c1b16a5aa76fbffc887e1d84f0d5d4374a9ab8cea0
+  metadata.gz: 0d9597d10ff728258b758e65aca73ec692374d3d359acb976677f0e143800978
+  data.tar.gz: 8eb851e88a7674a5d9e9af5f111085af87bb958db03f0539574bdd9358dad9be
 SHA512:
-  metadata.gz: 8011681974ffdbc3ca50097da9cb78cd4eb323957fd60c16d6531c36a5fb88fce1364092351f1f9498d11480645a23e968403a69a34ac80d60b0c044b34dea8c
-  data.tar.gz: 7076f10933b3b90efc0967b845448863adf3dc46780eecf655e917fc2face9eab42e2e779648db818589368296268dc7c06cd049677077f1d049e5132104f97f
+  metadata.gz: 6e62bb1798243beab62f44e1ba7a3fc211b53997ce44e4ba37e6c46303974a96d4391d3fcdb9c807f3b894f097e9d3c823831026d4dca645362b21f4cab050da
+  data.tar.gz: 047c09ea060864337ee852e51b85964bfed265009123e290e17d0f3b51782aca5ad3ca877ea45195536e8a93258dd5536e66c6e553d6afc5dfcbf970bccf7807

data/README.org

@@ -91,6 +91,10 @@ The =sanitize= method strips HTML tags from strings.
 Berns.sanitize('This <span>should be clean</span>') # => 'This should be clean'
 #+end_src
 
+Note that this is an extremely naive implementation of HTML sanitization that
+literally just looks for "<" and ">" characters and removes the contents between
+them. This should probably only be used on trusted strings.
+
 *** Standard and void elements
 
 All standard and void HTML elements are defined as methods on Berns, so you can

data/ext/berns/berns.c

@@ -1,5 +1,4 @@
 #include "ruby.h"
-#include "extconf.h"
 #include "hescape.h"
 
 static const char *attr_close = "\"";
@@ -47,11 +46,11 @@ static const size_t sllen = 1;
  * Macro to define a "dynamic" function that generates a void element.
  */
 #define VOID_ELEMENT(element_name) \
-  static VALUE external_##element_name##_element(int argc, VALUE* argv, RB_UNUSED_VAR(VALUE self)) { \
+  static VALUE external_##element_name##_element(int argc, VALUE *argv, RB_UNUSED_VAR(VALUE self)) { \
     rb_check_arity(argc, 0, 1); \
     \
-    char *tag = #element_name; \
-    char *string = void_element(tag, strlen(tag), &argv[0]); \
+    const char *tag = #element_name; \
+    char *string = void_element(tag, strlen(tag), argv[0]); \
     VALUE rstring = rb_utf8_str_new_cstr(string); \
     free(string); \
     \
@@ -62,12 +61,12 @@ static const size_t sllen = 1;
  * Macro to define a "dynamic" function that generates a standard element.
  */
 #define STANDARD_ELEMENT(element_name) \
-  static VALUE external_##element_name##_element(int argc, VALUE* argv, RB_UNUSED_VAR(VALUE self)) { \
+  static VALUE external_##element_name##_element(int argc, VALUE *argv, RB_UNUSED_VAR(VALUE self)) { \
     rb_check_arity(argc, 0, 1); \
     \
     CONTENT_FROM_BLOCK; \
-    char *tag = #element_name; \
-    char *string = element(tag, strlen(tag), RSTRING_PTR(content), RSTRING_LEN(content), &argv[0]); \
+    const char *tag = #element_name; \
+    char *string = element(tag, strlen(tag), RSTRING_PTR(content), RSTRING_LEN(content), argv[0]); \
     VALUE rstring = rb_utf8_str_new_cstr(string); \
     free(string); \
     \
@@ -78,25 +77,64 @@ static const size_t sllen = 1;
 /*
  * "Safe strcpy" - https://twitter.com/hyc_symas/status/1102573036534972416?s=12
 */
-static char *stecpy(char *destination, const char *source, const char *end) {
+static char * stecpy(char *destination, const char *source, const char *end) {
+  if (end) {
+    end--;
+  }
+
   while (*source && destination < end) {
     *destination++ = *source++;
   }
 
-  if (destination < end) {
+  if (destination) {
     *destination = '\0';
   }
 
   return destination;
 }
 
+/*
+ * The external API for Berns.sanitize
+ *
+ *   string should be a string or nil, anything else will raise an error.
+ *
+ */
+static VALUE external_sanitize(RB_UNUSED_VAR(VALUE self), VALUE string) {
+  if (TYPE(string) == T_NIL) {
+    return Qnil;
+  }
+
+  StringValue(string);
+
+  size_t slen = RSTRING_LEN(string);
+  char *str = RSTRING_PTR(string);
+
+  char dest[slen + 1];
+  int index = 0;
+  int open = 0;
+
+  for (unsigned int i = 0; i < slen; i++) {
+    if (str[i] == '<') {
+      open = 1;
+    } else if (str[i] == '>') {
+      open = 0;
+    } else if (!open) {
+      dest[index++] = str[i];
+    }
+  }
+
+  dest[index] = '\0';
+
+  return rb_utf8_str_new_cstr(dest);
+}
+
 /*
  * The external API for Berns.escape_html.
  *
  *   string should be a string, anything else will raise an error.
  *
  */
-static VALUE external_escape_html(const VALUE self, VALUE string) {
+static VALUE external_escape_html(RB_UNUSED_VAR(VALUE self), VALUE string) {
   StringValue(string);
 
   uint8_t *dest = NULL;
@@ -123,7 +161,6 @@ static VALUE external_escape_html(const VALUE self, VALUE string) {
 static char * empty_value_to_attribute(const char *attr, const size_t attrlen) {
   size_t total_size = attrlen + 1;
   char *dest = malloc(total_size);
-  char *ptr = NULL;
   char *end = dest + total_size;
 
   stecpy(dest, attr, end);
@@ -140,7 +177,6 @@ static char * string_value_to_attribute(const char *attr, const size_t attrlen,
   if (vallen == 0) {
     size_t total_size = attrlen + 1;
     char *dest = malloc(total_size);
-    char *ptr = NULL;
     char *end = dest + total_size;
 
     stecpy(dest, attr, end);
@@ -168,21 +204,21 @@ static char * string_value_to_attribute(const char *attr, const size_t attrlen,
   }
 }
 
-static char * hash_value_to_attribute(char *attr, const size_t attrlen, VALUE *value) {
-  if (TYPE(*value) == T_IMEMO) {
-    return calloc(0, 1);
+static char * hash_value_to_attribute(const char *attr, const size_t attrlen, VALUE value) {
+  if (TYPE(value) == T_IMEMO) {
+    return strdup("");
   }
 
-  Check_Type(*value, T_HASH);
+  Check_Type(value, T_HASH);
 
-  if (rb_hash_size(*value) == 1) {
-    return calloc(0, 1);
+  if (rb_hash_size(value) == 1) {
+    return strdup("");
   }
 
   VALUE subkey;
   VALUE subvalue;
 
-  const VALUE keys = rb_funcall(*value, rb_intern("keys"), 0);
+  const VALUE keys = rb_funcall(value, rb_intern("keys"), 0);
   const VALUE length = RARRAY_LEN(keys);
 
   size_t allocated = 256;
@@ -194,7 +230,7 @@ static char * hash_value_to_attribute(char *attr, const size_t attrlen, VALUE *v
 
   for (unsigned int i = 0; i < length; i++) {
     subkey = rb_ary_entry(keys, i);
-    subvalue = rb_hash_aref(*value, subkey);
+    subvalue = rb_hash_aref(value, subkey);
 
     switch(TYPE(subkey)) {
       case T_STRING:
@@ -224,27 +260,29 @@ static char * hash_value_to_attribute(char *attr, const size_t attrlen, VALUE *v
 
     char subattr[subattr_len + 1];
     char *ptr = subattr;
-    char *end = subattr + sizeof(subattr);
+    char *subend = subattr + subattr_len + 1;
 
     if (attrlen > 0) {
-      ptr = stecpy(ptr, attr, end);
+      ptr = stecpy(ptr, attr, subend);
     }
 
     if (attrlen > 0 && subkey_len > 0) {
-      ptr = stecpy(ptr, dash, end);
+      ptr = stecpy(ptr, dash, subend);
     }
 
-    stecpy(ptr, RSTRING_PTR(subkey), end);
+    stecpy(ptr, RSTRING_PTR(subkey), subend);
 
     char *combined;
 
     switch(TYPE(subvalue)) {
       case T_FALSE:
-        combined = calloc(0, 1);
+        combined = strdup("");
         break;
 
+      case T_NIL:
+        /* Fall through. */
       case T_TRUE:
-        combined = string_value_to_attribute(subattr, subattr_len, "", 0);
+        combined = empty_value_to_attribute(subattr, subattr_len);
         break;
 
       case T_STRING:
@@ -256,13 +294,8 @@ static char * hash_value_to_attribute(char *attr, const size_t attrlen, VALUE *v
         combined = string_value_to_attribute(subattr, subattr_len, RSTRING_PTR(subvalue), RSTRING_LEN(subvalue));
         break;
 
-      case T_NIL:
-        subvalue = rb_utf8_str_new_cstr("");
-        combined = string_value_to_attribute(subattr, subattr_len, RSTRING_PTR(subvalue), RSTRING_LEN(subvalue));
-        break;
-
       case T_HASH:
-        combined = hash_value_to_attribute(subattr, subattr_len, &subvalue);
+        combined = hash_value_to_attribute(subattr, subattr_len, subvalue);
         break;
 
       default:
@@ -313,7 +346,7 @@ static char * hash_value_to_attribute(char *attr, const size_t attrlen, VALUE *v
 /*
  * Convert an attribute name and value into a string.
  */
-static char * to_attribute(VALUE attr, VALUE *value) {
+static char * to_attribute(VALUE attr, VALUE value) {
   switch(TYPE(attr)) {
     case T_SYMBOL:
       attr = rb_sym2str(attr);
@@ -327,26 +360,27 @@ static char * to_attribute(VALUE attr, VALUE *value) {
   char *val = NULL;
   VALUE str;
 
-  switch(TYPE(*value)) {
+  switch(TYPE(value)) {
     case T_NIL:
+      /* Fall through. */
     case T_TRUE:
       val = empty_value_to_attribute(RSTRING_PTR(attr), RSTRING_LEN(attr));
       break;
     case T_FALSE:
-      val = calloc(0, 1);
+      val = strdup("");
       break;
     case T_HASH:
       val = hash_value_to_attribute(RSTRING_PTR(attr), RSTRING_LEN(attr), value);
       break;
     case T_STRING:
-      val = string_value_to_attribute(RSTRING_PTR(attr), RSTRING_LEN(attr), RSTRING_PTR(*value), RSTRING_LEN(*value));
+      val = string_value_to_attribute(RSTRING_PTR(attr), RSTRING_LEN(attr), RSTRING_PTR(value), RSTRING_LEN(value));
       break;
     case T_SYMBOL:
-      str = rb_sym2str(*value);
+      str = rb_sym2str(value);
       val = string_value_to_attribute(RSTRING_PTR(attr), RSTRING_LEN(attr), RSTRING_PTR(str), RSTRING_LEN(str));
       break;
     default:
-      str = rb_funcall(*value, rb_intern("to_s"), 0);
+      str = rb_funcall(value, rb_intern("to_s"), 0);
       val = string_value_to_attribute(RSTRING_PTR(attr), RSTRING_LEN(attr), RSTRING_PTR(str), RSTRING_LEN(str));
       break;
   }
@@ -372,7 +406,7 @@ static VALUE external_to_attribute(RB_UNUSED_VAR(VALUE self), VALUE attr, VALUE
 
   StringValue(attr);
 
-  char *val = to_attribute(attr, &value);
+  char *val = to_attribute(attr, value);
   VALUE rstring = rb_utf8_str_new_cstr(val);
   free(val);
 
@@ -392,8 +426,8 @@ static VALUE external_to_attributes(RB_UNUSED_VAR(VALUE self), VALUE attributes)
     return rb_utf8_str_new_cstr("");
   }
 
-  char *empty = "";
-  char *attrs = hash_value_to_attribute(empty, 0, &attributes);
+  const char *empty = "";
+  char *attrs = hash_value_to_attribute(empty, 0, attributes);
 
   VALUE rstring = rb_utf8_str_new_cstr(attrs);
   free(attrs);
@@ -401,9 +435,9 @@ static VALUE external_to_attributes(RB_UNUSED_VAR(VALUE self), VALUE attributes)
   return rstring;
 }
 
-static char * void_element(char *tag, size_t tlen, VALUE *attributes) {
+static char * void_element(const char *tag, size_t tlen, VALUE attributes) {
   /* T_IMEMO is what we get if an optional argument was not passed. */
-  if (TYPE(*attributes) == T_IMEMO) {
+  if (TYPE(attributes) == T_IMEMO) {
     size_t total = tag_olen + tlen + tag_clen + 1;
     char *string = malloc(total);
     char *ptr;
@@ -415,7 +449,7 @@ static char * void_element(char *tag, size_t tlen, VALUE *attributes) {
 
     return string;
   } else {
-    char *empty = "";
+    const char *empty = "";
     char *attrs = hash_value_to_attribute(empty, 0, attributes);
 
     size_t total = tag_olen + tlen + splen + strlen(attrs) + tag_clen + 1;
@@ -454,7 +488,7 @@ static VALUE external_void_element(int argc, VALUE *arguments, RB_UNUSED_VAR(VAL
 
   StringValue(tag);
 
-  char *string = void_element(RSTRING_PTR(tag), RSTRING_LEN(tag), &attributes);
+  char *string = void_element(RSTRING_PTR(tag), RSTRING_LEN(tag), attributes);
   VALUE rstring = rb_utf8_str_new_cstr(string);
 
   free(string);
@@ -462,8 +496,8 @@ static VALUE external_void_element(int argc, VALUE *arguments, RB_UNUSED_VAR(VAL
   return rstring;
 }
 
-static char * element(char *tag, size_t tlen, char *content, size_t conlen, VALUE *attributes) {
-  char *empty = "";
+static char * element(const char *tag, size_t tlen, char *content, size_t conlen, VALUE attributes) {
+  const char *empty = "";
   char *attrs = hash_value_to_attribute(empty, 0, attributes);
   size_t alen = strlen(attrs);
 
@@ -529,129 +563,130 @@ static VALUE external_element(int argc, VALUE *arguments, RB_UNUSED_VAR(VALUE se
 
   CONTENT_FROM_BLOCK;
 
-  char *string = element(RSTRING_PTR(tag), RSTRING_LEN(tag), RSTRING_PTR(content), RSTRING_LEN(content), &attributes);
+  char *string = element(RSTRING_PTR(tag), RSTRING_LEN(tag), RSTRING_PTR(content), RSTRING_LEN(content), attributes);
   VALUE rstring = rb_utf8_str_new_cstr(string);
   free(string);
 
   return rstring;
 }
 
-VOID_ELEMENT(area);
-VOID_ELEMENT(base);
-VOID_ELEMENT(br);
-VOID_ELEMENT(col);
-VOID_ELEMENT(embed);
-VOID_ELEMENT(hr);
-VOID_ELEMENT(img);
-VOID_ELEMENT(input);
-VOID_ELEMENT(link);
-VOID_ELEMENT(menuitem);
-VOID_ELEMENT(meta);
-VOID_ELEMENT(param);
-VOID_ELEMENT(source);
-VOID_ELEMENT(track);
-VOID_ELEMENT(wbr);
-
-STANDARD_ELEMENT(a);
-STANDARD_ELEMENT(abbr);
-STANDARD_ELEMENT(address);
-STANDARD_ELEMENT(article);
-STANDARD_ELEMENT(aside);
-STANDARD_ELEMENT(audio);
-STANDARD_ELEMENT(b);
-STANDARD_ELEMENT(bdi);
-STANDARD_ELEMENT(bdo);
-STANDARD_ELEMENT(blockquote);
-STANDARD_ELEMENT(body);
-STANDARD_ELEMENT(button);
-STANDARD_ELEMENT(canvas);
-STANDARD_ELEMENT(caption);
-STANDARD_ELEMENT(cite);
-STANDARD_ELEMENT(code);
-STANDARD_ELEMENT(colgroup);
-STANDARD_ELEMENT(datalist);
-STANDARD_ELEMENT(dd);
-STANDARD_ELEMENT(del);
-STANDARD_ELEMENT(details);
-STANDARD_ELEMENT(dfn);
-STANDARD_ELEMENT(dialog);
-STANDARD_ELEMENT(div);
-STANDARD_ELEMENT(dl);
-STANDARD_ELEMENT(dt);
-STANDARD_ELEMENT(em);
-STANDARD_ELEMENT(fieldset);
-STANDARD_ELEMENT(figcaption);
-STANDARD_ELEMENT(figure);
-STANDARD_ELEMENT(footer);
-STANDARD_ELEMENT(form);
-STANDARD_ELEMENT(h1);
-STANDARD_ELEMENT(h2);
-STANDARD_ELEMENT(h3);
-STANDARD_ELEMENT(h4);
-STANDARD_ELEMENT(h5);
-STANDARD_ELEMENT(h6);
-STANDARD_ELEMENT(head);
-STANDARD_ELEMENT(header);
-STANDARD_ELEMENT(html);
-STANDARD_ELEMENT(i);
-STANDARD_ELEMENT(iframe);
-STANDARD_ELEMENT(ins);
-STANDARD_ELEMENT(kbd);
-STANDARD_ELEMENT(label);
-STANDARD_ELEMENT(legend);
-STANDARD_ELEMENT(li);
-STANDARD_ELEMENT(main);
-STANDARD_ELEMENT(map);
-STANDARD_ELEMENT(mark);
-STANDARD_ELEMENT(menu);
-STANDARD_ELEMENT(meter);
-STANDARD_ELEMENT(nav);
-STANDARD_ELEMENT(noscript);
-STANDARD_ELEMENT(object);
-STANDARD_ELEMENT(ol);
-STANDARD_ELEMENT(optgroup);
-STANDARD_ELEMENT(option);
-STANDARD_ELEMENT(output);
-STANDARD_ELEMENT(p);
-STANDARD_ELEMENT(picture);
-STANDARD_ELEMENT(pre);
-STANDARD_ELEMENT(progress);
-STANDARD_ELEMENT(q);
-STANDARD_ELEMENT(rp);
-STANDARD_ELEMENT(rt);
-STANDARD_ELEMENT(ruby);
-STANDARD_ELEMENT(s);
-STANDARD_ELEMENT(samp);
-STANDARD_ELEMENT(script);
-STANDARD_ELEMENT(section);
-STANDARD_ELEMENT(select);
-STANDARD_ELEMENT(small);
-STANDARD_ELEMENT(span);
-STANDARD_ELEMENT(strong);
-STANDARD_ELEMENT(style);
-STANDARD_ELEMENT(sub);
-STANDARD_ELEMENT(summary);
-STANDARD_ELEMENT(table);
-STANDARD_ELEMENT(tbody);
-STANDARD_ELEMENT(td);
-STANDARD_ELEMENT(template);
-STANDARD_ELEMENT(textarea);
-STANDARD_ELEMENT(tfoot);
-STANDARD_ELEMENT(th);
-STANDARD_ELEMENT(thead);
-STANDARD_ELEMENT(time);
-STANDARD_ELEMENT(title);
-STANDARD_ELEMENT(tr);
-STANDARD_ELEMENT(u);
-STANDARD_ELEMENT(ul);
-STANDARD_ELEMENT(var);
-STANDARD_ELEMENT(video);
+VOID_ELEMENT(area)
+VOID_ELEMENT(base)
+VOID_ELEMENT(br)
+VOID_ELEMENT(col)
+VOID_ELEMENT(embed)
+VOID_ELEMENT(hr)
+VOID_ELEMENT(img)
+VOID_ELEMENT(input)
+VOID_ELEMENT(link)
+VOID_ELEMENT(menuitem)
+VOID_ELEMENT(meta)
+VOID_ELEMENT(param)
+VOID_ELEMENT(source)
+VOID_ELEMENT(track)
+VOID_ELEMENT(wbr)
+
+STANDARD_ELEMENT(a)
+STANDARD_ELEMENT(abbr)
+STANDARD_ELEMENT(address)
+STANDARD_ELEMENT(article)
+STANDARD_ELEMENT(aside)
+STANDARD_ELEMENT(audio)
+STANDARD_ELEMENT(b)
+STANDARD_ELEMENT(bdi)
+STANDARD_ELEMENT(bdo)
+STANDARD_ELEMENT(blockquote)
+STANDARD_ELEMENT(body)
+STANDARD_ELEMENT(button)
+STANDARD_ELEMENT(canvas)
+STANDARD_ELEMENT(caption)
+STANDARD_ELEMENT(cite)
+STANDARD_ELEMENT(code)
+STANDARD_ELEMENT(colgroup)
+STANDARD_ELEMENT(datalist)
+STANDARD_ELEMENT(dd)
+STANDARD_ELEMENT(del)
+STANDARD_ELEMENT(details)
+STANDARD_ELEMENT(dfn)
+STANDARD_ELEMENT(dialog)
+STANDARD_ELEMENT(div)
+STANDARD_ELEMENT(dl)
+STANDARD_ELEMENT(dt)
+STANDARD_ELEMENT(em)
+STANDARD_ELEMENT(fieldset)
+STANDARD_ELEMENT(figcaption)
+STANDARD_ELEMENT(figure)
+STANDARD_ELEMENT(footer)
+STANDARD_ELEMENT(form)
+STANDARD_ELEMENT(h1)
+STANDARD_ELEMENT(h2)
+STANDARD_ELEMENT(h3)
+STANDARD_ELEMENT(h4)
+STANDARD_ELEMENT(h5)
+STANDARD_ELEMENT(h6)
+STANDARD_ELEMENT(head)
+STANDARD_ELEMENT(header)
+STANDARD_ELEMENT(html)
+STANDARD_ELEMENT(i)
+STANDARD_ELEMENT(iframe)
+STANDARD_ELEMENT(ins)
+STANDARD_ELEMENT(kbd)
+STANDARD_ELEMENT(label)
+STANDARD_ELEMENT(legend)
+STANDARD_ELEMENT(li)
+STANDARD_ELEMENT(main)
+STANDARD_ELEMENT(map)
+STANDARD_ELEMENT(mark)
+STANDARD_ELEMENT(menu)
+STANDARD_ELEMENT(meter)
+STANDARD_ELEMENT(nav)
+STANDARD_ELEMENT(noscript)
+STANDARD_ELEMENT(object)
+STANDARD_ELEMENT(ol)
+STANDARD_ELEMENT(optgroup)
+STANDARD_ELEMENT(option)
+STANDARD_ELEMENT(output)
+STANDARD_ELEMENT(p)
+STANDARD_ELEMENT(picture)
+STANDARD_ELEMENT(pre)
+STANDARD_ELEMENT(progress)
+STANDARD_ELEMENT(q)
+STANDARD_ELEMENT(rp)
+STANDARD_ELEMENT(rt)
+STANDARD_ELEMENT(ruby)
+STANDARD_ELEMENT(s)
+STANDARD_ELEMENT(samp)
+STANDARD_ELEMENT(script)
+STANDARD_ELEMENT(section)
+STANDARD_ELEMENT(select)
+STANDARD_ELEMENT(small)
+STANDARD_ELEMENT(span)
+STANDARD_ELEMENT(strong)
+STANDARD_ELEMENT(style)
+STANDARD_ELEMENT(sub)
+STANDARD_ELEMENT(summary)
+STANDARD_ELEMENT(table)
+STANDARD_ELEMENT(tbody)
+STANDARD_ELEMENT(td)
+STANDARD_ELEMENT(template)
+STANDARD_ELEMENT(textarea)
+STANDARD_ELEMENT(tfoot)
+STANDARD_ELEMENT(th)
+STANDARD_ELEMENT(thead)
+STANDARD_ELEMENT(time)
+STANDARD_ELEMENT(title)
+STANDARD_ELEMENT(tr)
+STANDARD_ELEMENT(u)
+STANDARD_ELEMENT(ul)
+STANDARD_ELEMENT(var)
+STANDARD_ELEMENT(video)
 
 void Init_berns() {
   VALUE Berns = rb_define_module("Berns");
 
   rb_define_singleton_method(Berns, "element", external_element, -1);
   rb_define_singleton_method(Berns, "escape_html", external_escape_html, 1);
+  rb_define_singleton_method(Berns, "sanitize", external_sanitize, 1);
   rb_define_singleton_method(Berns, "to_attribute", external_to_attribute, 2);
   rb_define_singleton_method(Berns, "to_attributes", external_to_attributes, 1);
   rb_define_singleton_method(Berns, "void", external_void_element, -1);

data/ext/berns/extconf.rb

@@ -1,8 +1,14 @@
 # frozen_string_literal: true
 require 'mkmf'
 
-$CFLAGS = '-O3 -msse4' # rubocop:disable Style/GlobalVars
+dir_config 'berns'
+
+append_cflags '-O3'
+append_cflags '-Wshadow'
+append_cflags '-Wstrict-overflow'
+append_cflags '-flto'
+append_cflags '-fno-strict-aliasing'
+append_cflags '-msse4'
+append_cflags '-std=c99'
 
-dir_config('berns')
-create_header
 create_makefile 'berns/berns'

data/lib/berns.rb

@@ -1,25 +1,3 @@
 # frozen_string_literal: true
 require 'berns/berns'
 require 'berns/version'
-
-module Berns # :nodoc:
-  class Error < StandardError; end
-
-  EMPTY = ''
-
-  # Regular expression for basic HTML tag sanitizing.
-  SANITIZE_REGEX = /<[^>]+>/.freeze
-
-  # Sanitize text input by stripping HTML tags.
-  #
-  # @example Sanitize some text, removing HTML elements.
-  #   sanitize('This <span>should be clean</span>') # => "This should be clean"
-  #
-  # @param text [String]
-  #   The string to sanitize.
-  # @return [nil, String]
-  #   nil unless a string was passed in, otherwise the sanitized string.
-  def self.sanitize(string)
-    string&.gsub(SANITIZE_REGEX, EMPTY)
-  end
-end

data/lib/berns/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Berns
-  VERSION = '3.1.2'
+  VERSION = '3.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: berns
 version: !ruby/object:Gem::Version
-  version: 3.1.2
+  version: 3.2.0
 platform: ruby
 authors:
 - Taylor Beck
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-14 00:00:00.000000000 Z
+date: 2021-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips