try-catch wrapper around require()
Stubborn versions of Node's fs functions that try really hard to do their job.
Library that can be used to retry functions that return promise
AWS credential provider that sources credentials from a Node.JS environment.
Abstraction for exponential and custom retry strategies for failed operations.
Retrying made simple, easy and async
Define a data property on an object. Will fall back to assignment in an engine without descriptors.
a ThroughStream that strictly buffers all readable events when paused.
A decorator on top of `fetch` that caches the DNS query of the `hostname` of the passed URL
Write files in an atomic fashion w/configurable ownership
Abstraction for exponential and custom retry strategies for failed operations.
Node.js compression middleware
Word Processing Document library
TypeScript definitions for promise-retry
Node addon for string extraction for msgpackr
adaptive-timeout
A decorator on top of `fetch` that caches the DNS query of the `hostname` of the passed URL
Invokes function, returning an object of the results.
Best-effort discovery of the machine's default gateway and local network IP exclusively with UDP sockets.
Opinionated `fetch` optimized for use inside microservices
String manipulation extensions for Underscore.js javascript library.
Node.js native addon binary install tool
High-level messaging & socket patterns implemented in pure js
Decorate yargs content with chalk styles and figlet fonts
Gem that attempts to find the tests that are required to run for the changes you have made.
Attempts to reproduce a bug with gem requirement parsing
Attempts to scrape the inputs required to complete a 1 page online form.
Generates rails controller actions at runtime. Does not generate source code for you to inspect, modify and commit to version control, so requires your blind faith, hence evil. Also does not attempt to generate view code. On the other hand, massively reduces your line count.
Deprecated. I'm planning to discontinue this gem. Although it has enormous flexibility and power, it is in my view too complex. 80% of requirements can be met through custom shell scripts which are much simpler to write and maintain. Sifts through your log files in real time, using stateful intelligence to determine what is really important. REC can alert you (by email or IM) or it can simply condense a large log file into a much shorter and more meaningful log. REC is inspired by Risto Vaarandi's brilliant *sec* (simple-evcorr.sourceforge.net) but is original code and any defects are entirely mine. While event correlation is inherently complex, REC attempts to make common tasks easy while preserving plenty of power and flexibility for ambitious tasks.
== DESCRIPTION: My fork of aasmith's ofx-parser v1.0.2 and attempt at building the investment acct methods. OfxParser is a ruby library to parse a realistic subset of the lengthy OFX 1.x specification. == FEATURES/PROBLEMS: * Reads OFX responses - i.e. those downloaded from financial institutions and puts it into a usable object graph. * Supports the 3 main message sets: banking, credit card and investment accounts, as well as the required 'sign on' set. * Knows about SIC codes - if your institution provides them. See http://www.eeoc.gov/stats/jobpat/siccodes.html * Monetary amounts can be retrieved either as a raw string, or in pennies. * Supports OFX timestamps.
== FEATURES: * Real-Time OpenGL view * Multiple logfiles on multiple servers * Configurable layout * Multiple logfile parsers (Apache Combined, Rails, IIS, Postfix/spamd/clamd, Nginx, Squid, PostgreSQL, PureFTPD, MySQL, TShark, qmail/vmpop3d) * Custom events * Show rate, total or average * If you can 'tail' it, you can visualize it * Written in Ruby using net-ssh & libopengl-ruby * Free! == RUNNING: gl_tail --help gl_tail --new gl_tail.yaml gl_tail You can press 'f' while running to toggle the attempted frames per second. Or 'b' to change default blob type, and space to toggle bouncing. == REQUIREMENTS: * rubygems 0.9.4 * ruby-opengl 0.40.1 * net-ssh 1.1.2 * opengl/ruby development packages (ruby1.8-dev libgl1-mesa-dev libglu1-mesa-dev libglut3-dev)
Send SMS messages using the OpenMarket API
WARNING: Please be aware that this gem has not undergone any form of independent security evaluation and is provided for academic/educational purposes only. RHUBARBCIPHER should not be used to encrypt any data with high confidentiality, availability or integrity requirements, and should be treated purely as a proof of concept and/or learning exercise. RHUBARBCIPHER is an experimental multi-key file encryption/decryption system for GNU/Linux and BSD that combines one-time pad encryption/decryption with Shamir's Secret Sharing in an attempt to encrypt files in a versatile yet information-theoretically secure manner. RHUBARBCIPHER only works well on smaller files (e.g. less than 15000KiB) due to the time taken to encrypt/decrypt data, which increases as a function of file size. It includes an optional decoy feature which allows users to specify a decoy file and generate a set of decoy keys in addition to the real keys. Size similarity between the decoy file and the real file is strictly enforced.
The 'pg_search_multiple_highlight' gem extends the functionality of the popular 'pg_search' gem to overcome its limitation when performing searches against multiple columns and attempting to highlight results. The core issue arises when using the ':highlight' option within the ':tsearch' scope on multiple columns. This gem addresses this limitation by introducing the ':multiple_highlight' option, offering a comprehensive solution for highlighting results across multiple columns. Key Features: New Scope Option: The gem introduces the ':multiple_highlight' scope option, allowing users to perform searches on multiple columns and highlight matching terms. Enhanced Search Results: The gem enables the extraction of highlighted results from multiple columns, providing a unified view of highlighted content. Usage Convenience: Users can easily integrate the ':multiple_highlight' option into their existing 'pg_search' queries by calling the '.with_pg_search_multiple_highlight' method on the search object. Flexible Customization: The gem's options can be tailored to match specific highlighting requirements, such as custom start and stop markers for highlighting. Comprehensive Documentation: The README file explains the limitations of 'pg_search' regarding highlighting, demonstrates how the ':multiple_highlight' option resolves this issue, and offers clear usage examples for quick integration.
Chef-Berksfile-Env ================== A Chef plugin which allows you to lock down your Chef Environment's cookbook versions with a Berksfile. This is effectively the same as doing `berks apply ...` but via `knife environment from file ...`. View the [Change Log](https://github.com/bbaugher/chef-berksfile-env/blob/master/CHANGELOG.md) to see what has changed. Installation ------------ /opt/chef/embedded/bin/gem install chef-berksfile-env Usage ----- In your chef repo create a Berksfile next to your Chef environment file like this, chef-repo/environments/[ENV_NAME]/Berksfile This is the default location that will used by the plugin. We have to put the Berksfile in its own directory since [multiple Berksfiles can't exist in the same directory](https://github.com/berkshelf/berkshelf/issues/1247). The berksfile should include any cookbooks that your nodes or roles explicitly mention for that environment, source "https://supermarket.getchef.com" cookbook "java" cookbook "yum", "~> 2.0" ... Next we need to generate our Berksfile's lock file, berks install Your environment file must by in `.rb` format and look like this, require 'chef-berksfile-env' # The name must be defined first so we can use it to find the Berksfile name "my_env" # Load Berksfile locked dependencies as my environment's cookbook version contraints load_berksfile ... Now our environment will use the locked versions of the cookbooks and transitive dependencies generated by our Berksfile. Upgrading to the latest dependecies is now as simple as, berks install Our Berksfile also provides an easy way to ensure all the cookbooks and their versions that our environment requires are uploaded to our chef-server, berks upload How the Plugin Finds the Berksfile ---------------------------------- If you are curious how the plugin knows to find the Berksfile in `chef-repo/environments/[ENV]/Berksfile`, you want to put your Berksfile somewhere else or you have run into this error `Expected Berksfile at [/path/../Berksfile] but does not exist`, this section will explain how this works and ways to tweak the path or fix your error. `load_berksfile` has an optional argument which represents the path to your Berksfile. This path can be pseduo relative (explained in a moment) or absolute. By default the value is `environments/[ENV_NAME]/Berksfile`. By pseduo relative I mean that its a relative path but the plugin will check to see if the directory we are executing from partially matches our relative path. So if we are running knife from `/home/chef-repo/environments` and our relative path is `chef-repo/environments/dev/Berksfile` the plugin will see that the relative path is partially included in our execution directory and will attempt to merge the two to come up with `/home/chef-repo/environments/dev/Berksfile`. If we can't make any match at all we attempt to guess the path by just joining the relative path with our execution directory. So why do we do this? Well the only way to use this plugin is if your environment is in Ruby format. Chef's `knife from file ...` uses Ruby's `instance_eval` in order to do this. This means the code on Chef's end effectively looks like this, env.instance_eval(IO.read(env_ruby_file)) which means that any context about the location of the environment file is lost. So we have no great way to discern the location of our environment Ruby file, so instead we guess.
# Cryptophysh My attempt to produce a solution to the requirements listed [here](https://github.com/krystal/code-tasks/blob/main/password-generator.md). Essentially, a library/gem you can include in to your own code to add a `::generate_password` class method on a class. I've pushed the built gem up to RubyGems for completeness' sake. ## Installation Install the gem and add to the application's Gemfile by executing: $ bundle add cryptophysh If bundler is not being used to manage dependencies, install the gem by executing: $ gem install cryptophysh ## Usage ### Extending your own class `require cryptophysh` and Add to your class: `extend Cryptophysh` Your class will now have access to the `::generate_password` class method. ### Using the Cryptophysh::PasswordGenerator Class See the YARD documentation on the class itself for details. ## 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 the created tag, 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/[USERNAME]/cryptophysh. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/kryptykphysh/cryptophysh/blob/master/CODE_OF_CONDUCT.md). ## 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 Cryptophysh project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/kryptykphysh/cryptophysh/blob/master/CODE_OF_CONDUCT.md).
No description provided.
No description provided.
No description provided.