Bundler

A bundler for R

A gem that provides dead-simple usage of bundler.

This gem is used to get the paths for all gems known to Bundler in a given project. The paths can be printed in various formats.

Gem generator that uses bundler gem generator

Genlock generates Gemfile.lock files from .gems files without the need for Bundler

A bundler plugin that generates a visual representation of your gem dependencies.

A fork that can be used as a gem with Bundler as the model Task has been changed to Task_Item to remove a reserved word namespace issue in Rails. There is also a corresponding bf4-bcms_news. You'll likely want to require active_support and cms/init in your rails initializer.

# 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.

Hack bundler to not generate BUNDLED WITH

provides bundler-add command

Output credits for authors of RubyGems \ your Bundler-based project depends on.

exclude your bundle from Time Machine and Spotlight on macOS

Comment your Gemfile with descriptions from RubyGems.org

Make bundler git source faster

This is a script for generating a basic ruby directory with bundler, rake and rspec integrations.

bundler-fu provides some tools for bundler

command-line script to modify and run bundler for you in one operation

bundler-audit provides patch-level verification for Bundled apps.

Supplements Bundler for installing private gems.

bundler next

This is not a realy gem. Just trying to reproduce a bundler issue.

A simple repository and gem to help test and troubleshoot issues with Rubinius running Bundler.

Resolve gem dependencies as-of a date in the past. Intended to resurrect older projects with out-of-date dependencies.

This Gem automatically downloads and extracts the ruby-advisory-db Database from Github. Than it uses bundler and rubygems to check for advisories in your installed Gems by executing a rake task.

Flavors bundler generated Rubygem and scaffolding

As opposed to manually building a manifest file for all those sass partials, let this rake task take care of it.

A meta-gem to install bundler via the bungler name, for consistency with command-line aliases already in use.

Gemmate uses Bundler to identify an application's dependencies and opens them in TextMate for quick reference.

Application and configuration bundler for OSGi apps.

Bundler plugin to add gem summaries to a Gemfile

Generates new gem skeletons faster than the speed of rice! That is, assuming that you want to use bundler for gem management, rake for task management, rspec for testing, and yard for documentation.

Simple plugin for Bundler to generate verbose Gemfile with description of each gem. It may be useful for novice Ruby developers or when you start diving into the new Ruby project.

Disallow gem versions by release date

This gem was written largely to get familiar with aruba, and minitest, bundler and thor when making gems with a CLI

Bundler plugin to show the release dates of gems.

Manage delta indexes via Delayed Job for Thinking Sphinx (including fix for bundler)

rubygems-plugin fork! Bundler manages an application's dependencies through its entire life, across many machines, systematically and repeatably

# 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)) ``` $ gem install mdtoc ``` ## Usage ``` $ 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. ``` $ 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"). ``` $ 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 ``` task default: %w[mdtoc] desc 'Update Markdown table of contents and push changes to the git repository' task :mdtoc do |t| command = <<~END set -e git pull 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 -m 'Update TOC' git push END %x|#{command}| end ``` See [andornaut/til](https://github.com/andornaut/til/blob/master/Rakefile) for an example. ## Development ### Installation Requirements: * [Bundler](https://bundler.io/) ``` # Install dependencies $ bundle ``` ### Usage ``` # List rake tasks $ rake -T rake build # Build mdtoc-0.0.2.gem into the pkg directory rake default # Run the build, rubocop:auto_correct, sorbet and test tasks rake install # Build and install mdtoc-0.0.2.gem into system gems rake install:local # Build and install mdtoc-0.0.2.gem into system gems without... rake release[remote] # Create tag v0.0.2 and build and push mdtoc-0.0.2.gem to ru... rake rubocop # Run RuboCop rake rubocop:auto_correct # Auto-correct RuboCop offenses 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} ```

## Why I have to develop this tool One of my ruby project is using bundler to manage gem dependencies. But the `Gemfile` is very complicate. It requires external `Gemfile` by using ruby `eval`. Because I have lots of similar projects that will use same piece of gems. So I decide to abstract these gems into a standalone `Gemfile`. And let those projects’ `Gemfile` loads it. The problem I met is when I building my docker image. I hope that image can pre-install all the ruby gems in that `Gemfile.lock`. Unluckily, `bundle install` require you must have the `Gemfile`. So I have to find out a way to revert `Gemfile.lock` to a usable `Gemfile`. So here we are!

Bundler Security

Apologize to Bundler and you'll get your gem back

Bundler manages an application's dependencies through its entire life, across many machines, systematically and repeatably

Bundler patches for Jets

Test for gemify using bundler

Add multiple items to an Amazon Cart with one link.

Bundler for .debs

Installs Gems unable to be installed by bundler

Bundler for Puppet modules.

Thanks to ihaveu.com team.

Bring missing bundler functionalities to rubygems 2+