0.02
A long-lived project that still receives updates
A collection of refinements to core Ruby objects.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
 Project Readme

Refinements

Gem Version
Alchemists Style Guide
Circle CI Status

A collection of refinements (enhancements) to primitive Ruby objects.

Table of Contents
  • Features
  • Requirements
  • Setup
  • Usage
    • Requires
    • Using
    • Examples
      • Array
        • #compress
        • #compress!
        • #excluding
        • #including
        • #intersperse
        • #mean
        • #pad
        • #ring
      • Big Decimal
        • #inspect
      • DateTime
        • .utc
      • Hash
        • .infinite
        • .with_default
        • #deep_merge
        • #deep_merge!
        • #deep_stringify_keys
        • #deep_stringify_keys!
        • #deep_symbolize_keys
        • #deep_symbolize_keys!
        • #flatten_keys
        • #flatten_keys!
        • #recurse
        • #stringify_keys
        • #stringify_keys!
        • #symbolize_keys
        • #symbolize_keys!
        • #use
      • IO
        • .void
        • #redirect
        • #reread
        • #squelch
      • Pathname
        • Pathname
        • .home
        • .make_temp_dir
        • .require_tree
        • .root
        • #change_dir
        • #copy
        • #directories
        • #extensions
        • #files
        • #gsub
        • #make_ancestors
        • #make_dir
        • #make_path
        • #name
        • #relative_parent
        • #remove_dir
        • #remove_tree
        • #rewrite
        • #touch
        • #write
      • String
        • #blank?
        • #camelcase
        • #down
        • #first
        • #indent
        • #last
        • #snakecase
        • #titleize
        • #to_bool
        • #up
      • String IO
        • #reread
      • Struct
        • .keyworded?
        • .with_keywords
        • .with_positions
        • #merge
        • #merge!
        • #revalue
        • #revalue!
  • Development
  • Tests
  • Versioning
  • Code of Conduct
  • Contributions
  • License
  • History
  • Credits

Features

Enhances the following objects:

  • Array

  • BigDecimal

  • DateTime

  • Hash

  • IO

  • Pathname

  • String

  • StringIO

  • Structs

Requirements

  1. Ruby.

  2. A solid understanding of Ruby refinements and lexical scope.

Setup

To install, run:

gem install refinements

Add the following to your Gemfile file:

gem "refinements"

Usage

Requires

If all refinements are not desired, add the following to your Gemfile instead:

gem "refinements", require: false

…​then require the specific refinement, as needed. Example:

require "refinements/arrays"
require "refinements/big_decimals"
require "refinements/date_times"
require "refinements/hashes"
require "refinements/ios"
require "refinements/pathnames"
require "refinements/strings"
require "refinements/string_ios"
require "refinements/structs"

Using

Much like including/extending a module, you’ll need to modify your object(s) to use the refinement(s):

class Example
  using Refinements::Arrays
  using Refinements::BigDecimals
  using Refinements::DateTimes
  using Refinements::Hashes
  using Refinements::IOs
  using Refinements::Pathnames
  using Refinements::Strings
  using Refinements::StringIOs
  using Refinements::Structs
end

Examples

The following sections demonstrate how each refinement enriches your objects with new capabilities.

Array

#compress

Removes nil and empty values without mutating itself.

example = ["An", nil, "", "Example"]
example.compress  # => ["An", "Example"]
example           # => ["An", nil, "", "Example"]
#compress!

Removes nil and empty values while mutating itself.

example = ["An", nil, "", "Example"]
example.compress!  # => ["An", "Example"]
example            # => ["An", "Example"]
#excluding

Removes given array or elements without mutating itself.

[1, 2, 3, 4, 5].excluding [4, 5]  # => [1, 2, 3]
[1, 2, 3, 4, 5].excluding 4, 5    # => [1, 2, 3]
#including

Adds given array or elements without mutating itself.

[1, 2, 3].including [4, 5]  # => [1, 2, 3, 4, 5]
[1, 2, 3].including 4, 5    # => [1, 2, 3, 4, 5]
#intersperse

Inserts additional elements or array between all members of given array.

[1, 2, 3].intersperse :a         # => [1, :a, 2, :a, 3]
[1, 2, 3].intersperse :a, :b     # => [1, :a, :b, 2, :a, :b, 3]
[1, 2, 3].intersperse %i[a b c]  # => [1, :a, :b, :c, 2, :a, :b, :c, 3]
#mean

Answers mean/average all elements within an array.

[].mean                 # => 0
[5].mean                # => 5
[1, 2, 3].mean          # => 2
[1.25, 1.5, 1.75].mean  # => 1.5
#pad

Answers new array padded with given value up to a maximum size. Useful in situations where an array needs to be a specific size with padded values.

[1].pad 0             # => [1]
[1].pad 0, max: 3     # => [1, 0, 0]
[1, 2].pad 3, max: 3  # => [1, 2, 3]
#ring

Answers a circular array which can enumerate before, current, after elements.

example = [1, 2, 3]
example.ring # => #<Enumerator: ...>
example.ring { |(before, current, after)| puts "#{before} #{current} #{after}" }

# [3 1 2]
# [1 2 3]
# [2 3 1]

Big Decimal

#inspect

Allows one to inspect a big decimal with numeric representation.

BigDecimal.new("5.0E-10").inspect # => "#<BigDecimal:3fd3d458fe84 0.0000000005>"

DateTime

.utc

Answers new DateTime object for current UTC date/time.

DateTime.utc # => #<DateTime: 2019-12-31T18:17:00+00:00 ((2458849j,65820s,181867000n),+0s,2299161j)>

Hash

.infinite

Answers new hash where missing keys, even deeply nested, answer an empty hash.

example = Hash.infinite
example[:a]          # => {}
example[:a][:b][:c]  # => {}
.with_default

Answers new hash where every top-level missing key has the same default value.

example = Hash.with_default ""
example[:a]  # => ""

example = Hash.with_default []
example[:b]  # => []
#deep_merge

Merges deeply nested hashes together without mutating itself.

example = {a: "A", b: {one: "One", two: "Two"}}
example.deep_merge b: {one: 1}  # => {a: "A", b: {one: 1, two: "Two"}}
example                         # => {a: "A", b: {one: "One", two: "Two"}}
#deep_merge!

Merges deeply nested hashes together while mutating itself.

example = {a: "A", b: {one: "One", two: "Two"}}
example.deep_merge! b: {one: 1}  # => {a: "A", b: {one: 1, two: "Two"}}
example                          # => {a: "A", b: {one: 1, two: "Two"}}
#deep_stringify_keys

Stringifies keys of nested hash without mutating itself. Does not handle nested arrays, though.

example = {a: {b: 2}}
example.deep_stringify_keys  # => {"a" => {"b" => 1}}
example                      # => {a: {b: 2}}
#deep_stringify_keys!

Stringifies keys of nested hash while mutating itself. Does not handle nested arrays, though.

example = {a: {b: 2}}
example.deep_stringify_keys!  # => {"a" => {"b" => 1}}
example                       # => {"a" => {"b" => 1}}
#deep_symbolize_keys

Symbolizes keys of nested hash without mutating itself. Does not handle nested arrays, though.

example = {"a" => {"b" => 2}}
example.deep_symbolize_keys  # => {a: {b: 1}}
example                      # => {"a" => {"b" => 2}}
#deep_symbolize_keys!

Symbolizes keys of nested hash while mutating itself. Does not handle nested arrays, though.

example = {"a" => {"b" => 2}}
example.deep_symbolize_keys!  # => {a: {b: 1}}
example                       # => {a: {b: 1}}
#flatten_keys

Flattens nested keys as top-level keys without mutating itself. Does not handle nested arrays, though.

{a: {b: 1}}.flatten_keys prefix: :test  # => {test_a_b: 1}
{a: {b: 1}}.flatten_keys delimiter: :|  # => {:"a|b" => 1}

{a: {b: 1}}.flatten_keys cast: :to_s            # => {"a_b" => 1}
{"a" => {"b" => 1}}.flatten_keys cast: :to_sym  # => {a_b: 1}

example = {a: {b: 1}}
example.flatten_keys  # => {a_b: 1}
example               # => {a: {b: 1}}
#flatten_keys!

Flattens nested keys as top-level keys while mutating itself. Does not handle nested arrays, though.

example = {a: {b: 1}}
example.flatten_keys!  # => {a_b: 1}
example                # => {a_b: 1}
#recurse

Recursively iterates over the hash and any hash value by applying the given block to it. Does not handle nested arrays, though.

example = {"a" => {"b" => 1}}
example.recurse(&:symbolize_keys)  # => {a: {b: 1}}
example.recurse(&:invert)          # => {{"b" => 1} => "a"}
#stringify_keys

Converts keys to strings without mutating itself.

example = {a: 1, b: 2}
example.stringify_keys  # => {"a" => 1, "b" => 2}
example                 # => {a: 1, b: 2}
#stringify_keys!

Converts keys to strings while mutating itself.

example = {a: 1, b: 2}
example.stringify_keys!  # => {"a" => 1, "b" => 2}
example                  # => {"a" => 1, "b" => 2}
#symbolize_keys

Converts keys to symbols without mutating itself.

example = {"a" => 1, "b" => 2}
example.symbolize_keys  # => {a: 1, b: 2}
example                 # => {"a" => 1, "b" => 2}
#symbolize_keys!

Converts keys to symbols while mutating itself.

example = {"a" => 1, "b" => 2}
example.symbolize_keys!  # => {a: 1, b: 2}
example                  # => {a: 1, b: 2}
#use

Passes each hash value as a block argument for further processing.

example = {unit: "221B", street: "Baker Street", city: "London", country: "UK"}
example.use { |unit, street| "#{unit} #{street}" }  # => "221B Baker Street"

IO

.void

Answers an IO stream which points to /dev/null in order to ignore any reads or writes to the stream. When given a block, the stream will automatically close upon block exit. When not given a block, you’ll need to close the stream manually.

io = IO.void                                    # => #<IO:fd 20>
io = IO.void { |void| void.write "nevermore" }  # => #<IO:(closed)>
#redirect

Redirects current stream to other stream when given a block. Without a block, the original stream is answered instead.

io = IO.new IO.sysopen(Pathname("test.txt").to_s, "w+")
other = IO.new IO.sysopen(Pathname("other.txt").to_s, "w+")

io.redirect other                                    # => #<IO:fd 20>
io.redirect(other) { |stream| stream.write "test" }  # => #<IO:fd 21>
#reread

Answers full stream by rewinding to beginning of stream and reading all content.

io = IO.new IO.sysopen(Pathname("test.txt").to_s, "w+")
io.write "This is a test."

io.reread    # => "This is a test."
io.reread 4  # => "This"

buffer = "".dup
io.reread(buffer: buffer)  # => "This is a test."
buffer                     # => "This is a test."
#squelch

Temporarily ignores any reads/writes for code executed within a block. Answers itself without any arguments or when given a block.

io = IO.new IO.sysopen(Pathname("test.txt").to_s, "w+")
io.squelch                      # => #<IO:fd 20>
io.squelch { io.write "Test" }  # => #<IO:fd 20>
io.reread                       # => ""

Pathname

Pathname

Enhances the Kernel conversion function which casts nil into a pathname in order to avoid: TypeError (no implicit conversion of nil into String). The pathname remains invalid but at least you have an instance of Pathname, which behaves like a Null Object, that can be used to construct a valid path.

Pathname(nil) # => Pathname("")
.home

Answers user home directory.

Pathname.home  # => Pathname "/Users/bkuhlmann"
.make_temp_dir

Wraps Dir.mktmpdir with the following behavior (see Dir.mktmpdir for details):

  • Without Block - Answers a newly created Pathname instance which is not automatically cleaned up.

  • With Block Yields a Pathname instance, answers result of given block, and automatidally cleans up temporary directory after block exits.

The following examples use truncated temporary directories for illustration purposes only. In reality, these paths will be longer depending on which operating system you are using.

Pathname.make_temp_dir                                       # => Pathname:/var/folders/T/temp-20200101-16940-r8
Pathname.make_temp_dir prefix: "prefix-"                     # => Pathname:/var/folders/T/prefix-20200101-16940-r8
Pathname.make_temp_dir suffix: "-suffix"                     # => Pathname:/var/folders/T/temp-20200101-16940-r8-suffix
Pathname.make_temp_dir prefix: "prefix-", suffix: "-suffix"  # => Pathname:/var/folders/T/prefix-20200101-16940-r8-suffix
Pathname.make_temp_dir root: "/example"                      # => Pathname:/example/temp-20200101-16940-r8
Pathname.make_temp_dir { "I am a block result" }             # => "I am a block result"
Pathname.make_temp_dir { |path| path.join "sub_dir" }        # => Pathname:/var/folders/T/temp-20200101-16940-r8/sub_dir
.require_tree

Requires all files in given root path and corresponding nested tree structure. All files are sorted before being required to ensure consistent behavior. Example:

# Before
Dir[File.join(__dir__, "support/shared_contexts/**/*.rb")].sort.each { |path| require path }

# After
Pathname.require_tree __dir__, "support/shared_contexts/**/*.rb"

The following are further examples of potential usage:

# Requires all files in root directory and below.
Pathname.require_tree __dir__

# Requires all files in `/test/**/*.rb` and below.
Pathname.require_tree "/test"

# Requires all files in RSpec shared examples directory structure.
Pathname.require_tree Bundler.root.join("spec"), "support/shared_examples/**/*.rb"
.root

Answers operating system root path.

Pathname.root  # => Pathname "/"
#change_dir

Wraps Dir.chdir behavior by changing to directory of current path. See Dir.chdir for details.

Pathname.pwd                           # => "/"
Pathname("/test").make_dir.change_dir  # => Pathname "/test"
Pathname.pwd                           # => "/test"

Pathname.pwd                                         # => "/"
Pathname("/test").make_dir.change_dir { "example" }  # => "example"
Pathname.pwd                                         # => "/"
#copy

Copies file from current location to new location while answering itself so it can be chained.

Pathname("input.txt").copy Pathname("output.txt")  # => Pathname("input.txt")
#directories

Answers all directories or filtered directories for current path.

Pathname("/example").directories                           # => [Pathname("a"), Pathname("b")]
Pathname("/example").directories "a*"                      # => [Pathname("a")]
Pathname("/example").directories flag: File::FNM_DOTMATCH  # => [Pathname(".."), Pathname(".")]
#extensions

Answers file extensions as an array.

Pathname("example.txt.erb").extensions  # => [".txt", ".erb"]
#files

Answers all files or filtered files for current path.

Pathname("/example").files                           # => [Pathname("a.txt"), Pathname("a.png")]
Pathname("/example").files "*.png"                   # => [Pathname("a.png")]
Pathname("/example").files flag: File::FNM_DOTMATCH  # => [Pathname(".ruby-version")]
#gsub

Same behavior as String#gsub but answers a path with patterns replaced with desired substitutes.

Pathname("/a/path/some/path").gsub("path", "test")
# => Pathname("/a/test/some/test")

Pathname("/%placeholder%/some/%placeholder%").gsub("%placeholder%", "test")
# => Pathname("/test/some/test")
#make_ancestors

Ensures all ancestor directories are created for a path.

Pathname("/one/two").make_ancestors  # => Pathname("/one/two")
Pathname("/one").exist?              # => true
Pathname("/one/two").exist?          # => false
#make_dir

Provides alternative #mkdir behavior by always answering itself (even when directory exists) and not throwing errors when directory does exist in order to ensure the pathname can be chained.

Pathname("/one").make_dir           # => Pathname("/one")
Pathname("/one").make_dir.make_dir  # => Pathname("/one")
#make_path

Provides alternative #mkpath behavior by always answering itself (even when full path exists) and not throwing errors when directory does exist in order to ensure the pathname can be chained.

Pathname("/one/two/three").make_path            # => Pathname("/one/two/three")
Pathname("/one/two/three").make_path.make_path  # => Pathname("/one/two/three")
#name

Answers file name without extension.

Pathname("example.txt").name # => Pathname("example")
#relative_parent

Answers relative path from parent directory. This is a complement to #relative_path_from.

Pathname("/one/two/three").relative_parent("/one") # => Pathname "two"
#remove_dir

Provides alternative #rmdir behavior by always answering itself (even when full path exists) and not throwing errors when directory does exist in order to ensure the pathname can be chained.

Pathname("/test").make_dir.remove_dir.exist?  # => false
Pathname("/test").remove_dir                  # => Pathname("/test")
Pathname("/test").remove_dir.remove_dir       # => Pathname("/test")
#remove_tree

Provides alternative #rmtree behavior by always answering itself (even when full path exists) and not throwing errors when directory does exist in order to ensure the pathname can be chained.

parent_path = Pathname "/one"
child_path = parent_path.join "two"

child_path.make_path
child_path.remove_tree  # => Pathname "/one/two"
child_path.exist?       # => false
paremt_path.exist?      # => true

child_path.make_path
parent_path.remove_tree  # => Pathname "/one"
child_path.exist?        # => false
parent_path.exist?       # => false
#rewrite

When given a block, it provides the contents of the recently read file for manipulation and immediate writing back to the same file.

Pathname("/test.txt").rewrite                                           # => Pathname("/test.txt")
Pathname("/test.txt").rewrite { |body| body.sub "[token]", "example" }  # => Pathname("/test.txt")
#touch

Updates access and modification times for path. Defaults to current time.

Pathname("example.txt").touch               # => Pathname("example.txt")
Pathname("example.txt").touch Time.now - 1  # => Pathname("example.txt")
#write

Writes to file and answers itself so it can be chained. See IO.write for details on additional options.

Pathname("example.txt").write "test"             # => Pathname("example.txt")
Pathname("example.txt").write "test", offset: 1  # => Pathname("example.txt")
Pathname("example.txt").write "test", mode: "a"  # => Pathname("example.txt")

String

#blank?

Answers true/false based on whether string is blank, <space>, \n, \t, and/or \r.

" \n\t\r".blank? # => true
#camelcase

Answers a camelcased string.

"this_is_an_example".camelcase # => "ThisIsAnExample"
#down

Answers string with only first letter downcased.

"EXAMPLE".down # => "eXAMPLE"
#first

Answers first character of a string or first set of characters if given a number.

"example".first    # => "e"
"example".first 4  # => "exam"
#indent

Answers string indented by two spaces by default.

"example".indent                  # => "  example"
"example".indent 0                # => "example"
"example".indent -1               # => "example"
"example".indent 2                # => "    example"
"example".indent 3, padding: " "  # => "   example"
#last

Answers last character of a string or last set of characters if given a number.

"instant".last    # => "t"
"instant".last 3  # => "ant"
#snakecase

Answers a snakecased string.

"ThisIsAnExample".snakecase # => "this_is_an_example"
#titleize

Answers titleized string.

"ThisIsAnExample".titleize # => "This Is An Example"
#to_bool

Answers string as a boolean.

"true".to_bool     # => true
"yes".to_bool      # => true
"1".to_bool        # => true
"".to_bool         # => false
"example".to_bool  # => false
#up

Answers string with only first letter upcased.

"example".up # => "Example"

String IO

#reread

Answers full string by rewinding to beginning of string and reading all content.

io = StringIO.new
io.write "This is a test."

io.reread    # => "This is a test."
io.reread 4  # => "This"

buffer = "".dup
io.reread(buffer: buffer)  # => "This is a test."
buffer                     # => "This is a test."

Struct

.keyworded?

Answers whether a struct was constructed with keyword or positional arguments.

Struct.new(:a, keyword_init: true).keyworded?  # => true
Struct.new(:a).keyworded?                      # => false
.with_keywords

Answers a struct instance with given keyword arguments regardless of whether the struct was constructed with positional or keyword arguments.

Example = Struct.new :a, :b, :c
Example.with_keywords a: 1, b: 2, c: 3  # => #<struct a=1, b=2, c=3>
Example.with_keywords a: 1              # => #<struct a=1, b=nil, c=nil>
Example.with_keywords c: 1              # => #<struct a=nil, b=nil, c=1>

Example = Struct.new :a, :b, :c, keyword_init: true
Example.with_keywords a: 1, b: 2, c: 3  # => #<struct a=1, b=2, c=3>
Example.with_keywords a: 1              # => #<struct a=1, b=nil, c=nil>
Example.with_keywords c: 1              # => #<struct a=nil, b=nil, c=1>
.with_positions

Answers a struct instance with given positional arguments regardless of whether the struct was constructed with positional or keyword arguments.

Example = Struct.new :a, :b, :c
Example.with_positions 1, 2, 3  # => #<struct a=1, b=2, c=3>
Example.with_positions 1        # => #<struct a=1, b=nil, c=nil>

Example = Struct.new :a, :b, :c, keyword_init: true
Example.with_positions 1, 2, 3  # => #<struct a=1, b=2, c=3>
Example.with_positions 1        # => #<struct a=1, b=nil, c=nil>
#merge

Merges multiple attributes without mutating itself.

Example = Struct.new :a, :b, :c
example = Example[1, 2, 3]
example.merge a: 10                # => #<struct a=10, b=2, c=3>
example.merge a: 10, c: 30         # => #<struct a=10, b=2, c=30>
example.merge a: 10, b: 20, c: 30  # => #<struct a=10, b=20, c=30>
example                            # => #<struct a=1, b=2, c=3>

Example = Struct.new :a, :b, :c, keyword_init: true
example = Example[a: 1, b: 2, c: 3]
example.merge a: 10                # => #<struct a=10, b=2, c=3>
example.merge a: 10, c: 30         # => #<struct a=10, b=2, c=30>
example.merge a: 10, b: 20, c: 30  # => #<struct a=10, b=20, c=30>
example                            # => #<struct a=1, b=2, c=3>
#merge!

Merges multiple attributes while mutating itself.

Example = Struct.new :a, :b, :c
example = Example[1, 2, 3]
example.merge! a: 10                # => #<struct a=10, b=2, c=3>
example.merge! a: 10, c: 30         # => #<struct a=10, b=2, c=30>
example.merge! a: 10, b: 20, c: 30  # => #<struct a=10, b=20, c=30>
example                             # => #<struct a=10, b=20, c=30>

Example = Struct.new :a, :b, :c, keyword_init: true
example = Example[a: 1, b: 2, c: 3]
example.merge! a: 10                # => #<struct a=10, b=2, c=3>
example.merge! a: 10, c: 30         # => #<struct a=10, b=2, c=30>
example.merge! a: 10, b: 20, c: 30  # => #<struct a=10, b=20, c=30>
example                             # => #<struct a=10, b=20, c=30>
#revalue

Transforms values without mutating itself. An optional hash can be supplied to pinpoint and transform specific attributes. In the event that a block isn’t supplied, the struct will answer itself since there is nothing to operate on. Behavior is the same regardless of whether the struct is constructed using positional or keyword arguments. A positional struct is used in the examples below but a keyword struct would work too.

Example = Struct.new :a, :b, :c

example = Example[1, 2, 3]
example.revalue { |value| value * 2 }                             # => #<struct a=2, b=4, c=6>
example.revalue(c: 2) { |previous, current| previous + current }  # => #<struct a=1, b=2, c=5>
example.revalue c: 2                                              # => #<struct a=1, b=2, c=3>
example.revalue                                                   # => #<struct a=1, b=2, c=3>
example                                                           # => #<struct a=1, b=2, c=3>
#revalue!

Transforms values while mutating itself. An optional hash can be supplied to pinpoint and transform specific attributes. In the event that a block isn’t supplied, the struct will answer itself since there is nothing to operate on. Behavior is the same regardless of whether the struct is constructed using positional or keyword arguments. A positional struct is used in the examples below but a keyword struct would work too.

Example = Struct.new :a, :b, :c

example = Example[1, 2, 3]
example.revalue! { |value| value * 2 }                             # => #<struct a=2, b=4, c=6>
example                                                            # => #<struct a=2, b=4, c=6>

example = Example[1, 2, 3]
example.revalue!(c: 2) { |previous, current| previous + current }  # => #<struct a=1, b=2, c=5>
example                                                            # => #<struct a=1, b=2, c=5>

example = Example[1, 2, 3]
example.revalue! c: 2                                              # => #<struct a=1, b=2, c=3>
example.revalue!                                                   # => #<struct a=1, b=2, c=3>
example                                                            # => #<struct a=1, b=2, c=3>

Development

To contribute, run:

git clone https://github.com/bkuhlmann/refinements.git
cd refinements
bin/setup

You can also use the IRB console for direct access to all objects:

bin/console

Tests

To test, run:

bundle exec rake

Versioning

Read Semantic Versioning for details. Briefly, it means:

  • Major (X.y.z) - Incremented for any backwards incompatible public API changes.

  • Minor (x.Y.z) - Incremented for new, backwards compatible, public API enhancements/fixes.

  • Patch (x.y.Z) - Incremented for small, backwards compatible, bug fixes.

Code of Conduct

Please note that this project is released with a CODE OF CONDUCT. By participating in this project you agree to abide by its terms.

Contributions

Read CONTRIBUTING for details.

License

Read LICENSE for details.

History

Read CHANGES for details.

Credits

Engineered by Brooke Kuhlmann.