Adding minor tweaks to 101 and documents-editing as well as find stuff
authorEdgar Bering <ebering@csclub.uwaterloo.ca>
Tue, 7 Oct 2008 16:21:32 +0000 (12:21 -0400)
committerEdgar Bering <ebering@csclub.uwaterloo.ca>
Tue, 7 Oct 2008 16:21:32 +0000 (12:21 -0400)
documents-editing-etc.pod
holy-fuck-a-shell.pod

index 52abaaf..258a363 100644 (file)
@@ -88,4 +88,41 @@ editor will have this feature.
 To specify a find and replace most programs in unix use a I<substitution
 expression> wich is part string and part regular expression. Looking like
 C<s/regex/string/> these expressions instruct the program to replace every
-match of C<regex> with C<string>. In the previous section 
+match of C<regex> with C<string>. You can also capture items in the regular
+expression and re use them as variables in the string. Placing part of a
+pattern in C<()> will capture it, then following it with a triple backslash
+C<\\\> and the group number (capture groups are numbered left to right starting
+at one) to have whatever is matched inside the parens go there.
+
+In the previous tutorial we mentioned C<sed>. C<sed> is the classic program to 
+perform substitutions, it takes a substitution expression (you should put
+the expression in single quotes so the shell doesn't do odd things with your
+pattern) and operates on standard in, giving the result to standard out. This
+allows for C<sed> to be used in a pipe as discussed previously. C<sed> also has
+an B<i>nline edit mode using the C<-i> flag, which edits a single file in
+place. Before doing this its probably a good idea to make a backup of your
+file, incase your command doesn't do exactly what you meant. You can also limit
+the scope of your substitution to regions between two patterns, by specifying
+the start pattern and the end pattern like this: C<START,ENDs/regex/pattern>.
+C<sed> is more powerful than just steram substitution, and has a large 
+featureset and programming language to specify automated editing.
+
+"real editors" like C<vim> and C<emacs>, which we've mentioned earlier also
+have support for substitution commands. In vim these should have been mentioned
+in vimtutor, but if not, in command mode press C<:> and then type your 
+expression to apply it to a line. To specify a range of lines use numbers like
+you used a start and end regexes in C<sed>, or use C<%> to specify the whole
+document. In C<emacs> type C<M-x> and run the C<replace-regexp> macro. By
+default this works on the whole document, to restrict the scope mark a region.
+
+=head2 Spellchecking
+
+To spell check documents, including those marked up with C<latex>, most systems
+provide a program called C<ispell>, which is an interactive spell checker.
+C<ispell> is normally just run on a file, to run it on C<latex> specify the
+C<-t> option for C<TeX>. C<ispell> will edit the file in place, if you'd like
+a backup you can make one manually or pass the C<-b> option to have ispell
+create one for you. The interaction screen in ispell is rather straightforeward
+and if you would like more details you can read the man page. You can
+also create a personal word list if you like, and this too is beyond the scope
+of this tutorial.
index 337ad1b..b5a770a 100644 (file)
@@ -56,14 +56,6 @@ environment in Windows. You use it inside of a command-prompt window. So it's
 just like using PuTTY, except you don't have to be online to use it. Make sure
 the ssh package is installed, and then just type ssh.
 
-=for commentary
-
-What exactly did you want this to discuss? --mgregson
-
-This is fine --ebering
-
-=cut
-
 =head3 From Mac OS-X
 
 Mac OS X comes with X11 (more on X11 later) installed, and with X11 comes
@@ -158,12 +150,6 @@ for by default.
 
 We'll start with some basic file tools and command and control abilities.
 
-=for commentary
-
-Should we perhaps define "file system"?
-
-=cut
-
 =head2 The file system and what to do about it
 
 Programs are just files on disk and manipulate data which is also on the disk, 
@@ -349,21 +335,50 @@ place. There are a few other characters that must be escaped: a space,
 C<">, C<'>, and C<;> for reasons that may or may not be obvious now, but 
 will be after the next section.
 
-=for commentary
+=head3 Power searching: finding files with find
+
+The C<find> command is a flexable tool used to locate files and folders in a 
+given folder (or set of folders). The basic structure of the command is 
+
+       find [Folder(s)] [Search Expression]
+
+Note that the Search Expression is not simply a string that you wish to match - 
+it is more powerful and more complicated than that. As an example, this command:
+
+       (1) find ~/ -name "cs*" 
+
+will locate all files in your home folder that begin with "cs". Find searches 
+recursively, meaning that it will even find matching files when they are located 
+inside subfolders in the home directory. To adjust the number of levels down 
+that 'find' will search, you can use the -maxlevels and -minlevels flags.
+
+You can also use find to B<exec>ute a command on each file returned using the C<-exec>
+flag. Everything after the C<-exec> flag will be considered part of the command you 
+wish to run on all files until the sequence C<\;> (an escaped semi-colon) is 
+encountered. You can use the sequence C<{}> to represent the name of the current 
+file. As an example, this command will search all files in your home direcotry 
+for the phrase I<"Hello World"> and print the name of the files that have matches.
+
+       (2) find ~/ -exec grep -q Hello\ World {} \; -print
+
+The search expresison in C<find> is evaluated left-to-right as a boolean 
+expression based on the success or failure of each parameter. The C<-exec> and 
+C<-print> expressions are implicitly joined by an AND operator.
+
+Example 2 can have this implicit AND written explicitly as:
 
-A section on searching for files (even if its just a blurb) would be
-nice...
+       (3) find ~/ -exec grep -q Hello\ World {} \; -and -print
 
-mgregson--
-I'd recommend throwing in something about find.  It took me a while to figure
-out all the nice little tricks you can do with find, but it's definitely a
-worthwhile effort.
+Whereas:
 
-eg: find ~/src -type f -iname "*.java" -exec grep "/*TODO:*" {} \;
+       (4) find ~/ -exec grep -q Hello\ World {} \; -or -print
 
---mgregson
+would show only files that *didn't* have matchs.
 
-=cut
+Find will stop processing the expression once the final result is known. 
+In (3), C<-exec> returning false means that the whole expression is false, since 
+false AND anything is false. In (4), if C<-exec> returns true, C<-print> will not be 
+processed, since the exit state is already guaranteed to be true.
 
 =head2 What the shell really gives you.. power.