0.0
# mdtoc - Markdown Table of Contents
Read Markdown files and output a table of contents.
## Installation
Requirements:
* [Ruby](https://www.ruby-lang.org/en/) (see [.ruby-version](./.ruby-version))
```bash
gem install mdtoc
```
## Usage
```bash
$ mdtoc --help
Usage: mdtoc [options] files or directories...
-h, --help Show this message
-o, --output PATH Update a table of contents in the file at PATH
-a, --[no-]append Append to the --output file if a <!-- mdtoc --> tag isn't found
-c, --[no-]create Create the --output file if it does not exist
```
1. Add a `<!-- mdtoc -->` tag to a Markdown file.
```bash
echo '<!-- mdtoc -->' >> README.md
```
2. Run `mdtoc` and specify input files or directories (eg. the "test/samples" directory) and an output file (eg. "README.md").
```bash
mdtoc -aco README.md test/samples
```
## Example Rakefile
Create a `Rakefile` with the contents below, then run
[`rake`](https://github.com/ruby/rake) to:
* `git pull`
* `git add` any *.md files
* Run `mdtoc` to update the generated table of contents in the ./README.md file
* Git commit and push any changes
```ruby
task default: %w[mdtoc]
desc 'Update Markdown table of contents and push changes to the git repository'
task :mdtoc do
command = <<~CMD
set -e
if [ -n "$(git diff --name-only --diff-filter=U)" ]; then
echo 'Error: conflicts exist' >&2
exit 1
fi
mdtoc --append --create --output README.md docs/
git add *.md **/*.md
git commit -qm 'Update TOC' || true
git pull
git push
CMD
sh command, verbose: false do |ok, status|
unless ok
fail "Failed with status: #{status.exitstatus}"
end
end
end
```
See [andornaut/til](https://github.com/andornaut/til/blob/master/Rakefile) for an example.
## Development
### Setup
Requirements:
* [Bundler](https://bundler.io/)
```bash
# Install dependencies
bundle
```
### Tasks
```bash
# List rake tasks
$ rake -T
rake build # Build mdtoc-0.1.5.gem into the pkg directory
rake default # Run the build, rubocop:autocorrect_all, sorbet and test tasks
rake install # Build and install mdtoc-0.1.5.gem into system gems
rake install:local # Build and install mdtoc-0.1.5.gem into system gems without network access
rake release[remote] # Create tag v0.1.5 and build and push mdtoc-0.1.5.gem to rubygems.org
rake rubocop # Run RuboCop
rake rubocop:autocorrect # Autocorrect RuboCop offenses (only when it's safe)
rake rubocop:autocorrect_all # Autocorrect RuboCop offenses (safe and unsafe)
rake sorbet # Run the Sorbet type checker
rake test # Run tests
# Run mdtoc with test inputs
$ ruby -Ilib bin/mdtoc test/samples
# Run mdtoc with test inputs, and write to a newly created output file
$ f=$(mktemp) && ruby -Ilib bin/mdtoc -aco ${f} test/samples ; cat ${f}
```
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
Activity
0.03
A puppet-lint plugin to check for classes and defined types that contain names beginning with a digit.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
Activity
0.0
a Rails gem that allows you to validate a URL
entered in a form. It validates if the URL exists by hitting it with a HEAD
request.
The improved version includes retries for common patterns when the head request is refused before giving a failure notice.
It also looks up a SITE_URL constant to the user agent in the headers.
Also has the option to also check that the URL returns content of
a specified type.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
0.0
strong_csv is a type checker for a CSV file. It lets developers declare types for each column to ensure all cells are satisfied with desired types.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
Activity
0.0
Experimental type checker
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
0.0
# License
Create software licenses easily.
## Install
### Bundler: `gem 'license'`
### RubyGems: `gem install license`
## Usage
### Simple
```ruby
license = License::Software::MIT.new do |l|
l.year.start = 2012
l.author.name = 'Ryan Scott Lewis'
l.author.email = 'ryan@rynet.us'
end
p license.to_s # => "Copyright (c) 2012 Ryan Scott Lewis <ryan@rynet.us>\n\nPermission is hereby granted, free of charge..."
```
### Multiple Authors
```ruby
license = License::Software::MIT.new do |l|
l.year.start = 2012
l.authors.add name: 'Ryan Scott Lewis', email: 'ryan@rynet.us'
l.authors.add name: 'John Doe', email: 'john.doe@example.com'
l.authors.add name: 'Snake Pliskin'
l.authors.add 'John McClane <john@mcclain.org, jmcclane@gmail.com>'
end
p license.to_s # => "Copyright (c) 2012 Ryan Scott Lewis <ryan@rynet.us>, John Doe <john.doe@example.com>\n\nPermission is hereby granted, free of charge..."
p license.authors.first.name # => 'Ryan Scott Lewis'
p license.authors.first.email # => 'ryan@rynet.us'
p license.authors.last.name # => 'John McClane'
p license.authors.last.email # => 'john@mcclain.org'
p license.authors.last.emails # => ['john@mcclain.org', 'jmcclane@gmail.com]
```
#### Smart Setters
```ruby
license = License::Software.new do |l|
l.type = License::Software::MIT # Set which type of license here instead
l.year = '2006-2011' # Will set year.start to 2006 and year.end to 2011
l.authors = 'Ryan Scott Lewis<ryan@rynet>, John Doe < john.doe@example.com >'
end
p license.to_s # => "Copyright (c) 2012 Ryan Scott Lewis <ryan@rynet.us>, John Doe <john.doe@example.com>\n\nPermission is hereby granted, free of charge..."
```
#### Advanced usage (preferred method)
```ruby
license = License::Software.new do # Do not pass block variables to enter the scope of the License::Software
type MIT
year 2012
author 'Ryan Scott Lewis <ryan@rynet.us>'
end
p license.to_s # => "Copyright (c) 2012 Ryan Scott Lewis <ryan@rynet.us>\n\nPermission is hereby granted, free of charge..."
```
## Contributing
* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
* Fork the project
* Start a feature/bugfix branch
* Commit and push until you are happy with your contribution
* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
## Copyright
Copyright © 2012 Ryan Scott Lewis <ryan@rynet.us>.
The MIT License (MIT) - See LICENSE for further details.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
Activity
0.0
Dynamic type checker
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
0.0
Allows for easy YAML parsing and type checking, as well as generators
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
0.0
rubber-c-binder allows a rubyish means of generating bindings for C libraries,
including (but not limited to) GObject based libraries.
It allows C code to be written in the context of a ruby style class/method layout
and eases type checking and conversion between Ruby & C datatypes.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
0.0
yae provides a simple enum class (enumerated type) implementation (Yae::Enum) that can be used to abstract a set of values. It also provides methods to check values existence in the enum and to iterate over its contents.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
0.0
Allows you check if an object match a class expression. It is typically
used to check the type of method paraameters. It is an alternative to using
Ruby-3 .rbs files but with a different syntax and only dynamic checks
Typically you'll include the Constrain module and use #constrain to check
the type of method parameters:
include Constrain
# f takes a String and an array of Integer objects. Raise a Constrain::Error
# if parameters doesn't have the expected types
def f(a, b)
constrain a, String
constrain b, [Integer]
end
Constrain works with ruby-2 (and maybe ruby-3)
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
0.0
Rubyt is a ruby gem that provides type checking functionality. It includes support for various types such as Boolean, Integer, String, Array, Hash and more. This gem is designed to enforce type safety, facilitating the creation of readable and maintainable code. It includes custom error handling for type mismatches. With its ease of use and integration, it can seamlessly fit into existing projects.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
Activity
0.0
TypedOperation is a command pattern implementation where inputs can be defined with runtime type checks. Operations can be partially applied.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
Activity
0.0
Have 3-state radiobuttons instead of a 2-state checkbox for your Boolean columns which can store NULL. This gem:
1. Provides a custom Formtastic input type `:tristate_radio` which renders 3 radios (“Yes”, “No”, “Unset”) instead of a checkbox (only where you put it).
2. Teaches Rails recognize `"null"` and `"nil"` param values as `nil`
3. Encourages you to add translations for ActiveAdmin “status tag” so that `nil` be correctly translated as “Unset” instead of “False”.
Does not change controls, you need to turn it on via `as: :tristate_radio` option.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
Activity
0.0
This is an improved input function for Ruby.
Using this gem, you can easily get user input with real-time type validation, ensuring that the data provided is as expected, among other things.
If you have any questions, check the documentation: https://github.com/barrosflavio/ruby_better_input
Features:
- Ask, receive and check input in a single line
- Support for types such as integer, float and boolean.
- Input validation with clear error messages.
- Intuitive and easy-to-use function.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
0.0
== What's this?
{ComicFury}[https://comicfury.com] is an excellent no-bullshit webcomic hosting
site created and maintained by the legend Kyo. You should support them on
{Patreon}[https://www.patreon.com/comicfury]!
{Jekyll}[https://jekyllrb.com] is a highly regarded and widespread static site
generator. It builds simple slowly-changing content into HTML files using
templates.
RageRender allows you to use your ComicFury templates to generate a static
version of your webcomic site using Jekyll. You just supply your templates,
comics and blogs, and RageRender will output a site that mimics your ComicFury
site.
Well, I say "mimics". Output is a static site, which means all of the
interactive elements of ComicFury don't work. This includes comments,
subscriptions, search, and comic management.
=== But why?!
RageRender allows those of us who work on making changes to ComicFury site
templates to test our changes before we put them live.
With RageRender, you can edit your CSS, HTML templates and site settings before
you upload them to ComicFury. This makes the process of testing changes quicker
and makes it much more likely that you catch mistakes before any comic readers
have a chance to see them.
RageRender doesn't compete with the most excellent ComicFury (who's Patreon you
should contribute to, as I do!) – you should continue to use ComicFury for all
your day-to-day artistic rage management needs. But if you find yourself making
changes to a site design, RageRender may be able to help you.
== Getting started
First, you need to have {Ruby}[https://www.ruby-lang.org/] and
{Bundler}[https://bundle.io/] installed. The Jekyll site has {good guides on how
to do that}[https://jekyllrb.com/docs/installation/] depending on your operating
system.
To set up a new site, open a terminal and type:
mkdir mycomic && cd mycomic
bundle init
bundle add jekyll
bundle add ragerender
Now you can add comics! Add the image into an <tt>images</tt> folder:
mkdir images
cp 'cool comic.jpg' 'images/My first page.jpg'
The file name of the image will be the title of your comic page. And that's it,
you added your first comic!
If you want to add an author note, create a text file in a folder called
<tt>_comics</tt> that has the same file name, but with a <tt>.md</tt> extension:
mkdir _comics
echo "Check out my cool comic y'all!" > '_comics/My first page.md'
Generate the site using:
bundle exec jekyll build
Or start a local website to see it in your browser:
bundle exec jekyll serve
# Now visit http://localhost:4000!
=== Customising your site
You'll notice a few things that might be off about your site, including that the
webcomic title and author name are probably not what you were expecting.
You can create a configuration file to tell RageRender the important details.
Put something like this in your webcomic folder and call it
<tt>_config.yml</tt>:
title: "My awesome webcomic!"
slogan: "It's the best!"
description: >
My epic story about how him and her
fell into a romantic polycule with they and them
defaults:
- scope:
path: ''
values:
author: "John smith"
theme: ragerender
Your webcomic now has its basic information set up.
=== Adding your layouts
If you want to use your own layout code, then create a <tt>_layouts</tt>
directory and put the contents of each of your ComicFury layout tabs in there,
and then put your CSS in the main folder. You should end up with a full set of
files like:
_layouts
archive.html
blog-archive.html
blog-display.html
comic-page.html
error-page.html
overall.html
overview.html
search.html
layout.css
Now when you build your site, your custom templates and styles will be used
instead.
=== Adding blogs
Add your blogs into a folder called `_posts`:
cat _posts/2025-05-29-my-new-comic.md
Hey guys, welcome to my new comic! It's gonna be so sick!
Note that the name of your blog post has to include the date and the title, or
it'll be ignored.
=== Customising comics and blogs
You can add {Front Matter}[https://jekyllrb.com/docs/front-matter/] to set the
details of your author notes and blogs manually:
---
title: "spooky comic page"
date: "2025-03-05 16:20"
image: "images/ghost.png"
author: "Jane doe"
custom:
# use yes and no for tickbox settings
spooky: yes
# use text in quotes for short texts
mantra: "live long and prosper"
# use indented text for long texts
haiku: >
Testing webcomics
Now easier than ever
Thanks to RageRender
comments:
- author: "Skippy"
date: "13 Mar 2025, 3.45 PM"
comment: "Wow this is so sick!"
---
Your author note still goes at the end, like this!
=== Adding extra pages
You can add extra pages just by adding new HTML files to your webcomic folder.
The name of the file becomes the URL that it will use.
Pages by default won't be embedded into your 'Overall' layout. You can change
that and more with optional Front Matter:
---
# Include this line to set the page title
title: "Bonus content"
# Include this line to hide the page from the navigation menu
hidden: yes
# Include this line to embed this page in the overall layout
layout: Overall
---
<h1>yo check out my bonus content!</h1>
=== Stuff that doesn't work
Here is a probably incomplete list of things you can expect to be different
about your local site compared to ComicFury:
- Any comments you specify in Front Matter will be present, but you can't add
new ones
- Search doesn't do anything at all
- Saving and loading your place in the comic isn't implemented
- GET and POST variables in templates are ignored and will always be blank
- Random numbers in templates will be random only once per site build, not once
per page call
== Without Jekyll
RageRender can also be used without Jekyll to turn ComicFury templates into
templates in other languages.
E.g:
gem install ragerender
echo "[c:iscomicpage]<div>[f:js|v:comictitle]</div>[/]" > template.html
ruby $(gem which ragerender/to_liquid) template.html
# {% if iscomicpage %}<div>{{ comictitle | escape }}</div>{% endif %}
ruby $(gem which ragerender/to_erb) template.html
# <% if iscomicpage %><div><%= js(comictitle) %></div><% end %>
You still need to pass the correct variables to these templates; browse {this
unofficial documentation}[https://github.com/heyeinin/comicfury-documentation]
or RageRender::ComicDrop etc. to see which variables work on which templates.
== Get help
That's not a proclamation but an invitation! Reach out if you're having trouble
by {raising an issue}[https://github.com/simonwo/ragerender/issues] or posting
in the ComicFury forums.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
0.0
# COM #
COM is an object-oriented wrapper around WIN32OLE. COM makes it easy to add
behavior to WIN32OLE objects, making them easier to work with from Ruby.
## Usage ##
Using COM is rather straightforward. There’s basically four concepts to keep
track of:
1. COM objects
2. Instantiable COM objects
3. COM events
4. COM errors
Let’s look at each concept separately, using the following example as a base.
module Word end
class Word::Application < COM::Instantiable
def without_interaction
with_properties('displayalerts' => Word::WdAlertsNone){ yield }
end
def documents
Word::Documents.new(com.documents)
end
def quit(saving = Word::WdDoNotSaveChanges, *args)
com.quit saving, *args
end
end
### COM Objects ###
A COM::Object is a wrapper around a COM object. It provides error
specialization, which is discussed later and a few utility methods. You
typically use it to wrap COM objects that are returned by COM methods. If we
take the example given in the introduction, Word::Documents is a good
candidate:
class Word::Documents < COM::Object
DefaultOpenOptions = {
'confirmconversions' => false,
'readonly' => true,
'addtorecentfiles' => false,
'visible' => false
}.freeze
def open(path, options = {})
options = DefaultOpenOptions.merge(options)
options['filename'] = Pathname(path).to_com
Word::Document.new(com.open(options))
end
end
Here we override the #open method to be a bit easier to use, providing sane
defaults for COM interaction. Worth noting is the use of the #com method to
access the actual COM object to invoke the #open method on it. Also note that
Word::Document is also a COM::Object.
COM::Object provides a convenience method called #with_properties, which is
used in the #without_interaction method above. It lets you set properties on
the COM::Object during the duration of a block, restoring them after it exits
(successfully or with an error).
### Instantiable COM Objects ###
Instantiable COM objects are COM objects that we can connect to and that can be
created. The Word::Application object can, for example, be created.
Instantiable COM objects should inherit from COM::Instantiable. Instantiable
COM objects can be told what program ID to use, whether or not to allow
connecting to an already running object, and to load its associated constants
upon creation.
The program ID is used to determine what instantiable COM object to connect to.
By default the name of the COM::Instantiable class’ name is used, taking the
last two double-colon-separated components and joining them with a dot. For
Word::Application, the program ID is “Word.Application”. The program ID can be
set by using the .program_id method:
class IDontCare::ForConventions < COM::Instantiable
program_id 'Word.Application'
end
The program ID can be accessed with the same method:
Word::Application.program_id # ⇒ 'Word.Application'
Connecting to an already running COM object is not done by default, but is
sometimes desirable: the COM object might take a long time to create, or some
common state needs to be accessed. If the default for a certain instantiable
COM object should be to connect, this can be done using the .connect method:
class Word::Application < COM::Instantiable
connect
end
If no running COM object is available, then a new COM object will be created in
its stead. Whether or not a class uses the connection method can be queried
with the .connect? method:
Word::Application.connect? # ⇒ true
Whether or not to load constants associated with an instantiable COM object is
set with the .constants method:
class Word::Application < COM::Instantiable
constants true
end
and can similarly be checked:
Word::Application.constants? # ⇒ true
Constants are loaded by default.
When an instance of the instantiable COM object is created, a check is run to
see if constants should be loaded and whether or not they already have been
loaded. If they should be loaded and they haven’t already been loaded,
they’re, you guessed it, loaded. The constants are added to the module
containing the COM::Instantiable. Thus, for Word::Application, the Word module
will contain all the constants. Whether or not the constants have already been
loaded can be checked with .constants_loaded?:
Word::Application.constants_loaded # ⇒ false
That concludes the class-level methods.
Let’s begin with the #connected? method among the instance-level methods. This
method queries whether or not this instance connected to an already running COM
object:
Word::Application.new.connected? # ⇒ false
This can be very important in determining how shutdown of a COM object should
be done. If you connected to an already COM object it might be foolish to shut
it down if someone else is using it.
The #initialize method takes a couple of options:
* connect: whether or not to connect to a running instance
* constants: whether or not to load constants
These options will, when given, override the class-level defaults.
### Events ###
COM events are easily dealt with:
class Word::Application < COM::Instantiable
def initialize(options = {})
super
@events = COM::Events.new(com, 'ApplicationEvents',
'OnQuit')
end
def quit(saving = Word::WdDoNotSaveChanges, *args)
@events.observe('OnQuit', proc{ com.quit saving, *args }) do
yield if block_given?
end
end
end
To tell you the truth this API sucks and will most likely be rewritten. The
reason that it is the way it is is that WIN32OLE, which COM wraps, sucks. It’s
event API is horrid and the implementation is buggy. It will keep every
registered event block in memory for ever, freeing neither the blocks nor the
COM objects that yield the events.
### Errors ###
All errors generated by COM methods descend from COM::Error, except for those
cases where a Ruby error already exists. The following HRESULT error codes are
turned into Ruby errors:
HRESULT Error Code | Error Class
-------------------|------------
0x80004001 | NotImplementedError
0x80020005 | TypeError
0x80020006 | NoMethodError
0x8002000e | ArgumentError
0x800401e4 | ArgumentError
There are also a couple of other HRESULT error codes that are turned into more
specific errors than COM::Error:
HRESULT Error Code | Error Class
-------------------|------------
0x80020003 | MemberNotFoundError
0x800401e3 | OperationUnavailableError
Finally, when a method results in any other error, a COM::MethodInvocationError
will be raised, which can be queried for the specifics, specifically #message,
#method, #server, #code, #hresult_code, and #hresult_message.
### Pathname ###
The Pathname object receives an additional method, #to_com. This method is
useful for when you want to pass a Pathname object to a COM method. Simply
call #to_com to turn it into a String of the right encoding for COM:
Word::Application.new.documents.open(Pathname('a.docx').to_com)
# ⇒ Word::Document
## Installation ##
Install COM with
% gem install com
## License ##
You may use, copy and redistribute this library under the same [terms][1] as
Ruby itself.
[1]: http://www.ruby-lang.org/en/LICENSE.txt
## Contributors ##
* Nikolai Weibull
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
0.0
# FaradayError
[](https://badge.fury.io/rb/faraday_error)
A [Faraday](https://github.com/lostisland/faraday) middleware for adding request parameters to your exception tracker.
### Supports
- [Honeybadger](https://www.honeybadger.io/)
- [NewRelic](http://newrelic.com/)
- Your favorite thing, as soon as you make a pull request!
## Installation
Add this line to your application's Gemfile:
```ruby
gem 'faraday_error'
```
And then execute:
$ bundle
Or install it yourself as:
$ gem install faraday_error
## Usage
Configure your Faraday connection to use this middleware. You can optionally specify a name; defaults to `faraday`. It is expected that you also use `Faraday::Response::RaiseError` somewhere in your stack.
```ruby
connection = Faraday.new(url: 'http://localhost:4567') do |faraday|
faraday.use FaradayError::Middleware, name: "example_request"
faraday.use Faraday::Response::RaiseError
faraday.adapter Faraday.default_adapter
end
```
And that's it. Make a request as you normally would.
```ruby
connection.post do |req|
req.url '/503'
req.headers['Content-Type'] = 'application/json'
req.body = JSON.generate(abc: "xyz")
end
```
If any request fails, Honeybadger's "context" for this error will include your request parameters. If sending JSON or `application/x-www-form-urlencoded`, these will be included in parsed form.
```json
{
"example_request": {
"method": "post",
"url": "http://localhost:4567/503",
"request_headers": {
"User-Agent": "Faraday v0.9.2",
"Content-Type": "application/json"
},
"body_length": 13,
"body": {
"abc": "xyz"
}
}
}
```
## Development
After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` 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).
The included [RestReflector](../master/spec/rest_reflector.rb) Sinatra app is suitable for making requests that are guaranteed to fail in particlar ways.
## Contributing
Bug reports and pull requests are welcome on GitHub at https://github.com/jelder/faraday_error. 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](http://opensource.org/licenses/MIT).
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
Activity
0.0
Iz provides an API for type checking objects.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
0.0
Super basic type checking functions in ruby.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025