Untitled

Foreword:

I’ll resume taking notes on Ruby/Rails when I’m able to get my Konsole IDE to work as I would like it to, until then, I’m going to sharpen my GitHub skills. GitHub, is a Version Control System, it allows users to seamlessly edit, manage, and change (most often code) files that have been uploaded to directories. The notes I’ll be taking will be from Code School.

Another great place to find documentation for git is:

 https://git-scm.com/documentation (I’ll have excerpts from this site in quotations as well to try and help explain the git commands I’m using in tryGit.)

tryGit:

The class begins having you initialize a directory for git from the current working directory. If you’re from console (at home directory toast@localhost:~$ for example), you begin to first move to the directory in question, say a folder called “Code School”. We can check to see if we have this directory made by first using ls (lists contents of directory). If there isn’t a directory called “Code School” listed, we can create it using mkdir (make directory). Careful though, if you type mkdir Code School you’ll find by using ls, that you now have two directories, one named Code, and another named School. You can fix this by using rmdir command. To create a directory called “Code School”, we’d use mkdir “Code School”. To move into this directory, we’d use cd (Change directory). The command would look like cd “Code School”/ (or cd “Code School”/). We now find ourselves in the ~/Code School/ directory. I use the tilda to reference the login directory because, if we wanted to return to the directory we were just in (the login directory), we can use cd ~ and we’ll move back, alternatively we can go all the way to the system root directory with cd /. Lets return to the lesson at hand though:

Now that we’re in a working directory that we want to connect to git, we can initialize a git repository by using git init

> git init

Initialized empty Git repository in /.git/

Success! (This will not be shown when using console, I’ll be putting this text in bold to indicate that in future uses)

The advice that Code School provides in this section is:

Directory: A folder used for storing multiple files.

Repository: A directory where Git has been initialized to start version controlling your files.

Next we’re told to use the git status command, which “show’s the working tree status.”

$ git status

# On branch master

#

# Initial commit

#

nothing to commit (create/copy files and use "git add" to track)

Success!

The advice that Code School provides in this section is:

The .git directory 

On the left you'll notice a .git directory. It's usually hidden but we're showing it to you for convenience.

If you click it you'll notice it has all sorts of directories and files inside it. You'll rarely ever need to do anything inside here but it's the guts of Git, where all the magic happens.

The advice section here describes how if we used git init in our Code School directory we made earlier, and now used the ls -a command, we’d see a new .git directory in our folder. (the -a just means to list all files, including those that have . before their name.

In the following section they’ll have created a simple .txt file called octocat.txt and they’ll ask us to use git status again.

> git status

# On branch master

#

# Initial commit

#

# Untracked files:

#   (use "git add <file>..." to include in what will be committed)

#

# octocat.txt

nothing added to commit but untracked files present (use "git add" to track)

Success!

They tell you afterwards: “Notice how Git says octocat.txt is "untracked"? That means Git sees that octocat.txt is a new file.To tell Git to start tracking changes made to octocat.txt, we first need to add it to the staging area by using git add.”

With their advice being:

staged: Files are ready to be committed.

unstaged: Files with changes that have not been prepared to be committed.

untracked: Files aren't tracked by Git yet. This usually indicates a newly created file.

deleted: File has been deleted and is waiting to be removed from Git.

The next thing we’ll do is change octocat.txt from being untracked, to staged, or as seen above files that are ready to be committed. This also means we’ll be changing the file to be tracked. We’ll do this by the following command:

$ git add octocat.txt

Nice job, you've added octocat.txt to the Staging Area

They’re advice for using the git add command and helpful extras are:

add all: You can also type git add -A . where the dot stands for the current directory, so everything in and beneath it is added. The -A ensures even file deletions are included.

git reset: You can use git reset <filename> to remove a file or files from the staging area.

Code School is going to have us use, git status again to show the changes that are being made to the file.

$ git status

# On branch master

#

# Initial commit

#

# Changes to be committed:

#   (use "git rm --cached <file>..." to unstage)

#

# new file:   octocat.txt

#

Success!

Verbatim from Code School: “Notice how Git says changes to be committed? The files listed here are in the Staging Area, and they are not in our repository yet. We could add or remove files from the stage before we store them in the repository.To store our staged changes we run the commit command with a message describing what we've changed.” You’ll notice as well, that if we staged something using git add -A (the -A meaning add “ALL”), but only wanted to stage 9 of 10 things, we could use the git rm --cached <file> to unstage something before we commit.

Their helpful hints this section being:

Staging Area: A place where we can group files together before we "commit" them to Git.

Commit: A "commit" is a snapshot of our repository. This way if we ever need to look back at the changes we've made (or if someone else does), we will see a nice timeline of all changes.

Lets commit our file now:

$ git commit -m "Add cute octocat story"

[master (root-commit) 20b5ccd] Add cute octocat story

1 file changed, 1 insertion(+)

create mode 100644 octocat.txt

Success!

Verbatim again: “Great! You also can use wildcards if you want to add many files of the same type. Notice that I've added a bunch of .txt files into your directory below.I put some in a directory named "octofamily" and some others ended up in the root of our "octobox" directory. Luckily, we can add all the new files using a wildcard with git add. Don't forget the quotes! [here they’re asking us to use git add ‘*.txt’]”

With a bit of a warning:

Wildcards: We need quotes so that Git will receive the wildcard before our shell can interfere with it. Without quotes our shell will only execute the wildcard search within the current directory. Git will receive the list of files the shell found instead of the wildcard and it will not be able to add the files inside of the octofamily directory. 

So lets do what they’re asking us and move along:

$ git add '*.txt'

Success!

Their word of advice:

When using wildcards you want to be extra careful when doing commits. Make sure to check what files and folders are staged by using git status before you do the actual commit. This way you can be sure you're committing only the things you want.

So let’s go ahead and be extra careful:

$ git status

# On branch master

# Changes to be committed:

#   (use "git reset HEAD <file>..." to unstage)

#

# new file:   blue_octocat.txt

# new file:   octofamily/baby_octocat.txt

# new file:   octofamily/momma_octocat.txt

# new file:   red_octocat.txt

#

We can now see that by using our wildcard, not only did we at the two new files in the directory we were working in, but we also added both files that were in the newly created octofamily/ directory. 

Everything looks good, so lets run git commit -m ‘Add all the octocat family txt files’. (I didn’t mention this the first time we used git commit, but the “-m” the follows after our commit is for adding a message to go along with our commit. So when we view it on github, and subsequent changes, we can see the message attached to the commit. Often, this is what was changed, or added/removed from the repository with the commit)

$ git commit -m 'Add all the octocat txt files'

[master 3852b4d] Add all the octocat txt files

4 files changed, 4 insertions(+)

create mode 100644 blue_octocat.txt

create mode 100644 octofamily/baby_octocat.txt

create mode 100644 octofamily/momma_octocat.txt

create mode 100644 red_octocat.txt

Success!

To continue the verbatim notes: “So we've made a few commits. Now let's browse them to see what we changed.Fortunately for us, there's git log. Think of Git's log as a journal that remembers all the changes we've committed so far, in the order we committed them.”

More useful logs:

Use git log --summary to see more information for each commit. You can see where new files were added for the first time or where files were deleted. It's a good overview of what's going on in the project.

$ git log

commit 3852b4db1634463d0bb4d267edb7b3f9cd02ace1

Author: Try Git <[email protected]>

Date:   Sat Oct 10 08:30:00 2020 -0500

   Add all the octocat txt files

commit b652edfd888cd3d5e7fcb857d0dabc5a0fcb5e28

Author: Try Git <[email protected]>

Date:   Sat Oct 10 08:30:00 2020 -0500

   Added cute octocat story

Success!

Normally when you use this, you’d see the date being when you created each commit, you’ll also see the message that you attached to the commits. These commits though, we’re they going to? tryGit will cover this topic next using:

git remote: Git doesn't care what you name your remotes, but it's typical to name your main one origin.

It's also a good idea for your main repository to be on a remote server like GitHub in case your machine is lost

“To push our local repo to the GitHub server we'll need to add a remote repository.This command takes a remote name and a repository URL, which in your case is https://github.com/try-git/try_git.git.Go ahead and run git remote add with the options below”

To summarize Ruby 0.3 from codeschool:

"Exclamation Points. Methods may have exclamation points in their name, which just means to impact the current data, rather than making a copy. No big deal.

Square Brackets. With these, you can target and find things. You can even replace them if necessary.

Chaining methods lets you get a lot more done in a single command. Break up a poem, reverse it"

chain the .join onto it to put it all back together

By using { } you can create an empty hash, which is also called a dictionary.

 "Hashes store related information by giving reusable labels to pieces of our data."

Creating Hashes works like > Sandwiches = { } So we'll now have an empty hash that we can call with "Sandwiches". If we want to start filling our hash or dictionary we can do that by using "Sandwiches = ["Ham"] = :Delicious".

If we attempt to just type > Sandwiches = ["Ham"] we'll get an output of nil.

Something else we did was use the : colon.

"When you place a colon in front of a simple word, you get a Ruby symbol. Symbols are much cheaper than strings (in terms of computer memory.) If you need to use a word over and over in your program itself, use a symbol. Rather than having thousands of copies of that word in memory, the computer will store a symbol only once, and refer to it over and over."

If you want, instead of typing out each symbol you're going to use to describe sandwiches such as :delicious, :tastes_good, or tastes_bad you can assign the symbol to a variable using > del = :delicious I'm not sure about best practices when it comes to this but, if you try to do > Sandwiches["Rueben"] = del then call Sandwiches your output will be => {"Rueben" => :delicious}. If you want to know how many items are in your hash then you can type > Sandwiches.length and it'll return the number of items. In my example if I tried it, I would get => 2. The method name #length will work for strings, lists, arrays, and hashes. 

What if we can't remember if we've already entered something for "Ham". We can check with > Sandwiches.keys and our output will be => ["Ham", "Rueben"].

What we've done is create an empty hash and given it a name. In this instance we did Sandwiches by doing > Sandwiches {}. After we created our empty hash we then began to fill it with keys and values. We created keys by using the > Sandwiches["Ham'] = :Delicious. First we called which hash we wanted to use by declaring Sandwiches, after the square brackets and quotes targeted what key we were using, then the equal assigned a value to our key. The key in this case was the symbol ":Delicious". If we try to give a hash a key without a value we're given the output of nil as I stated earlier.

The next example codeschool gives you is to create another empty hash using a different command. It seems the end result may be the same (an empty hash) but how it interacts with our other example will be different.

=> ratings = Hash.new(0)

> { }

if it succeeds then we'll have created a new empty hash called ratings.

The next command we're asked to enter is:

=> books.values.each { |rate| ratings[rate] += 1 }

The excerpt from codeschool describes this as:

(That | in the code is called the pipe character. It's probably located right above the Enter key on your keyboard.)

This code will turn all your unique values in books...into keys within the new ratings hash. Crazy, right? Then, as it looks at each rating you originally gave in books, it will increase the count value for that rating in ratings

After you've built your new hash of count values, type ratings again to see the full tally. This new hash will show you a rating followed by the number of times you've given that rating.

The output of our last line of code (if you were following my examples and used sandwich instead of the codeschool book example):

> [:Delicious]

So what it did was as they explained above, took the values in the hash we created and turned those into keys under the new ratings hash. If you're wondering what values were assigned, were the total times each value was used in the original hash. So for our sandwich example if you were to call the hash ratings, the output will be;

=> {:Delicious=>2}

If we were to analyze the last line more, we can see that we're calling our hash, then using the method .values.each The first method #values created a new array from the values in our hash. The #each (this is taken from the ruby-doc.org):

"Calls block once for each key in hsh, passing the key-value pair as parameters.

If no block is given, an enumerator is returned instead.

h = { "a" => 100, "b" => 200 }

h.each {|key, value| puts "#{key} is #{value}" }

In summary of Ruby 0.2:

"Errors. If you try to reverse a number or do anything fishy, Ruby will skip the prompt and tell you to straighten up.

Arrays are lists of stored information.

Variables are a place to save stuff you might need again, as well as give that stuff a name. You used the equals sign to do this, in a process called assignment."

To demonstrate a way to dynamically change a string of text I'll show an example from codeschool:

There was a saved string of text named "poem". To call the poem you would use the command "print poem" the output yielded the results:

"My toast has flown out of my hand 

And my toast has gone to the moon.

But when I saw it on television,

Planting our flag on Haley's comet,

More still did I want to eat it."

Now, lets say using the word toast wasn't silly enough, we wanted to change the word toast in the poem to honeydew. We could change this by using the command: poem['toast'] = 'honeydew'.

While I'm not entirely sure if this is the process of how it works, I'm postulating that what you're doing is calling the array that you created of the string called poem. In that array you're using the equal sign to say that in the array poem you want to assign 'honeydew' to the character of 'toast' so now all instances of 'toast' are 'honeydew'

When you call "print poem" a second time you'll see that your output is now:

"My honeydew has flown out of my hand

And my toast has gone to the moon.

But when I saw it on television,

Planting our flag on Haley's comet,

More still did I want to eat it."

So looking at the output, I notice that you did not change toast in all instances but instead only on the first line of text did it change.

Fundamentally though, the bracket operator stated, "I am looking for ____ somewhere in here." In this scenario we were looking for the word toast to replace with honeydew.

the .reverse modifier still is able to be used for multiple lines of strings. In this case though, not only will the lines be moved in reverse, the order will reverse too. So the first line will become the last and the last line will become the first.

If we didn't want the words to become reverse such as: "dnah ym fo tuo nwolf sah wedyenoh yM", but still were looking to change the line order we can use the command: "poem.lines.to_a.reverse" This will maintain the word/letter order so our first line will still read as "My honeydew has flown out of my hand", but now it will be our last line instead of the first.

If we look at the command further we can see that it uses a new operand .lines, but we've seen the other two before .to_a and .reverse. The first part "poem" is calling our poem. Then the .lines is deciding on how we're going to handle our string. .lines is deciding to split it by each new line. The next part to_a (to_a[rray]) is converting each single string line into an array. Then lastly we're using .reverse to change the order of our array's. Now you may think when we had the array [47, 15, 33] it changed the order to [33, 15, 47]. So why didn't it change the order of each line array much like the first example of poem.reverse? If you think of it as [first array, second array, third array, fourth array, fifth array] then you can see how .reverse would change it to [fifth array, fourth array, ] and so on. using .line and .to_a changed each string into a single element in our array. This is at least how it seems to work while I'm working through it.

if we were to print this poem though, using just the command print poem.lines.to_a.reverse our output will be

["More still did I want to eat it.\

", "Planting our flag on Haley's comet,\

", "But when I saw it on television,\

", "And my toast has gone to the moon.\

", "My honeydew has flown out of my hand\

"]

to_s will convert values to strings

to_i will convert values to integers

to_a will convert values to arrays

Arrays are a form of lists, stored as sequences.

[ ] is an example of an empty array.

similar to sets in mathematics, when creating an array like [47, 15, 33] the numbers need to be separated by a comma.

Using the point operator you can find the max value in an array by typing ".max" at the end of an array like [47, 15, 33].max

the output would give you, 47

If you've used C you can also create named variables for an array.

number = [47, 15, 33]

now "number" has been declared and initialized with the value of your array

when you input "number" your output will be the array you assigned to it [47, 15, 33]

now instead of typing out the array to find the max value you could just use "number.max" and it'll give you the same output as above, 47

another function that can be called is .sort

inputing number.sort will yeild [15, 33, 47]

lowest value to highest value

by adding a .reverse operand to it will reverse the order to [47, 33, 15]

A note on using the operands on a declared variable.