I am joining a Ruby project and I was given a GitHub url for the gemfile. I copied and pasted the gemfile to the root of my ruby setup.
What I wasn't sure about was what the extension of the gemfile should be. Should it be "name.rb" ?
And also what I am confused about is the command I should use. I googled around for the right syntax, but got confused what the syntax should be to use the bundler to create the application from the gemfile that I have.
Advice much appreciated!
The Gemfile should be saved without an extension.
Bundler has many different commands you can use, but it sounds like you are interested in how to get Bundler to install all of the project dependencies. From the Bundler documentation:
bundle install
Install the gems specified by the Gemfile or Gemfile.lock
Since a Gemfile is evaluated as Ruby code it is possible to save it with an extension of .rb. However, Bundler will not automatically find it if you do. If for some reason you do need to save it with a .rb extension this answer shows how it is possible.
Related
Quick metaprogramming question. In my rails 5 project, I'd like to find the installed location of a certain gem in code (ie. not command line).
I started with Bundler.install_path.
Looking under that, I see all the versions of the various gems I have installed for this ruby (I use rbenv, but this should work for rvm too).
/home/user/.rbenv/versions/2.2.3/lib/ruby/gems/2.2.0/bundler/gems/mygem-7eafb06c791d/
/home/user/.rbenv/versions/2.2.3/lib/ruby/gems/2.2.0/bundler/gems/mygem-3da2bf38d01a/
...and so on
Is there a way to tell Bundler "Can you tell me the directory where the gem mygem is installed? Or if there was a hash of gem names with their directories (or something like that), that's fine too.
bonus: if there's a guide to the inner workings of bundler, that'd be cool too :)
Bundler has the show command to show the location of a gem:
bundle show mygem
rbenv-bundler is plugin that makes the rbenv shims Bundler-aware so you dont' have to type bundler exec in front of every command.
you can manage setting of the bundler with create a config file inside ~/.bundle/config (mac / linux)
BUNDLE_PATH: ~/vendor/some_path
if you need more information about config the bundler you can check this bundler.io link
What is the use of Gemfile in rails?
How to use Gemfile?
During your development in Rails, there will be times where you will want to provide some functionality which is required by you, but either you don't know how to do or you don't want to implement it on your own since a lot of work has been put into its development by talented developers.
These developments which you might need (user authentication, message system, asset handlers, geolocation, pagination system, linking to exterior services such as Amazon AWS, and last but not least Rails itself) are called Ruby Gems. These are ruby software packages, not necessarily relating to Rails, but since Rails is based on Ruby, 98% of the gems can be made availble to your Rails webapp code.
Lots of gems can be found in github, but its funner to search for gems via ruby-gems or ruby-toolbox
Your gemfile is a list of all gems that you want to include in the project.
It is used with bundler (also a gem) to install, update, remove and otherwise manage your used gems.
The gemfile has another purpose - you can group gems in :development, :test, :assets, :production, etc groups and Rails will know when to include the gems. For example:
group :development, :test do
gem "rspec-rails"
gem "factory_girl_rails"
gem "guard-rspec"
end
Note that on Rails 4, the assets group has been deprecated
These gems belong to development environment and the test environment since they are for testing the application. You don't need them available in the production environment (you could, but that will bloat the memory unnecessarily).
So - To use the gemfile, simply write the gem you wish to install such as
gem 'devise'
make sure to install bundler beforehand (in your console/cmd/ssh) with
$ gem install bundler
and then write in the console
bundle install
you will notice another gemfile appears! Gemfile.lock
This file, as you will see if you open it with a text reader, lists all your gems with their version and their dependencies. This will come useful when you need to know which versions of the gems you installed.
For more reading on the Gemfile - read on the bundler page
for information regarding picking a gem you could start with this
Good luck and have fun!
Ok, so whats this Gemfile.lock that got created?
Gemfile.lock, as the name suggests is a locking on all the versions of all the gems that got installed. So if Gemfile is what required to be installed, the lock file is what got installed and what version are actually required to get the app up and running.
If you don't have the gems in that specific version (as specified in Gemfile.lock) rails will complain and you will have to either install the missing gems (via bundle install) or fix any conflicts manually (I believe bundler will give you some clues on that)
Some things to know about Gemfile.lock
if you accidently delete it, it will get regenerated when you run bundle install. If you accidently delete Gemfile, you are out of luck.. You should use git :)
Heroku doesn't care about Gemfile.lock since it will reinstall all gems. So for Heroku, you must set the gem version you want, or Heroku will always install the latest version of gem, which may cause issues
Keep the Gemfile.lock in your project so you will always know what version of gems make your app work properly.
Gemfiles are configuration for Bundler, which is used to manage your application's Ruby dependencies. That website includes a lot of documentation, including the Gemfile manual page.
Explanation by analogy
You want to build a car. From scratch. You need to build: a chasis, engine, corroborator, radiator etc.
Gems allow you to utilise car parts which other people have made before
Everyone's who's ever built a car has needed the same things.
You needn't reinvent the wheel. Why make your own engine etc when you can get it straight off the shelf? What if you could get one of the best engines around, created by the most talented engineers in the world, without lifting a finger? Are you gonna spend a year trying to make your own?
So basically rather than make everything yourself, you write down a shopping list of all the parts you need:
Rolls Royce Engine
AutoLive seatbelts
Michellin tyres.
PIAA Night headlights
etc etc.
That my friend, is basically your gem file!
Your system can have lots of gems ... thus can have multiple versions of same gem.
A Gemfile specifies the list of gems with their versions that shall be used/loaded/(install if not present) whenever you run your rails application. or anything with bundle exec . .
Firstly, what is a gem?
According to Wikipedia:
RubyGems is a package manager for the Ruby programming language that
provides a standard format for distributing Ruby programs and
libraries
Gemfile
A Gemfile is a file we create which is used for describing gem
dependencies for Ruby programs
Now, in very very simple words:
Gem can be thought of as a library which you can use in your code.
Example: faker gem
Your code can use the functionality of faker gem to produce fake data.
Now you can list all the gems that your project requires in the gemfile.
When you do a bundle install, all the gems in your gemfile are installed for you.
There is my question: I wonder why using a RVM .gems (see http://beginrescueend.com/gemsets/initial/ to know what I'm tlaking about) in a Rails app while we use Gemfile to install our gems in our project?
I think that could be useful when deploying a project for the first time and ensure (eg.) bundler is installed before running (automatically?) a command like bundle install through the .rvmrc file.
I am right? Is there any use case I am missing?
In short, I want to know what is the interest of *.gems file?
Thanks in advance for all your help that will make me learn a lot ;)
Using .gems and Gemfile is rather explicit, You need only one of them, .gems file is more useful for small projects or even for your preferred gems, mostly when there is not much dependencies, in contrary Gemfile brings strict dependency management ensuring you will always get proper versions of gems (assuming Gemfile.lock is also used)
There is good support for generating .rvmrc in development version of rvm, it will detect if you have *.gems or Gemfile and include proper code like bundle install in .rvmrc:
rvm get head
cd /path/to/project
rvm --rvmrc --create --install 1.9.3#project
Review the new generated .rvmrc file and remove the parts that are not important for you.
I'm just getting started with rails and I'm a little confused reading through different documentation as to when you should add the gem to your gemfile and when you should just "gem install XXX"
For example, when installing rspec and guard-rspec. I see that some folks will:
gem install rb-fsevent
and some people put it in their gemfile and bundle.
Which is the right way and how do you know which to choose? Thanks!
The Gemfile records and manages all the dependencies for the application. When you list gems in the Gemfile, bundler sorts out any version conflicts and makes sure that the correct version of the gems are used with your application.
When you set up the application in a new environment (such as when your colleagues pull your changes from version control or when you deploy to a production web server), Bundler can use the gem file to ensure that the environment is set-up exactly as you had it in development.
So, anything on which your application depends (any code you call from your application for example), needs to be in the Gemfile. This includes libraries that you use for testing (although they can be excluded from the production environment).
Gems that are not dependancies of your application don't need to go in the Gemfile. An example would be guard which is more of a development tool than an application dependancy. You can install those with the gem command.
Typically though, most things you're going to want to install probably need to be in the Gemfile.
It doesn't matter if you install it with the gem command however. You can still put it in your Gemfile afterwards and Bundler will work out what to do.
All gems you will use in your application you should put into Gemfile.
All gems that will be just serving your application you'd better keep out of Gemfile.
For example. You need paperclip and mysql2 gems to store pictures and data, so put them into Gemfile. And you need magic_encoding gem to do some helpful stuff. But as far you are creating it straight from console, you don't need it in your application. Keep it separate from your app.
You use test frameworks when writing code, so put them into your Gemfile.
You use passenger gem to deploy your apps, but you never need to use it right in your code - don't put it into Gemfile.
What is the difference between installing a gem from the command line
sudo gem install gem-name
and writing your gem into the Gemfile and running bundle install?
I think the problem is that I don't understand the exact purpose of the Gemfile. So far it seems like it is a place to list all of the gems that your app is dependent on.
Installing a gem via:
sudo gem install gem-name
is going to install that gem system wide.
Whereas installing them via the Gemfile is specific for your rails app(to keep track of dependencies, version, app portability etc).
The best source of the whats and whys about Bundler, is probably this page:
http://gembundler.com/rationale.html
That page has great examples and explanation about why Bundler is useful and in some cases, necessary.
I always thought you write all gems that your app is dependent on in it, and then if you want to port your application somewhere else, you can run the bundle install and it'll grab the gems you need for you so you don't manually have to do it.
This might clear things up, I quote:
'It holds information about all the project dependencies so that you don't need to struggle to figure out what gems you need to install.'
http://blog.despo.me/42762318