fast_underscore 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 92b7e9dcd681e04772d2ebc6c19cb4b81754c30c15f2c5b11ea70f480b60de94
+  data.tar.gz: 1dae29981eb5c68f39fe9f0d0840a4d2066c3a6e123ae2f68190e7244aae93c0
+SHA512:
+  metadata.gz: e30d177a4285fe0486a995f83b7eba7e5d4bd11aa3b7c0ee25954364b28b57a9e02066e746271a3f4643cdbe6989e22a6b3587492f2820902eac062b1e490dc0
+  data.tar.gz: ba43f899c1055930bc7a9e3ad9a4c7973fefd03668428e9d3ae48de6f7bcdb53abbf3beec1f50b89c317a17f1b4400f5abd664744e4eff526d0591694213b61b

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/lib/fast_underscore/fast_underscore.bundle

data/.rubocop.yml

@@ -0,0 +1,11 @@
+AllCops:
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  TargetRubyVersion: 2.4
+  Exclude:
+  - 'bin/**/*'
+  - 'vendor/**/*'
+  - 'tmp/**/*'
+
+Style/PerlBackrefs:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm: 2.5.0
+branches:
+  only: master
+cache: bundler
+script: bin/rubocop && bin/rake

data/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'activesupport', '~> 5.1'

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    fast_underscore (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.1.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    ast (2.3.0)
+    benchmark-ips (2.7.2)
+    concurrent-ruby (1.0.5)
+    i18n (0.9.1)
+      concurrent-ruby (~> 1.0)
+    minitest (5.10.3)
+    parallel (1.12.1)
+    parser (2.4.0.2)
+      ast (~> 2.3)
+    powerpack (0.1.1)
+    rainbow (3.0.0)
+    rake (12.3.0)
+    rake-compiler (0.9.9)
+      rake
+    rubocop (0.52.0)
+      parallel (~> 1.10)
+      parser (>= 2.4.0.2, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.9.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.4)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 5.1)
+  benchmark-ips (~> 2)
+  bundler (~> 1)
+  fast_underscore!
+  minitest (~> 5)
+  rake (~> 12)
+  rake-compiler (~> 0)
+  rubocop (~> 0.52)
+
+BUNDLED WITH
+   1.16.1.pre1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Kevin Deisz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+# `String#underscore` Ruby Extension
+
+`fast_underscore` is a simple C extension which provides a fast implementation of [Active Support's `String#underscore` method](http://api.rubyonrails.org/classes/String.html#method-i-underscore).
+
+## Do I need this?
+
+Maybe! Run a stack profiler like [`ruby-prof`](https://github.com/ruby-prof/ruby-prof). If `String#underscore` is coming up near the top of the list, this gem might be for you! If not, you probably don't need it. Either way, your milage may vary depending on the type of strings on which you're calling `underscore`.
+
+## Is it fast?
+
+At last check, these were the benchmarks (obtained by running `bin/benchmark`):
+
+```
+Warming up --------------------------------------
+       ActiveSupport     2.000  i/100ms
+      FastUnderscore    64.000  i/100ms
+Calculating -------------------------------------
+       ActiveSupport     28.839  (± 6.9%) i/s -    144.000  in   5.019140s
+      FastUnderscore    650.151  (± 7.7%) i/s -      3.264k in   5.056094s
+
+Comparison:
+      FastUnderscore:      650.2 i/s
+       ActiveSupport:       28.8 i/s - 22.54x  slower
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fast_underscore'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fast_underscore
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kddeisz/fast_underscore.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new(:compile) do |ext|
+  ext.name = 'fast_underscore'
+  ext.ext_dir = 'ext/fast_underscore'
+  ext.lib_dir = 'lib/fast_underscore'
+  ext.gem_spec = Gem::Specification.load('fast_underscore.gemspec')
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+Rake::Task[:test].prerequisites << :compile
+
+task default: :test

data/bin/benchmark

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'benchmark/ips'
+
+require 'active_support'
+require 'fast_underscore'
+
+source =
+  %w[_ - : :: / 漢字 😊🎉] + ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
+words = 500.times.map { Array.new(100) { source.sample }.join }
+
+Benchmark.ips do |x|
+  x.report('ActiveSupport') do
+    words.each { |word| ActiveSupport::Inflector.underscore(word) }
+  end
+
+  x.report('FastUnderscore') do
+    words.each { |word| FastUnderscore.underscore(word) }
+  end
+
+  x.compare!
+end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'fast_underscore'
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/rake

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 150) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/rubocop

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rubocop' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 150) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rubocop", "rubocop")

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/ext/fast_underscore/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+create_makefile('fast_underscore/fast_underscore')

data/ext/fast_underscore/fast_underscore.c

@@ -0,0 +1,376 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <stdlib.h>
+
+/**
+ * true if the given codepoint is a lowercase ascii character.
+ */
+static int
+character_is_lower(unsigned int character) {
+  return character >= 'a' && character <= 'z';
+}
+
+/**
+ * true if the given codepoint is a uppercase ascii character.
+ */
+static int
+character_is_upper(unsigned int character) {
+  return character >= 'A' && character <= 'Z';
+}
+
+/**
+ * true if the given codepoint is an ascii digit.
+ */
+static int
+character_is_digit(unsigned int character) {
+  return character >= '0' && character <= '9';
+}
+
+/**
+ * Macros for extracting the character out of the `codepoint_t` struct.
+ */
+#define codepoint_is_lower(codepoint) character_is_lower(codepoint->character)
+#define codepoint_is_upper(codepoint) character_is_upper(codepoint->character)
+#define codepoint_is_digit(codepoint) character_is_digit(codepoint->character)
+
+/**
+ * Macros for shortcuts to call into the `builder_result_push_char` function.
+ */
+#define builder_result_push(builder, codepoint) \
+  builder_result_push_char(builder, codepoint->character, codepoint->size, \
+                           codepoint->encoding)
+#define builder_result_push_literal(builder, character) \
+  builder_result_push_char(builder, character, 1, NULL)
+
+/**
+ * A struct for keeping track of a codepoint from the original string. Maintains
+ * the original encoding, the actual character codepoint, and the size of the
+ * codepoint.
+ */
+typedef struct codepoint {
+  // The encoding of the character
+  rb_encoding *encoding;
+
+  // Representation of a character, regardless of encoding
+  unsigned int character;
+
+  // The size that this character actually represents
+  int size;
+} codepoint_t;
+
+/**
+ * A struct for tracking the built string as it gets converted. Maintains an
+ * internal DFA for transitioning through various inputs to match certain
+ * patterns that need to be separated with underscores.
+ */
+typedef struct builder {
+  // The state of the DFA in which is the builder
+  enum state {
+    STATE_DEFAULT,
+    STATE_COLON,
+    STATE_UPPER_END,
+    STATE_UPPER_START
+  } state;
+
+  // The current segment of text that we're analyzing
+  char *segment;
+  long segment_size;
+
+  // The resultant text from the underscore operation
+  char *result;
+  long result_size;
+
+  // Whether or not the last pushed result character should cause the following
+  // one to be spaced by an underscore
+  int pushNext;
+} builder_t;
+
+/**
+ * Allocate and initialize a `codepoint_t` struct.
+ */
+static codepoint_t*
+codepoint_build(rb_encoding *encoding) {
+  codepoint_t *codepoint = (codepoint_t *) malloc(sizeof(codepoint_t));
+  if (codepoint == NULL) {
+    return NULL;
+  }
+
+  codepoint->encoding = encoding;
+  return codepoint;
+}
+
+/**
+ * Free a previously allocated `codepoint_t` struct.
+ */
+static void
+codepoint_free(codepoint_t *codepoint) {
+  free(codepoint);
+}
+
+/**
+ * Allocate and initialize a `builder_t` struct.
+ */
+static builder_t*
+builder_build(long str_len) {
+  builder_t *builder = (builder_t *) malloc(sizeof(builder_t));
+  if (builder == NULL) {
+    return NULL;
+  }
+
+  builder->state = STATE_DEFAULT;
+  builder->segment = (char *) malloc(str_len * sizeof(unsigned int) * 2);
+
+  if (builder->segment == NULL) {
+    free(builder);
+    return NULL;
+  }
+
+  builder->result = (char *) malloc(str_len * sizeof(unsigned int) * 2);
+
+  if (builder->result == NULL) {
+    free(builder->segment);
+    free(builder);
+    return NULL;
+  }
+
+  builder->segment_size = 0;
+  builder->result_size = 0;
+  builder->pushNext = 0;
+
+  return builder;
+}
+
+/**
+ * Push a character onto the resultant string using the given codepoint and
+ * encoding.
+ */
+static void
+builder_result_push_char(builder_t *builder, unsigned int character, int size,
+                         rb_encoding *encoding) {
+  if (character_is_upper(character)) {
+    if (builder->pushNext == 1) {
+      builder->pushNext = 0;
+      builder_result_push_literal(builder, '_');
+    }
+
+    builder->result[builder->result_size++] = (char) character - 'A' + 'a';
+    return;
+  }
+
+  builder->pushNext = (character_is_lower(character) || character_is_digit(character));
+
+  if (encoding == NULL) {
+    builder->result[builder->result_size++] = (char) character;
+  } else {
+    rb_enc_mbcput(character, &builder->result[builder->result_size], encoding);
+    builder->result_size += size;
+  }
+}
+
+/**
+ * Push the given codepoint onto the builder.
+ */
+static void
+builder_segment_push(builder_t *builder, codepoint_t *codepoint) {
+  builder->segment[builder->segment_size++] = (char) codepoint->character;
+}
+
+/**
+ * Copy the given number of characters out of the segment cache onto the result
+ * string.
+ */
+static void
+builder_segment_copy(builder_t *builder, long size) {
+  for (long idx = 0; idx < size; idx++) {
+    builder_result_push_literal(builder, builder->segment[idx]);
+  }
+}
+
+/**
+ * Restart the `builder_t` back at the default state (because we've hit a
+ * character for which we have no allowed transitions).
+ */
+static void
+builder_restart(builder_t *builder) {
+  builder->state = STATE_DEFAULT;
+  builder->segment_size = 0;
+}
+
+static void builder_next(builder_t *builder, codepoint_t *codepoint);
+
+/**
+ * Pull the remaining content out of the cached segment in case we don't end
+ * parsing while not in the default state.
+ */
+static void
+builder_flush(builder_t *builder) {
+  switch (builder->state) {
+    case STATE_DEFAULT: return;
+    case STATE_COLON:
+      builder_result_push_literal(builder, ':');
+      return;
+    case STATE_UPPER_END:
+    case STATE_UPPER_START:
+      builder_segment_copy(builder, builder->segment_size);
+      return;
+  }
+}
+
+/**
+ * Perform transitions from the STATE_DEFAULT state.
+ */
+static inline void
+builder_default_transition(builder_t *builder, codepoint_t *codepoint) {
+  if (codepoint->character == '-') {
+    builder_result_push_literal(builder, '_');
+    return;
+  }
+  if (codepoint->character == ':') {
+    builder->state = STATE_COLON;
+    return;
+  }
+  if (codepoint_is_digit(codepoint) || codepoint_is_upper(codepoint)) {
+    builder->segment[0] = (char) codepoint->character;
+    builder->segment_size = 1;
+    builder->state = STATE_UPPER_START;
+    return;
+  }
+  builder_result_push(builder, codepoint);
+}
+
+/**
+ * Perform transitions from the STATE_COLON state.
+ */
+static inline void
+builder_colon_transition(builder_t *builder, codepoint_t *codepoint) {
+  if (codepoint->character == ':') {
+    builder_result_push_literal(builder, '/');
+    builder_restart(builder);
+    return;
+  }
+
+  builder_result_push_literal(builder, ':');
+  builder_restart(builder);
+  builder_next(builder, codepoint);
+}
+
+/**
+ * Perform transitions from the STATE_UPPER_START state.
+ */
+static inline void
+builder_upper_start_transition(builder_t *builder, codepoint_t *codepoint) {
+  if (codepoint_is_digit(codepoint)) {
+    builder_segment_push(builder, codepoint);
+    return;
+  }
+  if (codepoint_is_upper(codepoint)) {
+    builder_segment_push(builder, codepoint);
+    builder->state = STATE_UPPER_END;
+    return;
+  }
+
+  builder_segment_copy(builder, builder->segment_size);
+  builder_restart(builder);
+  builder_next(builder, codepoint);
+}
+
+/**
+ * Perform transitions from the STATE_UPPER_END state.
+ */
+static inline void
+builder_upper_end_transition(builder_t *builder, codepoint_t *codepoint) {
+  if (codepoint_is_digit(codepoint)) {
+    builder_segment_push(builder, codepoint);
+    builder->state = STATE_UPPER_START;
+    return;
+  }
+  if (codepoint_is_upper(codepoint)) {
+    builder_segment_push(builder, codepoint);
+    return;
+  }
+  if (codepoint_is_lower(codepoint)) {
+    builder_segment_copy(builder, builder->segment_size - 1);
+    builder_result_push_literal(builder, '_');
+    builder_result_push_literal(builder, builder->segment[builder->segment_size - 1]);
+    builder_restart(builder);
+    builder_next(builder, codepoint);
+    return;
+  }
+
+  builder_segment_copy(builder, builder->segment_size);
+  builder_restart(builder);
+  builder_next(builder, codepoint);
+}
+
+/**
+ * Accept the next codepoint, which will move the `builder_t` struct into the
+ * next state.
+ */
+static void
+builder_next(builder_t *builder, codepoint_t *codepoint) {
+  switch (builder->state) {
+    case STATE_DEFAULT:
+      return builder_default_transition(builder, codepoint);
+    case STATE_COLON:
+      return builder_colon_transition(builder, codepoint);
+    case STATE_UPPER_START:
+      return builder_upper_start_transition(builder, codepoint);
+    case STATE_UPPER_END:
+      return builder_upper_end_transition(builder, codepoint);
+  }
+}
+
+/**
+ * Frees a previously allocated `builder_t` struct.
+ */
+static void
+builder_free(builder_t *builder) {
+  free(builder->segment);
+  free(builder->result);
+  free(builder);
+}
+
+/**
+ * Makes an underscored, lowercase form from the expression in the string.
+ *
+ * Changes '::' to '/' to convert namespaces to paths.
+ *
+ *     underscore('ActiveModel')         # => "active_model"
+ *     underscore('ActiveModel::Errors') # => "active_model/errors"
+ *
+ * As a rule of thumb you can think of +underscore+ as the inverse of
+ * #camelize, though there are cases where that does not hold:
+ *
+ *     camelize(underscore('SSLError'))  # => "SslError"
+ */
+static VALUE
+rb_str_underscore(VALUE self, VALUE rb_string) {
+  rb_encoding *encoding = rb_enc_from_index(ENCODING_GET(rb_string));
+
+  char *string = RSTRING_PTR(rb_string);
+  char *end = RSTRING_END(rb_string);
+
+  builder_t *builder = builder_build(RSTRING_LEN(rb_string) * 2);
+  codepoint_t *codepoint = codepoint_build(encoding);
+
+  while (string < end) {
+    codepoint->character = rb_enc_codepoint_len(string, end, &codepoint->size, encoding);
+    builder_next(builder, codepoint);
+    string += codepoint->size;
+  }
+  builder_flush(builder);
+
+  VALUE resultant = rb_enc_str_new(builder->result, builder->result_size, encoding);
+  builder_free(builder);
+
+  return resultant;
+}
+
+/**
+ * Hook into Ruby and define the `FastUnderscore::underscore`.
+ */
+void
+Init_fast_underscore(void) {
+  VALUE rb_cFastUnderscore = rb_define_module("FastUnderscore");
+  rb_define_singleton_method(rb_cFastUnderscore, "underscore", rb_str_underscore, 1);
+}

data/ext/fast_underscore/fast_underscore.h

@@ -0,0 +1,3 @@
+#ifndef FAST_UNDERSCORE_H
+#define FAST_UNDERSCORE_H
+#endif

data/fast_underscore.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fast_underscore/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'fast_underscore'
+  spec.version       = FastUnderscore::VERSION
+  spec.authors       = ['Kevin Deisz']
+  spec.email         = ['kevin.deisz@gmail.com']
+
+  spec.summary       = 'Fast String#underscore implementation'
+  spec.description   = 'Provides a C-optimized method for underscoring a string'
+  spec.homepage      = 'https://github.com/kddeisz/fast_underscore'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.extensions    = ['ext/fast_underscore/extconf.rb']
+
+  spec.add_development_dependency 'benchmark-ips', '~> 2'
+  spec.add_development_dependency 'bundler', '~> 1'
+  spec.add_development_dependency 'minitest', '~> 5'
+  spec.add_development_dependency 'rake', '~> 12'
+  spec.add_development_dependency 'rake-compiler', '~> 0'
+  spec.add_development_dependency 'rubocop', '~> 0.52'
+end

data/lib/fast_underscore.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'fast_underscore/version'
+require 'fast_underscore/fast_underscore'
+
+if defined?(ActiveSupport)
+  String.prepend(Module.new do
+    def underscore
+      return self unless /[A-Z-]|::/.match?(self)
+
+      acronyms = ActiveSupport::Inflector.inflections.acronym_regex
+      dup.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{acronyms})(?=\b|[^a-z])/) do
+        "#{$1 && '_'}#{$2.downcase}"
+      end
+
+      FastUnderscore.underscore(self)
+    end
+  end)
+else
+  String.prepend(Module.new do
+    def underscore
+      FastUnderscore.underscore(self)
+    end
+  end)
+end

data/lib/fast_underscore/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FastUnderscore
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: fast_underscore
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kevin Deisz
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-12-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.52'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.52'
+description: Provides a C-optimized method for underscoring a string
+email:
+- kevin.deisz@gmail.com
+executables: []
+extensions:
+- ext/fast_underscore/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/benchmark
+- bin/console
+- bin/rake
+- bin/rubocop
+- bin/setup
+- ext/fast_underscore/extconf.rb
+- ext/fast_underscore/fast_underscore.c
+- ext/fast_underscore/fast_underscore.h
+- fast_underscore.gemspec
+- lib/fast_underscore.rb
+- lib/fast_underscore/version.rb
+homepage: https://github.com/kddeisz/fast_underscore
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Fast String#underscore implementation
+test_files: []