cd my_app

cd my_app/app/controllers

ls directory

Windows: dir directory

ls

ls my_app

mkdir rails

mkdir fun

rm file

Windows: del file

rm foo

rm index.html

rm pictures/old_picture.jpg

Deletes the specified file. Be extra cautious with this as it would be too bad to delete something you still need :-(

You can simply specify the name of a file of the directory you are currently in. However you can also specify a path, this is shown in the third example. There we delete the old_picture.jpg file from the pictures folder.

rm -r folder

Windows: rd folder

rm -r stuff_i_dont_need

rm -r stuff_i_dont_need/

rm -r old_application

Deletes the specified folder and all of its contents. So please be super cautious with this! Make sure that you do not need any of the contents of this folder any more.

So why would you want to delete a whole folder? Well maybe it was an old application that you do not need anymore :-)

firefox

firefox railsgirlsberlin.de

irb

# This text is a comment

some.ruby_code # A comment

# some.ignored_ruby_code

name = "Tobi"
name # => "Tobi"

sum = 18 + 5
sum # => 23

puts "Hello World"

puts [1, 5, "mooo"]

string.length

array.delete_at(2)

string.gsub("ae", "ä")

Calling a method is also often referred to as sending a message in Ruby. Basically we are sending an object some kind of message and are waiting for its response. This message may have no arguments or multiple arguments, depending on the message. So we kindly ask the object to do something or give us some information. When you "call a method" or "send a message" something happens. In the first example we ask a String how long it is (how many characters it consists of). In the last example we substitute all occurrences of "ae" in the string with the German "ä".

Different kinds of objects (Strings, Numbers, Arrays...) understand different messages.

def name(parameter)
  # method body
end

def greet(name)
  puts "Hi there " + name
end

Methods are basically reusable units of behaviour. And you can define them yourself just like this. Methods are small and focused on implementing a specific behaviour.

Our example method is focused on greeting people. You could call it like this: greet("Tobi")

true == true # => true

3 == 4 # => false

"Hello" == "Hello" # => true

"Helo" == "Hello" # => false

true != true # => false

3 != 4 # => true

if condition
  # happens when true
else
  # happens when false
end

if input == password
  grant_access
else
  deny_access
end

With if-clauses you can decide based upon a condition what to do. When the condition is considered true, then the code after it is executed. If it is considered false, the code after the "else" is executed.

In the example, access is granted based upon the decision if a given input matches the password.

PI = 3.1415926535
PI # => 3.1415926535

ADULT_AGE = 18
ADULT_AGE # => 18

0

-11

42

3.2

-5.0

2 + 3 # => 5

5 - 7 # => -2

8 * 7 # => 56

84 / 4 # => 21

12 > 3 # => true

12 < 3 # => false

7 >= 7 # => true

Numbers may be compared to determine if a number is bigger or smaller than another number. When you have the age of a person saved in the age variable you can see if that person is considered an adult in Germany:

age >= 18 # true or false

'A string'

'Hello World'

'a'

'Just characters 129 _!$%^'

''

"A string and an #{expression}"

"Email: #{user.email}"

"The total is #{2 + 2}"

"A simple string"

"Hello".length # => 5

"".length # => 0

"Hello " + "reader"
# => "Hello reader"

"a" + "b" + "c" # => "abc"

string.gsub(a_string,
substitute)

"Hae".gsub("ae", "ä")
# => "Hä"

"Hae".gsub("b", "ä")
# => "Hae"

"Greenie".gsub("e", "u")
# => "Gruuniu"

[]

["Rails", "fun", 5]

[].size # => 0

[1, 2, 3].size # => 3

["foo", "bar"].size # => 2

array = ["hi", "foo", "bar"]
array[0] # => "hi"
array[2] # => "bar"

array = [1, 2, 3]
array << 4
array # => [1, 2, 3, 4]

array = ["hi", "foo", "bar"]
array[2] = "new"
array # => ["hi", "foo", "new"]

array = [0, 14, 55, 79]
array.delete_at(2)
array # => [0, 14, 79]

persons.each do |p| puts p.name end

numbers.each do |n| n = n * 2 end

"Iterating" means doing something for each element of the array. Code placed between do and end determines what is done to each element in the array.

The first example prints the name of every person in the array to the console. The second example simply doubles every number of a given array.

{:hobby => "programming"}

{42 => "answer", "score" => 100,
 :name => "Tobi"}

hash = {:key => "value"}
hash[:key] # => "value"
hash[foo] # => nil

hash = {:a => "b"}
hash[:key] = "value"
hash # => {:a=>"b", :key=>"value"}

hash = {:a => "b", :b => 10}
hash.delete(:a)
hash # => {:b=>10}

The views subdirectory contains the display templates that will be displayed to the user after a successful request. By default they are written in HTML with embedded ruby (.html.erb). The embedded ruby is used to insert data from the application. It is then converted to HTML and sent to the browser of the user. It has subdirectories for every resource of our application, e.g. places, persons. These subdirectories contain the associated view files.

Files starting with an underscore (_) are called partials. Those are parts of a view which are reused in other views. A common example is _form.html.erb which contains the basic form for a given resource. It is used in the new and in the edit view since creating something and editing something looks pretty similar.

A file that specifies a list of gems that are required to run your application. Rails itself is a gem you will find listed in the Gemfile. Ruby gems are self-contained packages of code, more generally called libraries, that add functionality or features to your application.

If you want to add a new gem to your application, add "gem gem_name" to your Gemfile, optionally specifying a version number. Save the file and then run bundle install to install the gem.

You have to start the server in order for your application to respond to your requests. Starting the server might take some time. When it is done, you can access your application under localhost:3000 in the browser of your choice.

In order to stop the server, go to the console where it is running and press Ctrl + C

The scaffold command magically generates all the common things needed for a new resource for you! This includes controllers, models and views. It also creates the following basic actions: create a new resource, edit a resource, show a resource, and delete a resource.

That's all the basics you need. Take this example:

rails generate scaffold product name:string price:integer

Now you can create new products, edit them, view them and delete them if you don't need them anymore. Nothing stops you from creating a full fledged web shop now ;-)

<% if user.admin? %>
  <p>Hello Admin!</p>
<% end %>

Ctrl + Y

or Ctrl + Shift + Z

Ctrl + H

or Ctrl + R