User:Jitendra92/Bundler

Bundler

Original author(s)	Yehuda Katz,Carl Lerche
Developer(s)	Bundler Core Team
Initial release	29 August 2010 (2010-08-29)
Stable release	1.10.6 / July 22, 2015 (2015-07-22)
Written in	Ruby
Operating system	Cross-platform
Type	Application-level package manager
License	MIT License
Website	bundler.io

Bundler is an application-level gem dependency manager for Ruby written under MIT License. Ruby applications like any other software application have dependencies on other Ruby libraries and frameworks called gems to use certain features. Before an application can start using features from other gems, it needs to install those gems through a package manager like RubyGems which allows gems to be manually installed for the application one by one.

Bundler automates the installation process by tracking and installing the exact gems your application needs together with the required versions of their dependencies. It not only helps in installation of gems but also manages them throughout their lifecycle.

Additionally, Bundler checks the compatibility between the specified gem versions along with their dependencies before installing them. It also allows updating one or more gems to newer versions when they are available. By tracking and locking the versions of all gems and their dependencies, it allows application programmers to run the same ruby code on every machine ensuring easy code distribution.

History of Dependency Management in Ruby

Require method

One of the oldest ways in Ruby to share code is the require method. It dates back to the year 1997 . Require method takes in a filename, and loads that file exactly once. The require method makes use of the two important globals $LOADED_FEATURES and $LOAD_PATHS . Working of require method can be logically represented through the following code snippet.

#Logical interpretation of LOADED_FEATURES
$LOADED_FEATURES = []
def require(filename)
  return true if $LOADED_FEATURES.include?(filename)
  eval File.read(filename)
  $LOADED_FEATURES << filename
end

$LOADED_FEATURES maintains the list of all the files that have been ‘required’ once. So that the same code doesn’t run twice if require method gets called again. To solve the problem of code being distributed in multiple directories and to provide absolute paths for the files in require method, global $LOAD_PATH is needed. This can be thought of as a list of directories to look into once require method is called.

#Logical interpretation of LOADED_FEATURES
$LOAD_PATH = []
def require(filename)
  full_path = $LOAD_PATH.find do |path|
    File.exist?(File.join(path, filename))
  end
  eval File.read(full_path)
end

Setup.rb and The Ruby Application Archive

Setup.rb and Ruby Application Archive (RAA) combination for sharing code became popular with Ruby developers from the year 2004 . At its core, setup.rb is a Ruby implementation of a set of three commands ( ruby setup.rb config, ruby setup.rb setup and ruby setup.rb install ) to install libraries .A developer had to browse through RAA looking for library and the version he needed, download the .tar.gz file containing the library, decompress the tar, and from the directory run ruby setup.rb. For updating the library same process had to be repeated as getting a new library. This did not support multiple version install so it created a problem if two applications running on a same environment needed different library versions. RAA was shut down on August 4, 2013 due to lack of resources . Setup.rb still exists but the code has not been maintained since the year 2005. .

RubyGems

In 2004 RubyGems came into existence. Developers could now install and list gems through single commands like gem list and gem install. Also it solved the existing problem by introducing installation of multiple gem versions. It provided its own patches to the require method. If no version of a gem was installed, it installs the newest version available. Developers could now call require for different versions of gem. This revolutionized code sharing in Ruby, and many libraries came up. But with increasing number of gems and their versions, managing dependencies became tougher. Every platform where the application is running had to install the same version of gem, which could create dependency problem for some other application running on the same server. Many solutions like config.gem and gem_installer came up but they failed because RubyGems would simply install the newest available version. Gem activation errors where RubyGems was asked to install a version of the gem and then later on asks to install another version also became very common.

Bundler

The problem with RubyGems was dependency resolution at runtime . Developers had to manually figure out a set of gem versions which would work together before the application runs, this is commonly known as dependency graph resolution problem. Bundler automates this process. Bundler tries various combinations of versions before one combination works. Over the years, it has developed various heuristics to figure out which combination to try first. With this dependency resolution, it has become very fast and takes few seconds for most of the Gemfiles.

Important Files

Gemfile

This file is used to specify a list of all the gems (dependencies) with their versions (optional) which the application requires Bundler to install and manage.

#An example of Gemfile

source 'https://rubygems.org'

gem 'rails', '4.1.0.rc2'
gem 'rack-cache'
gem 'nokogiri', '~> 1.6.1'

In the above shown example Gemfile, the first line defines the source which bundler will be using to fetch the listed gems in this file. The following lines declare the list of gems with their versions (optional)

Gemfile.lock

The file snapshots the exact versions of all the gems installed by Bundler. It not only includes the gems present in the Gemfile but also their dependencies. This allows Bundler to install all the dependencies of the application with their exact versions defined in this file on another machine instead of performing dependency resolution using the Gemfile. This file is automatically generated by bundler after a bundle install.

Getting started

1. Open the terminal and install bundler gem using the command

    $ gem install bundler
   

2. List the gems required by the application in Gemfile

   #How to specify gems and their specific version in a gemfile
   
   gem "rails", "~> 4.0.10"
   gem "pg"
   gem "delayed_job_active_record"
   gem "devise", "~> 3.1.2"
   gem "figaro", github: "laserlemon/figaro"
   gem "will_paginate"
   gem "bootstrap-will_paginate"
   gem "simple_form"
   gem "honeybadger"
   gem "draper"
   gem "stripe"
   

   You may include gem version in the file if you need a specific one.

3. Install the listed gems and their dependencies using command

    $ bundle install
   

   If Gemfile.lock is not present and bundle install is run for the first time, all remote sources are fetched, dependencies are resolved and all needed gems are installed.

   If Gemfile.lock is present bundler will use all gem versions specified in Gemfile.lock instead of resolving dependencies. In case Gemfile is updated, bundler will re-resolve dependencies for updated gems and use versions from Gemfile.lock for gems which were not updated.

4. Checkin Gemfile.lock to your repository so that other developers of the application use same version of the third party code.

Primary Commands

Command	Description
bundle install	Install gems listed in your Gemfile and resolve dependencies
bundle update	Updates the version of the specified gem, updates all dependencies otherwise
bundle package	Copies all .gem files needed by the application to vendor/cache directory
bundle exec	Execute the specified command in context of the bundled gems in Gemfile
bundle config	To set various bundler configuration options
bundle help	Displays help for all subcommands

Supported Frameworks

• Rails 3
• Rails 2.3
• Sinatra
• RubyGems
• RubyMotion

Version History

Version	Date
1.10.0	May 28, 2015
1.9.0	March 20, 2015
1.8.0	February 10, 2015
1.7.0	August 14, 2014
1.6.0	March 28, 2014
1.5.0	December 26, 2013
1.3.0	February 25, 2013
1.2.0	August 30, 2012
1.1.0	March 7, 2012
1.0.0	August 29, 2010
0.9.0	February 3, 2010
0.8.0	January 4, 2010
0.7.0	November 5, 2009
0.6.0	September 23, 2009
0.5.0	September 3, 2009
0.4.0	August 18, 2009
0.3.0	July 29, 2009

References

Category:Free computer libraries Category:Free software programmed in Ruby Category:Software using the MIT license Category:Free package management systems