rusty_key 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7167c2c8764597614b0f0e91433bfb4518eb2406df9d2d9dbd69628d12cc6759
+  data.tar.gz: 12d40ff99010b05274847849426772575dc4e6f89e81fa5bb34fdfdd4042b30b
+SHA512:
+  metadata.gz: aef7638538d6e04b4d6aa4dde985c1366492c5a43390d38a02519a0551516b584817a9452b65b4e832600fcf59aba9287e08d9474ca114fe3d15f4a1b6372efa
+  data.tar.gz: '088d5911ee9b0daf8afa2642de25fe152f61f534ec6874b5988f7aa4673c65ac4201c0c529c52fd41e6b67c4c11898eed27d3db6d562a2686a6e5aceaa65f499'

data/.gitignore

@@ -0,0 +1,12 @@
+Gemfile.lock
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.0
+before_install: gem install bundler -v 2.0.1

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 mkg@fastmail.com. 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,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rusty.gemspec
+gemspec

data/README.md

@@ -0,0 +1,158 @@
+# rusty_key
+
+This gem replaces many keywords with more-or-less equivalent method calls.
+
+## Why?
+
+I made a joke about Rust's proposed ["dot keyword" syntax](https://boats.gitlab.io/blog/post/await-decision/), namely that they should apply it to all their keywords.
+
+Then I took that joke too far.
+
+I have nothing but respect for the Rust Lang Team's work, and their proposal regarding the `await` keyword makes perfect sense to me. This is just a well-intentioned goof.
+
+## Usage
+
+Don't?
+
+If you really want to, start with this:
+
+```ruby
+require 'rusty_key'
+
+RustyKey.using
+```
+
+Below are some things you can do, but it's probably not an exhaustive list. Consider using braces rather than `do` and `end` to heighten the effect.
+
+# Define methods
+```ruby
+:foo.def { |x, y, *zs, key: value, &block|
+  # stuff
+}
+```
+
+# Define and monkey patch classes
+```ruby
+:Dog.class {
+  :initialize.def { |color|
+    # stuff
+  }
+
+  :bark.def {
+    "wruff!"
+  }
+}
+
+Dog.new(:green).bark # => "wruff!"
+```
+
+# Define and monkey patch modules
+```ruby
+:PrettyBow.module {
+  # stuff
+}
+```
+# using, alias, include, extend
+```ruby
+:RustyKey.using
+```
+```ruby
+:f.def { |x|
+  # stuff
+}
+:func.alias :f
+```
+```ruby
+:String.class {
+  :Cheese.include
+  :Kite.extend
+}
+```
+
+# Flow control
+```ruby
+computation = -> { expensive }
+computation.if(necessary?)
+  .else_if(cheap_check) { one_thing }
+  .elsif(-> { expensive_check }) { another_thing }
+  .else! { go_to_sleep }
+```
+
+# Boolean logic
+```ruby
+false.or { true } # => truthy
+false.and { expensive } # => falsey
+400.and { 20 } # => truthy
+```
+
+# Case expressions
+```ruby
+x.case
+  .when(String) { "It's a string!" }
+  .when(0..10) { "Pretty small..." }
+  .when(-> y { y.respond_to? :phone }) { "Hello? }
+  .else { go_to_sleep } 
+```
+
+# Raise and handle exceptions
+```ruby
+# raises RuntimeError, like `raise "msg"`
+"something's wrong!".raise
+```
+```ruby
+-> {
+  ArgumentError.new("no arguing!").raise
+}.rescue(OtherError, DifferentError) { |e|
+  # not called
+}.rescue(ArgumentError) { |e|
+  puts "Please don't argue!"
+}.rescue(Exception) { |e|
+  # already caught, so this isn't called
+}.rescue { |e|
+  # would catch any uncaught StandardError
+}.ensure! {
+  puts "Thank you for following the rules."
+}
+```
+
+# return and yield
+```ruby
+:f.def { |x|
+  -> { x / 3 }.return_if(x > 10) # guard clause
+  (x * 3).return # explicit return
+}
+```
+```ruby
+:takes_block.def { |&block|
+  25.yield # yields 25 to block
+}
+```
+
+## Caveats
+
+* Nested classes (and possibly other nested things) don't work.
+* There's no replacement for `refine`.
+* For `#elsif`/`#else_if`, wrap conditions in procs or they will always get evaluated.
+* Specifically the class `Module` can't be monkey patched this way, or at least it couldn't at some point. Haven't tested that in a while.
+* Speaking of which: There are no automated tests. I didn't think this would continue to the point where I might need them; I was wrong.
+* Use `#return_if` and `#return_unless` for conditional returns (e.g. guard clauses) unless you're very comfortable with the difference in semantics between regular procs and lambdas.
+
+## Acknowledgements
+
+I'd like to thank:
+
+* John Mair, whose [binding_of_caller gem](https://github.com/banister/binding_of_caller), released under the MIT license, makes most of this possible.
+* The Rust Lang Team, who do great work and inspire terrible jokes.
+* Matz, who will hopefully not ban me from using Ruby for releasing this.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/smoochbot/rusty. 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.
+
+## Unlicense
+
+This is free and unencumbered software released into the [public domain](http://unlicense.org).
+
+## Code of Conduct
+
+Everyone interacting in the Rusty project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/smoochbot/rusty/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/UNLICENSE

@@ -0,0 +1,25 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org/>
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rusty_key"
+
+# 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/example/definitions.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+# A demonstration of how to define classes, methods and aliases using rusty.
+
+require_relative '../lib/rusty_key.rb'
+
+RustyKey.using
+
+:StringBuilder.class {
+  :initialize.def { |*strs|
+    @string = strs.join.dup
+  }
+
+  :<<.def { |*strs|
+    @string << strs.join
+    self
+  }
+  :append.alias :<<
+
+  :to_s.def {
+    @string.dup.freeze
+  }
+}
+
+sb = StringBuilder.new("This ", "is ")
+sb << "how "
+sb.append("rusty_", "key ") << "works."
+
+puts sb.to_s
+#=> This is how rusty_key works.
+

data/lib/rusty_key/boolean.rb

@@ -0,0 +1,120 @@
+module RustyKey
+  refine Object do
+    def and
+      raise ArgumentError("Object#and requires a block") unless block_given?
+      self && yield
+    end
+
+    def or
+      raise ArgumentError("Object#or requires a block") unless block_given?
+      self || yield
+    end
+
+    def if(condition)
+      -> { self }.if(condition)
+    end
+
+    def unless(condition)
+      -> { self }.unless(condition)
+    end
+
+    def if!(condition)
+      self.if(condition).call
+    end
+
+    def unless!(condition)
+      self.unless(condition).call
+    end
+
+    def return_if(condition)
+      if condition
+        result = self.if!(condition)
+        id = result.object_id
+        binding.of_caller(1).eval("return ObjectSpace._id2ref(#{id})")
+      end
+    end
+
+    def return_unless(condition)
+      unless condition
+        result = self.unless!(condition)
+        id = result.object_id
+        binding.of_caller(1).eval("return ObjectSpace._id2ref(#{id})")
+      end
+    end
+  end
+
+  refine Proc do
+    def if(condition)
+      Conditional.if(self, condition)
+    end
+
+    def unless(condition)
+      Conditional.unless(self, condition)
+    end
+  end
+
+  private
+
+  class Conditional
+    private_class_method :new
+
+    private
+
+    def check(condition)
+      if condition.respond_to?(:call)
+        !!condition.call
+      else
+        !!condition
+      end
+    end
+
+    attr_accessor :found, :result, :otherwise
+
+    def initialize(action, negate, condition)
+      self.found = negate ? !check(condition) : check(condition)
+      self.result = found ? action : -> {}
+    end
+
+    public
+
+    class << self
+      def if(action, condition)
+        new(action, false, condition)
+      end
+      def unless(action, condition)
+        new(action, true, condition)
+      end
+    end
+
+    def elsif(condition, &action)
+      if !found && check(condition)
+        self.found = true
+        self.result = action
+      end
+      self
+    end
+    alias else_if elsif
+
+    def call
+      if found
+        result&.call
+      else
+        otherwise&.call
+      end
+    end
+
+    def else(&action)
+      self.otherwise = action
+      self
+    end
+
+    def else!(&action)
+      self.else(&action)
+      self.call
+    end
+
+    def to_proc
+      -> { self.call }
+    end
+  end
+end

data/lib/rusty_key/case.rb

@@ -0,0 +1,33 @@
+module RustyKey
+  refine Object do
+    def case
+      Case.new(self)
+    end
+  end
+
+  private
+
+  class Case
+    def initialize(value)
+      @value = value
+      @found = false
+      @result = -> {}
+    end
+
+    def when(condition, &block)
+      if !@found && condition === @value
+        @found = true
+        @result = block
+      end
+      self
+    end
+
+    def else(&block)
+      if @found
+        @result&.call(@value)
+      else
+        block&.call(@value)
+      end
+    end
+  end
+end

data/lib/rusty_key/definition.rb

@@ -0,0 +1,97 @@
+module RustyKey
+  refine Symbol do
+    def def(&b)
+      binding.of_caller(1).eval('self').send(:define_method, self, b || -> {})
+      self
+    end
+
+    def alias(original)
+      binding.of_caller(1).eval("alias #{self} #{original}")
+    end
+
+    def include
+      binding.of_caller(1).eval("include #{self}")
+    end
+
+    def extend
+      binding.of_caller(1).eval("extend #{self}")
+    end
+
+    alias _class class
+    def class(&b)
+      return _class unless b
+      # get context in which we're trying to define our class
+      context = binding.of_caller(1).eval('self.class')
+      # does a class with this name already exist?
+      if context.const_defined?(self) &&
+        context.const_get(self).is_a?(Class)
+        # a class with this name does exist! we don't want to just replace it,
+        # so let's get to monkey patching.
+        context.const_get(self).class_eval(&b)
+      else
+        # there's no class with this name. there might be another constant,
+        # but who cares? TODO: care
+        context.const_set(self, Class.new(&b))
+      end
+      nil
+    end
+    alias Class class
+    alias clazz Class
+    alias klass Class
+
+    def Module(&b)
+      # get context in which we're trying to define our module
+      context = binding.of_caller(1).eval('self.class')
+      # does a module (not a class!) with this name already exist?
+      if context.const_defined?(self) &&
+          !context.const_get(self).is_a?(Class) &&
+          context.const_get(self).is_a?(Module)
+        # a module with this name does exist! we don't want to just replace it,
+        # so let's get to monkey patching.
+        context.const_get(self).module_eval(&b)
+      else
+        # there's no module with this name. there might be another constant,
+        # but who cares? TODO: care
+        context.const_set(self, Module.new(&b))
+      end
+      nil
+    end
+    alias module Module
+  end
+
+  refine Class do
+    alias _class class
+    def class(&b)
+      b ? self.class_eval(&b) : _class
+    end
+    alias Class class
+    alias clazz Class
+    alias klass Class
+  end
+
+  refine Module do
+    def Module(&b)
+      self.module_eval(&b)
+    end
+    alias module Module
+
+    alias _include include
+    alias _extend extend
+
+    def include(*args)
+      if args.empty?
+        binding.of_caller(1).eval("include #{self}")
+      else
+        _include(*args)
+      end
+    end
+
+    def extend(*args)
+      if args.empty?
+        binding.of_caller(1).eval("extend #{self}")
+      else
+        _extend(*args)
+      end
+    end
+  end
+end

data/lib/rusty_key/exception.rb

@@ -0,0 +1,89 @@
+require 'binding_of_caller'
+
+module RustyKey
+  refine Exception do
+    def raise
+      id = self.object_id
+      binding.of_caller(1).eval("raise ObjectSpace._id2ref(#{id})")
+    end
+  end
+
+  refine String do
+    def raise
+      binding.of_caller(1).eval("raise \"#{self}\"")
+    end
+  end
+
+  refine Proc do
+    def rescue(*types, &handler)
+      RescuedProc.new(self, *types, &handler)
+    end
+  end
+
+  private
+
+  class RescuedProc
+
+    private
+
+    attr_accessor :prc, :handlers, :otherwise, :finally, :result
+
+    def merge_handlers(handler, *types, initial: handlers)
+      # rescue clause with unspecified type handles StandardError
+      types << StandardError if types.empty?
+      types.reduce(initial) do |acc, k|
+        # rescue clauses should be prioritized by order of declaration, desc
+        acc.merge(k => handler) { |k, existing| existing }
+      end
+    end
+
+    public
+
+    def initialize(wrapped, *types, &handler)
+      self.handlers = merge_handlers(handler, *types, initial: {})
+      self.prc = wrapped
+      self.result = nil
+    end
+
+    def rescue(*types, &handler)
+      self.handlers = merge_handlers(handler, *types)
+      self
+    end
+
+    def else(&handler)
+      self.otherwise = handler
+      self
+    end
+
+    def call
+      begin
+        self.result = prc.call
+      rescue Exception => e
+        if match = handlers.find { |type, handler| e.is_a? type }&.last
+          match&.call(e)
+        else
+          raise e
+        end
+      else
+        otherwise&.call
+      ensure
+        finally&.call
+      end
+      result
+    end
+
+    def to_proc
+      -> { self.call }
+    end
+
+    def ensure(&handler)
+      self.finally = handler
+      self
+    end
+
+    def ensure!(&handler)
+      self.ensure(&handler)
+      self.call
+    end
+  end
+end

data/lib/rusty_key/misc.rb

@@ -0,0 +1,18 @@
+module RustyKey
+  refine Object do
+    def return
+      id = self.object_id
+      binding.of_caller(1).eval("return ObjectSpace._id2ref(#{id})")
+    end
+
+    def yield
+      b = binding.of_caller(1)
+      # this is kinda hacky, but it is fun
+      if b.local_variables.include? :block
+        b.eval("block.call(#{self})")
+      else
+        b.eval("yield #{self}")
+      end
+    end
+  end
+end

data/lib/rusty_key/version.rb

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

data/lib/rusty_key.rb

@@ -0,0 +1,29 @@
+require 'binding_of_caller'
+require 'rusty_key/version'
+require 'rusty_key/definition'
+require 'rusty_key/case'
+require 'rusty_key/boolean'
+require 'rusty_key/exception'
+require 'rusty_key/misc'
+
+module RustyKey
+end
+
+## monkey-patching these to allow `RustyKey.using`
+
+class Symbol
+  def using
+    b = binding.of_caller(1)
+    b.eval("using #{self}")
+    b
+  end
+end
+
+class Module
+  def using
+    b = binding.of_caller(1)
+    b.eval("using #{self}")
+    b
+  end
+end
+

data/rusty_key.gemspec

@@ -0,0 +1,40 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rusty_key/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rusty_key"
+  spec.version       = RustyKey::VERSION
+  spec.authors       = ["Margaret K. Geiger"]
+  spec.email         = ["mkg@fastmail.com"]
+
+  spec.summary       = %q{Replaces keywords with method calls.}
+  spec.homepage      = "https://github.com/smoochbot/rusty_key"
+  spec.license       = "Public Domain"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = spec.homepage 
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # 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.add_runtime_dependency "binding_of_caller"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: rusty_key
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Margaret K. Geiger
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: binding_of_caller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- mkg@fastmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- README.md
+- Rakefile
+- UNLICENSE
+- bin/console
+- bin/setup
+- example/definitions.rb
+- lib/rusty_key.rb
+- lib/rusty_key/boolean.rb
+- lib/rusty_key/case.rb
+- lib/rusty_key/definition.rb
+- lib/rusty_key/exception.rb
+- lib/rusty_key/misc.rb
+- lib/rusty_key/version.rb
+- rusty_key.gemspec
+homepage: https://github.com/smoochbot/rusty_key
+licenses:
+- Public Domain
+metadata:
+  homepage_uri: https://github.com/smoochbot/rusty_key
+  source_code_uri: https://github.com/smoochbot/rusty_key
+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.1
+signing_key: 
+specification_version: 4
+summary: Replaces keywords with method calls.
+test_files: []