fzy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3d9b0ca699907c027e4cc3196971d3bb6cadd90e84d7cbb3e715ab6646560c0f
+  data.tar.gz: 52efaf9f44e76b5c15cd71e2b7b26aaa7364e290de28d0658bf149e282bed2d3
+SHA512:
+  metadata.gz: 6199c4ec774da59b321ca878d7bc60cd9109fd3ceb7b56b785a74e6ba43471dd65a972bb09705e93dc7612d750e2363171265cb4c57bde4d0b9db5ce2a5359db
+  data.tar.gz: bf7d4f1f30ad6fe4050dfed9407fc8e3ebb08f11e4d190dab69476c714819bd4212d9798b32f720a1ef9f1a6f50a418a8e73304d33441627d59a6aa6e49e530b

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at john@hawthorn.email. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in fzy.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,25 @@
+PATH
+  remote: .
+  specs:
+    fzy (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.13.0)
+    rake (10.5.0)
+    rake-compiler (1.0.8)
+      rake
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  fzy!
+  minitest
+  rake (~> 10.0)
+  rake-compiler
+
+BUNDLED WITH
+   1.17.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 John Hawthorn
+
+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,60 @@
+# fzy.rb
+
+A Ruby port of [fzy](https://github.com/jhawthorn/fzy)'s fuzzy finder scoring algorithm
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fzy'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fzy
+
+## Usage
+
+`Fzy.has_match?(needle, haystack)`
+
+``` ruby
+Fzy.has_match?("rb", "ruby")  # => true
+Fzy.has_match?("rb", "bar")   # => false
+```
+
+`Fzy.score(needle, haystack)`
+
+``` ruby
+Fzy.score("amuser", "app/models/user.rb")     # => 5.595
+Fzy.score("amuser", "app/models/customer.rb") # => 3.655
+```
+
+`Fzy.positions(needle, haystack)`
+
+``` ruby
+Fzy.positions("amuser", "app/models/user.rb")     # => [ 0, 4, 11, 12, 13, 14 ]
+Fzy.positions("amuser", "app/models/customer.rb") # => [ 0, 4, 12, 13, 17, 18 ]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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/jhawthorn/fzy. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Fzy project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/jhawthorn/fzy/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+require "rake/testtask"
+
+task :build => :compile
+
+Rake::ExtensionTask.new("fzy") do |ext|
+  ext.lib_dir = "lib/fzy"
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = p(FileList["test/**/*_test.rb"])
+end
+
+task :default => [:clobber, :compile, :test]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fzy"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/config.h

@@ -0,0 +1,8 @@
+#define SCORE_GAP_LEADING -0.005
+#define SCORE_GAP_TRAILING -0.005
+#define SCORE_GAP_INNER -0.01
+#define SCORE_MATCH_CONSECUTIVE 1.0
+#define SCORE_MATCH_SLASH 0.9
+#define SCORE_MATCH_WORD 0.8
+#define SCORE_MATCH_CAPITAL 0.7
+#define SCORE_MATCH_DOT 0.6

data/ext/fzy/bonus.h

@@ -0,0 +1,108 @@
+#ifndef BONUS_H
+#define BONUS_H BONUS_H
+
+#include "../config.h"
+
+#define ASSIGN_LOWER(v) \
+	['a'] = (v), \
+	['b'] = (v), \
+	['c'] = (v), \
+	['d'] = (v), \
+	['e'] = (v), \
+	['f'] = (v), \
+	['g'] = (v), \
+	['h'] = (v), \
+	['i'] = (v), \
+	['j'] = (v), \
+	['k'] = (v), \
+	['l'] = (v), \
+	['m'] = (v), \
+	['n'] = (v), \
+	['o'] = (v), \
+	['p'] = (v), \
+	['q'] = (v), \
+	['r'] = (v), \
+	['s'] = (v), \
+	['t'] = (v), \
+	['u'] = (v), \
+	['v'] = (v), \
+	['w'] = (v), \
+	['x'] = (v), \
+	['y'] = (v), \
+	['z'] = (v)
+
+#define ASSIGN_UPPER(v) \
+	['A'] = (v), \
+	['B'] = (v), \
+	['C'] = (v), \
+	['D'] = (v), \
+	['E'] = (v), \
+	['F'] = (v), \
+	['G'] = (v), \
+	['H'] = (v), \
+	['I'] = (v), \
+	['J'] = (v), \
+	['K'] = (v), \
+	['L'] = (v), \
+	['M'] = (v), \
+	['N'] = (v), \
+	['O'] = (v), \
+	['P'] = (v), \
+	['Q'] = (v), \
+	['R'] = (v), \
+	['S'] = (v), \
+	['T'] = (v), \
+	['U'] = (v), \
+	['V'] = (v), \
+	['W'] = (v), \
+	['X'] = (v), \
+	['Y'] = (v), \
+	['Z'] = (v)
+
+#define ASSIGN_DIGIT(v) \
+	['0'] = (v), \
+	['1'] = (v), \
+	['2'] = (v), \
+	['3'] = (v), \
+	['4'] = (v), \
+	['5'] = (v), \
+	['6'] = (v), \
+	['7'] = (v), \
+	['8'] = (v), \
+	['9'] = (v)
+
+const score_t bonus_states[3][256] = {
+	{ 0 },
+	{
+		['/'] = SCORE_MATCH_SLASH,
+		['-'] = SCORE_MATCH_WORD,
+		['_'] = SCORE_MATCH_WORD,
+		[' '] = SCORE_MATCH_WORD,
+		['.'] = SCORE_MATCH_DOT,
+	},
+	{
+		['/'] = SCORE_MATCH_SLASH,
+		['-'] = SCORE_MATCH_WORD,
+		['_'] = SCORE_MATCH_WORD,
+		[' '] = SCORE_MATCH_WORD,
+		['.'] = SCORE_MATCH_DOT,
+
+		/* ['a' ... 'z'] = SCORE_MATCH_CAPITAL, */
+		ASSIGN_LOWER(SCORE_MATCH_CAPITAL)
+	}
+};
+
+const size_t bonus_index[256] = {
+	/* ['A' ... 'Z'] = 2 */
+	ASSIGN_UPPER(2),
+
+	/* ['a' ... 'z'] = 1 */
+	ASSIGN_LOWER(1),
+
+	/* ['0' ... '9'] = 1 */
+	ASSIGN_DIGIT(1)
+};
+
+#define COMPUTE_BONUS(last_ch, ch) (bonus_states[bonus_index[(unsigned char)(ch)]][(unsigned char)(last_ch)])
+
+#endif

data/ext/fzy/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile("fzy/fzy")

data/ext/fzy/fzy.c

@@ -0,0 +1,50 @@
+#include "fzy.h"
+#include "match.h"
+
+static VALUE rb_mFzy;
+
+static VALUE
+rb_has_match(VALUE _, VALUE needle, VALUE haystack) {
+  const char *needle_str = StringValueCStr(needle);
+  const char *haystack_str = StringValueCStr(haystack);
+  int match = has_match(needle_str, haystack_str);
+
+  return match ? Qtrue : Qfalse;
+}
+
+static VALUE
+rb_score(VALUE _, VALUE needle, VALUE haystack) {
+  const char *needle_str = StringValueCStr(needle);
+  const char *haystack_str = StringValueCStr(haystack);
+  double score = match(needle_str, haystack_str);
+
+  return DBL2NUM(score);
+}
+
+static VALUE
+rb_positions(VALUE _, VALUE needle, VALUE haystack) {
+  const char *needle_str = StringValueCStr(needle);
+  const char *haystack_str = StringValueCStr(haystack);
+  size_t size = RSTRING_LEN(needle);
+  VALUE arr = rb_ary_new2(size);
+
+  size_t *positions = xcalloc(size, sizeof(size_t));
+  match_positions(needle_str, haystack_str, positions);
+
+  for (size_t i = 0; i < size; i++) {
+    rb_ary_push(arr, ULL2NUM(positions[i]));
+  }
+
+  xfree(positions);
+  return arr;
+}
+
+void
+Init_fzy(void)
+{
+  rb_mFzy = rb_define_module("Fzy");
+
+  rb_define_module_function(rb_mFzy, "has_match?", rb_has_match, 2);
+  rb_define_module_function(rb_mFzy, "score", rb_score, 2);
+  rb_define_module_function(rb_mFzy, "positions", rb_positions, 2);
+}

data/ext/fzy/fzy.h

@@ -0,0 +1,6 @@
+#ifndef FZY_H
+#define FZY_H 1
+
+#include "ruby.h"
+
+#endif /* FZY_H */

data/ext/fzy/match.c

@@ -0,0 +1,181 @@
+#include <ctype.h>
+#include <string.h>
+#include <strings.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+#include "match.h"
+#include "bonus.h"
+
+#include "../config.h"
+
+char *strcasechr(const char *s, char c) {
+	const char accept[3] = {c, toupper(c), 0};
+	return strpbrk(s, accept);
+}
+
+int has_match(const char *needle, const char *haystack) {
+	while (*needle) {
+		char nch = *needle++;
+
+		if (!(haystack = strcasechr(haystack, nch))) {
+			return 0;
+		}
+		haystack++;
+	}
+	return 1;
+}
+
+#define max(a, b) (((a) > (b)) ? (a) : (b))
+
+#ifdef DEBUG_VERBOSE
+/* print one of the internal matrices */
+void mat_print(score_t *mat, char name, const char *needle, const char *haystack) {
+	int n = strlen(needle);
+	int m = strlen(haystack);
+	int i, j;
+	fprintf(stderr, "%c   ", name);
+	for (j = 0; j < m; j++) {
+		fprintf(stderr, "     %c", haystack[j]);
+	}
+	fprintf(stderr, "\n");
+	for (i = 0; i < n; i++) {
+		fprintf(stderr, " %c |", needle[i]);
+		for (j = 0; j < m; j++) {
+			score_t val = mat[i * m + j];
+			if (val == SCORE_MIN) {
+				fprintf(stderr, "    -\u221E");
+			} else {
+				fprintf(stderr, " %.3f", val);
+			}
+		}
+		fprintf(stderr, "\n");
+	}
+	fprintf(stderr, "\n\n");
+}
+#endif
+
+static void precompute_bonus(const char *haystack, score_t *match_bonus) {
+	/* Which positions are beginning of words */
+	int m = strlen(haystack);
+	char last_ch = '/';
+	for (int i = 0; i < m; i++) {
+		char ch = haystack[i];
+		match_bonus[i] = COMPUTE_BONUS(last_ch, ch);
+		last_ch = ch;
+	}
+}
+
+score_t match_positions(const char *needle, const char *haystack, size_t *positions) {
+	if (!*needle)
+		return SCORE_MIN;
+
+	int n = strlen(needle);
+	int m = strlen(haystack);
+
+	if (n == m) {
+		/* Since this method can only be called with a haystack which
+		 * matches needle. If the lengths of the strings are equal the
+		 * strings themselves must also be equal (ignoring case).
+		 */
+		if (positions)
+			for (int i = 0; i < n; i++)
+				positions[i] = i;
+		return SCORE_MAX;
+	}
+
+	if (m > 1024) {
+		/*
+		 * Unreasonably large candidate: return no score
+		 * If it is a valid match it will still be returned, it will
+		 * just be ranked below any reasonably sized candidates
+		 */
+		return SCORE_MIN;
+	}
+
+	char lower_needle[n];
+	char lower_haystack[m];
+
+	for (int i = 0; i < n; i++)
+		lower_needle[i] = tolower(needle[i]);
+
+	for (int i = 0; i < m; i++)
+		lower_haystack[i] = tolower(haystack[i]);
+
+	score_t match_bonus[m];
+	score_t D[n][m], M[n][m];
+
+	/*
+	 * D[][] Stores the best score for this position ending with a match.
+	 * M[][] Stores the best possible score at this position.
+	 */
+	precompute_bonus(haystack, match_bonus);
+
+	for (int i = 0; i < n; i++) {
+		score_t prev_score = SCORE_MIN;
+		score_t gap_score = i == n - 1 ? SCORE_GAP_TRAILING : SCORE_GAP_INNER;
+
+		for (int j = 0; j < m; j++) {
+			if (lower_needle[i] == lower_haystack[j]) {
+				score_t score = SCORE_MIN;
+				if (!i) {
+					score = (j * SCORE_GAP_LEADING) + match_bonus[j];
+				} else if (j) { /* i > 0 && j > 0*/
+					score = max(
+					    M[i - 1][j - 1] + match_bonus[j],
+
+					    /* consecutive match, doesn't stack with match_bonus */
+					    D[i - 1][j - 1] + SCORE_MATCH_CONSECUTIVE);
+				}
+				D[i][j] = score;
+				M[i][j] = prev_score = max(score, prev_score + gap_score);
+			} else {
+				D[i][j] = SCORE_MIN;
+				M[i][j] = prev_score = prev_score + gap_score;
+			}
+		}
+	}
+
+#ifdef DEBUG_VERBOSE
+	fprintf(stderr, "\"%s\" =~ \"%s\"\n", needle, haystack);
+	mat_print(&D[0][0], 'D', needle, haystack);
+	mat_print(&M[0][0], 'M', needle, haystack);
+	fprintf(stderr, "\n");
+#endif
+
+	/* backtrace to find the positions of optimal matching */
+	if (positions) {
+		int match_required = 0;
+		for (int i = n - 1, j = m - 1; i >= 0; i--) {
+			for (; j >= 0; j--) {
+				/*
+				 * There may be multiple paths which result in
+				 * the optimal weight.
+				 *
+				 * For simplicity, we will pick the first one
+				 * we encounter, the latest in the candidate
+				 * string.
+				 */
+				if (D[i][j] != SCORE_MIN &&
+				    (match_required || D[i][j] == M[i][j])) {
+					/* If this score was determined using
+					 * SCORE_MATCH_CONSECUTIVE, the
+					 * previous character MUST be a match
+					 */
+					match_required =
+					    i && j &&
+					    M[i][j] == D[i - 1][j - 1] + SCORE_MATCH_CONSECUTIVE;
+					positions[i] = j--;
+					break;
+				}
+			}
+		}
+	}
+
+	return M[n - 1][m - 1];
+}
+
+score_t match(const char *needle, const char *haystack) {
+	return match_positions(needle, haystack, NULL);
+}

data/ext/fzy/match.h

@@ -0,0 +1,14 @@
+#ifndef MATCH_H
+#define MATCH_H MATCH_H
+
+#include <math.h>
+
+typedef double score_t;
+#define SCORE_MAX INFINITY
+#define SCORE_MIN -INFINITY
+
+int has_match(const char *needle, const char *haystack);
+score_t match_positions(const char *needle, const char *haystack, size_t *positions);
+score_t match(const char *needle, const char *haystack);
+
+#endif

data/fzy.gemspec

@@ -0,0 +1,31 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "fzy/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "fzy"
+  spec.version       = Fzy::VERSION
+  spec.authors       = ["John Hawthorn"]
+  spec.email         = ["john@hawthorn.email"]
+
+  spec.summary       = %q{A better fuzzy finder}
+  spec.description   = %q{fzy is a fast fuzzy text selector with an advanced scoring algorithm}
+  spec.homepage      = "https://github.com/jhawthorn/fzy.js"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |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/fzy/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "minitest"
+end

data/lib/fzy.rb

@@ -0,0 +1,27 @@
+require "fzy/version"
+require "fzy/fzy"
+
+module Fzy
+  class Error < StandardError; end
+
+  class Match
+    def initialize(needle, haystack)
+      @needle = needle
+      @haystack = haystack
+    end
+
+    def score
+      @score ||= Fzy.score(@needle, @haystack)
+    end
+
+    def positions
+      @positions ||= Fzy.positions(@needle, @haystack)
+    end
+  end
+
+  def self.match(needle, haystack)
+    if has_match?(needle, haystack)
+      Match.new(needle, haystack)
+    end
+  end
+end

data/lib/fzy/version.rb

@@ -0,0 +1,3 @@
+module Fzy
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: fzy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- John Hawthorn
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !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: minitest
+  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'
+description: fzy is a fast fuzzy text selector with an advanced scoring algorithm
+email:
+- john@hawthorn.email
+executables: []
+extensions:
+- ext/fzy/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/config.h
+- ext/fzy/bonus.h
+- ext/fzy/extconf.rb
+- ext/fzy/fzy.c
+- ext/fzy/fzy.h
+- ext/fzy/match.c
+- ext/fzy/match.h
+- fzy.gemspec
+- lib/fzy.rb
+- lib/fzy/version.rb
+homepage: https://github.com/jhawthorn/fzy.js
+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: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A better fuzzy finder
+test_files: []