Return `true` if a file path ends with the given string/suffix.
Returns `true` if the given `string` or `array` ends with `suffix` using strict equality for comparisons.
Convert globs to regular expressions
Retries a function that returns a promise, leveraging the power of the retry module.
Check the text is ends with period mark.
Map of nouns to their irregular plural form
writable stream that concatenates strings or binary data and calls a callback with the result
Check if a string or buffer ends with a given string
Command-line parser with readable syntax from your sweetest dreams
Returns a copy of an object with its keys sorted
A term-str-ends function-factory actor
A tiny Node.js module to make any server force-closeable
Polygonizes a set of lines that represents edges in a planar graph.
A library for interacting with JSON through Refract elements
Conditionally add a middleware to express with some common patterns.
Transform stream to read line-by-line and write a string
Fibonacci and exponential backoffs.
A PEG.js parser for ICU MessageFormat strings
Adds a newline to the end of esformatter output. Will not add newline is the output ends in a newline already.
Stream variables beetween 2 JavaScript threads (client/server, ipc, worker/main thread).
Invoke multiple commands, running in parallel
🐊Putout plugin helps with regexp
node-edge-tts is a module that using Microsoft Edge's online TTS (Text-to-Speech) service on the Node.js
Check if a DOM element matches a given selector, with decent browser support and unit tests.
Inserts an HTML comment at the beggining and ending of html partials with the path to the partial, so that "view vource" can tell you exactly what partial is responsible for the piece of HTML you're looking at. Limited to files ending with .html,.haml,.erb, and .rhtml and Rails 3.0.x ONLY. See https://github.com/gwshaw/noisy_partials for a 3.1 compatibile version
reverse-require allows one to require files that ends with a specified path from other RubyGems. For instance, if one wanted to require the file 'mylibrary/extensions.rb' from all RubyGems: require 'reverse_require' require_all 'mylibrary/extensions' # => true One can also require 'mylibrary/extensions.rb' only from RubyGems that depend on the currently loaded version of the mylibrary Gem: require_for 'mylibrary', 'mylibrary/extensions' # => true
SmarterCSV is a high-performance CSV reader and writer for Ruby focused on fastest end-to-end ingestion — not just parsing. It returns ready-to-use hashes with configurable header and value transformations, intelligent defaults, and automatic delimiter discovery. Built for real-world data pipelines, SmarterCSV supports chunked processing for large files, streaming via Enumerable APIs, and C acceleration to optimize the full ingestion path (parsing + hash construction + conversions). Designed to handle messy user-uploaded CSV while remaining easy to integrate with Rails, ActiveRecord imports, Sidekiq jobs, parallel processing, and S3-based workflows.
Aqueductron lets you create a path for data, then flow data through it, then find the results at the end. It encourages a functional style, avoiding mutable values. It uses iteratees to let the path change itself as the data passes.
Utility for defining a path that, if the file exists, is deleted at the end of the block.
Vimdo is a ruby gem to automate tasks with vim remote servers. Predefined tasks include diff, merge, etc. You can define your own recipes to run tasks with Vim. For example, you can define `DirDiff` recipe: ```ruby module VimDo class CLI < Thor desc "dirdiff", "directory diff in vim" def dirdiff(from, to) [from, to].each do |f| unless File.directory?(f) raise PathError "#{f} is not directory!" end end from, to = [from, to].map {|f| File.expand_path(f) } commands(%Q{exec 'DirDiff ' fnameescape("#{from}") fnameescape("#{to}")}) end end end ``` Then run `vimdo dirdiff path/to/a path/to/b` from the command line or other tools
== Baf baf helps writing an user acceptance test suite with a dedicated library and cucumber steps. It can run and wait for programs in a modified environment, verify the exit status, the output streams and other side effects. It also supports interactive programs and writing to their standard input. Then, it provides a DSL to write the CLI: require 'baf/cli' module MyProgram class CLI < Baf::CLI def setup flag_version '0.1.2'.freeze option :c, :config, 'config', 'specify config file' do |path| @config_path = path end end def run usage! unless arguments.any? puts 'arguments: %s' % arguments puts 'config: %s' % @config_path if @config_path end end end MyProgram::CLI.run ARGV Which behaves this way: % ./my_program Usage: my_program [options] options: -c, --config config specify config file -h, --help print this message -V, --version print version zsh: exit 64 ./my_program % ./my_program --wrong-arg Usage: my_program [options] options: -c, --config config specify config file -h, --help print this message -V, --version print version zsh: exit 64 ./my_program --wrong-arg % ./my_program foo arguments ["foo"] % ./my_program -c some_file foo arguments ["foo"] config path some_file
Provides an AES-256-CBC encrypted session cookie signed with an HMAC digest in a double ended manor. Cookie options include max-age, path, domain, http-only, and secure. Honors Rack's methods like session and request.session_options
If you're running a javascript single-page-app with html5 routing, you may notice that deep links will 404 unless your web front-end is configured to rewrite all non-asset paths to index.html. If you'd like to achieve the same rewrite using rack, this is the gem for you!
Maze-like problem spaces for agentic reasoning — paths, dead ends, backtracking, breadcrumb trails, Ariadne's thread (guiding heuristic), and Minotaur encounters (dangerous misconceptions)
Authentication / Authorization library for Watermark apps
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.