hydra 10.0.0 → 10.0.1

data/doc/Lesson---Build-a-book-model-with-RDF.md

@@ -0,0 +1,250 @@
+# Goals
+* Start the Rails console and run code interactively in the console
+* Define an ActiveFedora model class for Book objects 
+* Create Book objects that use your Book model class
+* See how an object has been indexed into Solr
+* See how and where objects and metadata are stored in Fedora
+* Set indexers to manage how your metadata is indexed into Solr
+* Re-index objects into Solr (update the Solr index based on any changes to an object)
+
+# Explanation
+We are going to create a 'Book' object.  This object will have a set of RDF statements which will describe the properties of the book.
+
+Once you've created an object and saved it in Fedora, you also want to be able to search for it in Solr.  ActiveFedora makes it easy to get your metadata into Solr and manage if/when/how your metadata is indexed. 
+
+# Steps
+
+### Step 1: Create a Book model
+Create a new file at `app/models/book.rb`. We'll paste in this code:
+
+```ruby
+class Book < ActiveFedora::Base
+  property :title, predicate: ::RDF::Vocab::DC.title, multiple: false
+  property :author, predicate: ::RDF::Vocab::DC.creator, multiple: false
+end
+```
+
+This class extends from ActiveFedora::Base the abstract class which all ActiveFedora models should descend.  The code says, create one property called title, which will be expressed in RDF using the Dublin Core RDF title predicate.  Since multiple is set to false, there may only be one title on each Book.   Author is similar, except it uses the Dublin Core RDF 'creator' predicate.
+
+### Step 2: Start the Rails console
+
+Let's take a look at how this class works.  We'll start the rails console by typing 
+
+```bash
+rails console
+```
+
+(Or you can abbreviate this as ```rails c```.)
+
+You should see something like `Loading development environment (Rails 4.2.0)`.  Now you're in a "[REPL](http://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop)", or *interactive ruby console* that has all of your Rails application's code and configuration loaded. 
+
+### Step 3: In the console, create a Book object
+
+Let's create a new Book instance. I've shown the expected output after each command:
+
+```text
+b = Book.new(id: 'test-1')
+ActiveFedora: loading fedora config from /Users/justin/workspace/hydra-demo/config/fedora.yml
+ActiveFedora: loading solr config from /Users/justin/workspace/hydra-demo/config/solr.yml
+Attempted to init base path `dev`, but it already exists
+=> #<Book id: "test-1", title: nil, author: nil>
+b.title = "Anna Karenina"
+=> "Anna Karenina"
+b.author = "Tolstoy, Leo"
+=> "Tolstoy, Leo"
+b.save
+=> true
+puts b.resource.dump(:ttl)
+
+<http://127.0.0.1:8984/rest/dev/test-1> a <http://www.w3.org/ns/ldp#RDFSource>,
+     <http://www.w3.org/ns/ldp#Container>,
+     <http://www.jcp.org/jcr/nt/1.0folder>,
+     <http://www.jcp.org/jcr/nt/1.0hierarchyNode>,
+     <http://www.jcp.org/jcr/nt/1.0base>,
+     <http://www.jcp.org/jcr/mix/1.0created>,
+     <http://fedora.info/definitions/v4/repository#Container>,
+     <http://fedora.info/definitions/v4/repository#Resource>,
+     <http://www.jcp.org/jcr/mix/1.0lastModified>,
+     <http://www.jcp.org/jcr/mix/1.0referenceable>;
+   <http://purl.org/dc/terms/title> "Anna Karenina";
+   <http://fedora.info/definitions/v4/repository#created> "2015-02-04T20:51:20.337Z"^^<http://www.w3.org/2001/XMLSchema#dateTime>;
+   <http://fedora.info/definitions/v4/repository#createdBy> "bypassAdmin";
+   <http://fedora.info/definitions/v4/repository#exportsAs> <http://127.0.0.1:8984/rest/dev/test-1/fcr:export?format=jcr/xml>;
+   <http://fedora.info/definitions/v4/repository#hasParent> <http://127.0.0.1:8984/rest/dev>;
+   <http://fedora.info/definitions/v4/repository#lastModified> "2015-02-04T20:51:20.337Z"^^<http://www.w3.org/2001/XMLSchema#dateTime>;
+   <http://fedora.info/definitions/v4/repository#lastModifiedBy> "bypassAdmin";
+   <http://fedora.info/definitions/v4/repository#mixinTypes> "fedora:Container",
+     "fedora:Resource";
+   <http://fedora.info/definitions/v4/repository#primaryType> "nt:folder";
+   <http://fedora.info/definitions/v4/repository#uuid> "3ed7ee9d-68c7-4b8e-b703-d8a547842aa3";
+   <http://fedora.info/definitions/v4/repository#writable> true;
+   <http://purl.org/dc/terms/creator> "Tolstoy, Leo";
+   <info:fedora/fedora-system:def/model#hasModel> "Book" .
+=> nil
+```
+
+We've created a new Book object in the repository.  You can see that it has a URI (Fedora Commons persistence identifier) of 'http://127.0.0.1:8984/rest/dev/test-1' (default username/password  `fedoraAdmin/fedoraAdmin`).  Because you set title and author you can see they are also stored in the RDF graph.  We can use those values by calling their accessors.
+
+```text
+b.author
+ => "Tolstoy, Leo"
+b.title
+ => "Anna Karenina"
+```
+
+Finally we'll get the Fedora URI and the abbreviated version (`id`) of the object:
+
+```text
+b.uri
+=> "http://127.0.0.1:8984/rest/dev/test-1"
+b.id
+=> "test-1"
+```
+>
+**Note:**
+In the last command of the sequence, we printed the RDF graph for the Book object using Turtle (:ttl) syntax `b.resource.dump(:ttl)`. You can also print the graph using other RDF serialization formats such as N-Triples and JSON-LD
+* `b.resource.dump(:ntriples)`
+* `b.resource.dump(:jsonld)`
+>
+
+### Step 4: See what your Book objects look like in Fedora and Solr
+
+If we go to the URI of your object in a browser; i.e. [http://127.0.0.1:8984/rest/dev/test-1](http://127.0.0.1:8984/rest/dev/test-1), we should see what it looks like in Fedora.  In the properties section you should see the attributes we set:
+
+![screen shot 2015-02-04 at 3 00 07 pm](https://cloud.githubusercontent.com/assets/92044/6049601/9962014c-ac7e-11e4-873e-2c01014ee699.png)
+
+Let's also see that this book has been ingested into the Solr search index. If you followed the example and used test-1 for your book's ID, the solr page will be [[http://localhost:8983/solr/hydra-development/select?q=test-1]] - the generic pattern looks like this: [[http://localhost:8983/solr/hydra-development/select?q=XXX]] and replace the `XXX` with the `id` from your console session. The page should look like the sample below.  Note that, at this point, the title and author have not been indexed in solr.  You only get fields like `system_create_dtsi`, `system_modified_dtsi`, `id`, `object_profile_ssm`, and `has_model_ssim`.  In the next step we will modify our Book model to add the book metadata to the solr document.
+
+```xml
+<?xml version="1.0"?>
+<response>
+  <lst name="responseHeader">
+    <int name="status">0</int>
+    <int name="QTime">27</int>
+    <lst name="params">
+      <str name="q">test-1</str>
+    </lst>
+  </lst>
+  <result name="response" numFound="1" start="0" maxScore="0.0010456265">
+    <doc>
+      <date name="system_create_dtsi">2015-02-04T20:51:20Z</date>
+      <date name="system_modified_dtsi">2015-02-04T20:59:59Z</date>
+      <str name="active_fedora_model_ssi">Book</str>
+      <arr name="has_model_ssim">
+        <str>Book</str>
+      </arr>
+      <str name="id">test-1</str>
+      <arr name="object_profile_ssm">
+        <str>
+          {"id":"test-1","title":"Anna Karenina","author":"Tolstoy, Leo"}
+        </str>
+      </arr>
+      <long name="_version_">1492211308347523072</long>
+      <date name="timestamp">2015-02-04T20:59:59.422Z</date>
+      <float name="score">0.0010456265</float>
+    </doc>
+  </result>
+  <lst name="facet_counts">
+    <lst name="facet_queries"/>
+    <lst name="facet_fields">
+      <lst name="active_fedora_model_ssi">
+        <int name="Book">1</int>
+      </lst>
+      <lst name="object_type_si"/>
+    </lst>
+    <lst name="facet_dates"/>
+    <lst name="facet_ranges"/>
+    <lst name="facet_intervals"/>
+  </lst>
+  <lst name="spellcheck">
+    <lst name="suggestions">
+      <bool name="correctlySpelled">true</bool>
+    </lst>
+  </lst>
+</response>
+```
+
+### Step 5: See how your Book metadata are indexed into Solr
+
+The to_solr method is what generates the solr document for your objects.  To see the full solr document for the book we created, call
+
+```text
+b.to_solr
+=> {"system_create_dtsi"=>"2015-02-04T20:51:20Z", "system_modified_dtsi"=>"2015-02-04T20:59:59Z", "active_fedora_model_ssi"=>"Book", "has_model_ssim"=>["Book"], :id=>"test-1", "object_profile_ssm"=>"{\"id\":\"test-1\",\"title\":\"Anna Karenina\",\"author\":\"Tolstoy, Leo\"}"}
+```
+
+As you can see, the the author and title values are not indexed (excluding `object_profile_ssm`).
+
+Once you're done, exit the console by typing ```exit```
+
+### Step 6: Change how your Book metadata are indexed into Solr
+
+To make the Book model index the author and title fields, you need to reopen `app/models/book.rb` and change the class to look like this:
+
+```ruby
+class Book < ActiveFedora::Base
+  property :title, predicate: ::RDF::Vocab::DC.title, multiple: false do |index|
+    index.as :stored_searchable
+  end
+  property :author, predicate: ::RDF::Vocab::DC.creator, multiple: false do |index|
+    index.as :stored_searchable
+  end
+end
+```
+
+**Note:** Because we have made changes to our Ruby code that we want to use, we need to restart the Rails console so that it will reload all of the code, including our latest changes.
+
+Now, **restart the rails console** and we can load the object we previously created:
+
+```text
+b = Book.find("test-1")
+=> #<Book id: "test-1", title: "Anna Karenina", author: "Tolstoy, Leo">
+```
+
+Check and see that to_solr includes the title and author fields.
+
+```text
+b.to_solr
+=> {"system_create_dtsi"=>"2015-02-04T20:51:20Z", "system_modified_dtsi"=>"2015-02-04T20:59:59Z", "active_fedora_model_ssi"=>"Book", "has_model_ssim"=>["Book"], :id=>"test-1", "object_profile_ssm"=>"{\"id\":\"test-1\",\"title\":\"Anna Karenina\",\"author\":\"Tolstoy, Leo\"}", "title_tesim"=>["Anna Karenina"], "author_tesim"=>["Tolstoy, Leo"]}
+```
+
+Now when you call `.to_solr` on a Book it returns a solr document with fields named `title_tesim` and `author_tesim` that contain your title and author values.  Those are the field names that we will add to Blacklight's queries in [[Lesson - Make Blacklight Return Search Results]].
+
+
+### Step 7: Re-index an object in Solr
+
+Now we'll call the ```update_index``` method, which republishes the Solr document using the changes we've made.
+
+```text
+b.update_index
+ => {"responseHeader"=>{"status"=>0, "QTime"=>25}} 
+```
+
+If you refresh the document result from solr ([[http://localhost:8983/solr/hydra-development/select?q=test-1]]) you should see that these fields have been added to the solr_document:
+
+```xml
+<arr name="title_tesim">
+    <str>Anna Karenina</str>
+</arr>
+<arr name="author_tesim">
+    <str>Tolstoy, Leo</str>
+</arr>
+```
+
+**Aside:** The strange suffixes on the field names are provided by [solrizer](http://github.com/projecthydra/solrizer). You can read about them in the [solrizer documentaton](https://github.com/projecthydra/hydra-head/wiki/Solr-Schema). In short, the **_tesim** suffix tells Solr to treat the values as _**t**ext_ in the _**e**nglish_ language that should be _**s**tored_, _**i**ndexed_ and allowed to be _**m**ultivalued_. This _tesim suffix is a useful catch-all that gets your searches working predictably with minimal fuss. As you encounter cases where you need to index your content in more nuanced ways, there are ways to change these suffixes in order to achieve different results in Solr.
+
+#### Why doesn't the Book show up in Blacklight?
+
+Now your object is indexed properly, but it **won't show up in Blacklight's search results** until you've turned off access controls and added the appropriate fields to Blacklight's queries.  We cover those in a subsequent lesson, but first we'll take a look at modeling a similar object using XML instead of RDF to store our metadata.
+
+### Step 8: Commit your changes
+
+Now that we've got our model working, it's a great time to commit to git:
+
+```text
+git add .
+git commit -m "Create a book model using RDF"
+```
+
+# Next Step
+If you want to learn about modeling similar data in XML, proceed to [[Lesson - Build a codex model with XML]]; otherwise, go on directly to [[Lesson - Make Blacklight Return Search Results]] or return to the [[Dive into Hydra]] page.

data/doc/Lesson---Define-Relationships-Between-Objects.md

@@ -0,0 +1,125 @@
+# Goals
+* Set up Models to represent relationships between different types of objects
+* Create and modify relationships between objects
+
+# Explanation
+Now that we have created a model for Books, we will create a separate model for Pages and set a relationship between the two models indicating that any Book can have many Pages and Pages know what Book they belong to.
+
+The syntax for declaring relationships between ActiveFedora models is the same syntax used by ActiveRecord.  It's called the ActiveModel syntax.  Underneath the hood, the two libraries implement relationships in very different ways.  ActiveRecord uses relational database techniques like foreign keys and join tables while ActiveFedora puts this information into RDF relationships in the RELS-EXT datastreams of your Fedora objects. In both cases you can use the ActiveRecord methods to handle relationships.
+
+# Steps
+
+### Step 1: Define a Page object model
+
+Next we're going to add a Page model.  We'll start by creating another simple model.  This time open ```app/models/page.rb``` and add this content:
+
+```ruby
+class Page < ActiveFedora::Base
+  
+  property :number, predicate: ::RDF::URI.new('http://opaquenamespace.org/hydra/pageNumber'), multiple: false do |index|
+    index.as :stored_searchable
+    index.type :integer
+  end
+  
+  property :text, predicate: ::RDF::URI.new('http://opaquenamespace.org/hydra/pageText'), multiple: false do |index|
+    index.as :stored_searchable
+  end
+
+  belongs_to :book, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
+
+end
+
+```
+
+This is very similar to how our RDF-based Book class looks, we're just adding different attributes defined by different predicates.  I.E. a Book has an _author_ and a _title_, while a Page has a _number_ and _text_.
+
+The final line in the page example establishes a relationship between the page and book models. This works very similarly to the way you would define the relationship with ActiveRecord.  In ActiveFedora, we have to add the :predicate attribute as well that describes the type of relationship. 
+
+If you completed the XML Codex lesson but not the Book lesson, change the next to last line to read `belongs_to :codex, ...` instead of `belongs_to :book, ...`.  It's totally OK to mix models with both XML and RDF in this way! If you defined a Codex object model, but not a Book object model in previous lessons, you can complete the rest of this lesson by substituting `codex` anywhere the lesson says `book` (be sure to match capitalization, etc.).  Hydra, especially Active Fedora, is designed to let you manipulate your digital repository objects as much like standard ruby objects as possible; this means that we try to abstract away the specific mechanisms used to persist metadata.  So, once your objects are defined, the code you write to manipulate object with RDF metadata looks very much like the code you write to manipulate objects with XML metadata.
+
+> ASIDE #1: It's generally best practice to use well-known RDF predicates when defining metadata terms, e.g. using DC.title for your title term. In some cases, however, RDF ontologies don't exist to express the concepts we want to track.  Surprisingly, page numbers are in this group; therefore, we have used a predicate registry created by the community to define our page number predicate: <span>http:/</span>/opaquenamespace.org/hydra/pageNumber.  
+
+> ASIDE #2: We are explicitly assigning a type for the page number index.  This lets us control our indexing and searching to use integer sorting (e.g. 1,2,3,4,...9,10,11) instead of the default lexical sorting use for strings (e.g. '1','10','11','2','21','27','5','6','60').  By default, Hydra and Active Fedora assume all metadata are text values.  You can find additional information on the available indexing options in the [Solrizer ReadME](https://github.com/projecthydra/solrizer) and in the [solrizer code that defines the default indexing strategies](https://github.com/projecthydra/solrizer/blob/master/lib/solrizer/default_descriptors.rb)
+
+### Step 2: Make Books aware of their Pages
+
+Let's edit the Book class in ```app/models/book.rb``` and add the other half of the relationship:
+
+```ruby
+  # within app/models/book.rb
+  has_many :pages
+```
+
+### Step 3: In the Console, manipulate relationships between Book and Page objects
+
+Save your changes and then reopen the rails console. Now we ought to be able to create some associations.
+
+```ruby
+b = Book.find("test-1")
+ => #<Book id: "test-1", title: "Anna Karenina", author: "Tolstoy, Leo"> 
+p = Page.new(id: "test-3", number: 1, text: "Happy families are all alike; every unhappy family is unhappy in its own way.")
+ => #<Page id: "test-3", number: 1, text:"Happy families are all alike; every unhappy family is unhappy in its own way."> 
+p.book = b
+ => #<Book id: "test-1", title: "Anna Karenina", author: "Tolstoy, Leo"> 
+p.save
+ => true
+b.pages
+ => [#<Page id: "test-3", number: 1, text: "Happy families are all alike; every unhappy family is unhappy in its own way.", book_id: "test-1">]
+```
+
+### Step 4: Look at the RDF (if you want to)
+
+**Note:** If you don't know what RDF is and don't care to know, you can skip this step.
+
+Let's look at the RDF that active-fedora uses to represent these relationships. To see that content, either output it on the command line like this:
+
+```ruby
+puts p.resource.dump(:ttl)
+```
+Alternatively, look at the resource in your browser at [http://127.0.0.1:8984/rest/dev/test-3](http://127.0.0.1:8984/rest/dev/test-3)  (You might need to change the pid in the URL if your page's id isn't test-3)
+
+Either way, you should see RDF that looks like this:
+
+```text
+<http://127.0.0.1:8984/rest/dev/test-3> a <http://www.w3.org/ns/ldp#RDFSource>,
+     <http://www.w3.org/ns/ldp#Container>,
+     <http://www.jcp.org/jcr/nt/1.0folder>,
+     <http://www.jcp.org/jcr/nt/1.0hierarchyNode>,
+     <http://www.jcp.org/jcr/nt/1.0base>,
+     <http://www.jcp.org/jcr/mix/1.0created>,
+     <http://fedora.info/definitions/v4/repository#Container>,
+     <http://fedora.info/definitions/v4/repository#Resource>,
+     <http://www.jcp.org/jcr/mix/1.0lastModified>,
+     <http://www.jcp.org/jcr/mix/1.0referenceable>;
+   <http://fedora.info/definitions/v4/repository#created> "2015-02-04T23:09:20.012Z"^^<http://www.w3.org/2001/XMLSchema#dateTime>;
+   <http://fedora.info/definitions/v4/repository#createdBy> "bypassAdmin";
+   <http://fedora.info/definitions/v4/repository#exportsAs> <http://127.0.0.1:8984/rest/dev/test-3/fcr:export?format=jcr/xml>;
+   <http://fedora.info/definitions/v4/repository#hasParent> <http://127.0.0.1:8984/rest/dev>;
+   <http://fedora.info/definitions/v4/repository#lastModified> "2015-02-04T23:09:20.012Z"^^<http://www.w3.org/2001/XMLSchema#dateTime>;
+   <http://fedora.info/definitions/v4/repository#lastModifiedBy> "bypassAdmin";
+   <http://fedora.info/definitions/v4/repository#mixinTypes> "fedora:Container",
+     "fedora:Resource";
+   <http://fedora.info/definitions/v4/repository#primaryType> "nt:folder";
+   <http://fedora.info/definitions/v4/repository#uuid> "6c2b0f28-f211-4e91-a1e6-59b86d916ad6";
+   <http://fedora.info/definitions/v4/repository#writable> true;
+   <http://opaquenamespace.org/hydra/pageNumber> 1;
+   <http://opaquenamespace.org/hydra/pageText> "Happy families are all alike; every unhappy family is unhappy in its own way.";
+   <info:fedora/fedora-system:def/model#hasModel> "Page";
+   <info:fedora/fedora-system:def/relations-external#isPartOf> <http://127.0.0.1:8984/rest/dev/test-1> .
+=> nil
+```
+
+As you can see, it is creating rdf assertions of `info:fedora/fedora-system:def/relations-external#isPartOf` `http://127.0.0.1:8984/rest/dev/test-1` and `info:fedora/fedora-system:def/model#hasModel` `Page`. The model assertion is created automatically based on the name of your ActiveFedora model (in this case, Page)
+
+### Step 5: Commit your changes
+
+Now that we've added page relationships, it's a great time to commit to git:
+
+```text
+git add .
+git commit -m "Created a page model with relationship to the book model"
+```
+
+# Next Step
+Go on to **BONUS** [[Lesson - Adding attached files]] or 
+explore other [Dive into Hydra](Dive into Hydra#Bonus) tutorial bonus lessons.

data/doc/{Lesson:-Generate-Rails-Scaffolding-for-Creating-and-Editing-Books.md → Lesson---Generate-Rails-Scaffolding-for-Creating-and-Editing-Books.md}

@@ -5,7 +5,7 @@
 
 # Explanation
 
-This lesson walks you through modifying the "Title" field in your book model to make it either single- or multi-valued.  The lesson then walks through the changes necessary to modify views to read, create, and edit your updated metadata model.
+This lesson walks you through modifying the "Author" field in your book model to make it either single- or multi-valued.  The lesson then walks through the changes necessary to modify views to read, create, and edit your updated metadata model.
 
 # Steps
 
@@ -16,25 +16,23 @@ We will use the Rails scaffold generator to set up the routes, Controller and Vi
 
 **Note:** If you are not familiar with the ideas of Controllers, Views and routes, or aren't familiar with the Rails scaffold generator, go through the [Railsbridge Curriculum](http://curriculum.railsbridge.org/curriculum/curriculum) and then come back to this lesson.  You might also want to read the [Getting Started with Rails](http://guides.rubyonrails.org/getting_started.html) guide.
 
-Tell the generator to build scaffolding for the Book model and make it assume books have `title` and `author` attributes like the ones we set up earlier in [[Lesson: build a book model]].
+Tell the generator to build scaffolding for the Book model and make it assume books have `title` and `author` attributes like the ones we set up earlier in [Lesson Build a book model with RDF](https://github.com/projecthydra/hydra/wiki/Lesson---Build-a-book-model-with-RDF).
 ```text
 rails generate scaffold Book title:string author:string
 ```
 
+>NOTE: If you completed the XML based Codex example instead of the RDF based Book example earlier, all you need to do is replace `Book` with `Codex` in the line above.
+
 When it asks you whether to overwrite `app/models/book.rb`, enter `n` and hit enter. 
 
-Depending on the specific version of rails you are running the generator creates a few things that we don't want in the `test` and `db` directories.  Delete them with the `git clean` command.
+Rails assumes that you're using an ActiveRecord based model stored in a SQL databases and creates the necessary database migrations to setup a table to store books.  We're using Fedora, not SQL, to persist our book objects, so you don't need this database migration.  You can delete it with the `git clean` command.
 
 ```bash
-$ git clean -df test db
+git clean -df db
 ```
 You'll see output something like this:
 ```text
 Removing db/migrate/20130417230046_create_books.rb
-Removing test/fixtures/books.yml
-Removing test/functional/books_controller_test.rb
-Removing test/unit/book_test.rb
-Removing test/unit/helpers/
 ```
 
 ### Step 2: Run the server & Explore
@@ -43,20 +41,6 @@ Run the `rails server` and visit [[http://localhost:3000/books]]
 
 Explore the pages for creating, editing and showing Books.
 
-> ####Rails 3-troubleshooting:
-> If you see 'uninitialized constant Book::BookMetadata' you'll need to edit two files.
-> Open `app/models/datastreams/book_metadata.rb` and replace `BookMetadata` in the class definition with `Datastreams::BookMetadata` i.e.
-> 
-> ```ruby
-> class Datastreams::BookMetadata < ActiveFedora::OmDatastream
-> ```
->
-> You will also need to edit `app/models/book.rb` and replace `BookMetadata` with `Datastreams::BookMetadata`:
->
-> ```ruby
->  has_metadata 'descMetadata', type: Datastreams::BookMetadata
-> ```  
-
 ### Step 3: Commit your work
 
 ```text
@@ -69,9 +53,11 @@ git commit -m "Ran Book scaffold generator"
 Open `app/models/book.rb` and edit the multiple setting to be 'true':
 
 ```ruby
-   has_attributes :author, datastream: 'descMetadata', multiple: true
+   property :author, predicate: ::RDF::DC.creator, multiple: true
 ```
 
+>NOTE: you might be editing the file `app/models/codex.rb` if you completed the XML step of the tutorial, just make sure the value for `multiple:` in the author property is set to `true`
+
 Now you need to tell your hydra application how to display multivalued fields in the 'show' (Display) view for this model. 
 In `app/views/books/show.html.erb` find the lines that display the author field.
 ```erb
@@ -86,14 +72,14 @@ We want to make these lines iterate over the values returned by `@book.author` a
 <p>
   <b>Author(s):</b>
   <ul>
-    <%- @book.author.each do |author|%>
+    <% @book.author.each do |author|%>
       <li><%= author %></li>
-    <%- end %>
+    <% end %>
   </ul>
 </p>
 ```
 
-Save the file and refresh the Show view for a book.  Now authors show up as a list of values.
+Save the file and refresh the Show view for a book.  Now authors show up as a list of values.  Note that the display of results of a search is **not** affected, only the view which you can reach from [http://localhost:3000/books](http://localhost:3000/books).
 
 ### Step 5: Allow Create and Update views to display Authors as a multi-valued field
 
@@ -118,7 +104,7 @@ Replace those lines with something that iterates over the values from `@book.aut
   <% end %> 
 ```
 
-This handles displaying existing author values, but what about setting the author value in the first place?  If there are no values in the array, no fields are going to be displayed.  As a stop-gap, we can add a conditional clause that displays an empty text_field when the array is empty.
+This handles displaying existing author values, but what about setting the author value in the first place?  If there are no values in the array, no fields are going to be displayed.  As a stop-gap, we can add a conditional clause that displays an empty text_field after the existing authors are displayed.
 
 ```erb
   <%= f.label :author, "Authors" %>
@@ -127,36 +113,55 @@ This handles displaying existing author values, but what about setting the autho
       <%= text_field_tag "book[author][]", author %>
     </div>
   <% end %> 
-  <%- if @book.author.empty? %>
-    <div class="field">
-      <%= text_field_tag "book[author][]", nil %>
-    </div>
-  <%- end %>
+  <div class="field">
+    <%= text_field_tag "book[author][]", nil %>
+  </div>
+```
+
+Update the `book_params` method in `app/controllers/books_controller.rb` from
+```ruby
+    def book_params
+      params.require(:book).permit(:title, :author)
+    end
+```
+to
+```ruby
+    def book_params
+      params.require(:book).permit(:title, :author=>[])
+    end
 ```
 
-*Note:* This still doesn't cover the case where you want to _add_ more than one Author to a Book.  That goes beyond the scope of this tutorial because it requires javascript (or a multi-page workflow).
-
-> #### Rails 4-only step
->
-> Update the `book_params` method in `app/controllers/books_controller.rb` from
-> ```ruby
->     def book_params
->       params.require(:book).permit(:title, :author)
->     end
-> ```
-> to
-> ```ruby
->     def book_params
->       params.require(:book).permit(:title, :author=>[])
->     end
-> ```
+Now every time you save the form you'll get one more additional author. However you get this author even if you haven't filled any value in. Let's update the BooksController to not save authors that don't have names.
+
+
+```ruby
+# app/controllers/books_controller.rb
+
+  def update
+    @book.attributes = book_params
+    @book.author = params[:book][:author].select { |a| a.present? }
+    respond_to do |format|
+      if @book.save
+        format.html { redirect_to @book, notice: 'Book was successfully updated.' }
+        format.json { render :show, status: :ok, location: @book }
+      else
+        format.html { render :edit }
+        format.json { render json: @book.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+```
+
+*Note:* This still doesn't cover the case where you want to _add_ more than one additional Author to a Book.  That goes beyond the scope of this tutorial because it requires javascript (or a multi-page workflow).
+
 
 ### Step 6: Try out multiple authors
 
 Start up the rails console and run the following commands to add a second author to our book.
 
 ```ruby
-b = Book.find('changeme:1')
+b = Book.find('test-1')
 b.author += ['Some other author']
 b.save
 ```
@@ -174,5 +179,7 @@ git commit -m "Handling multivalued author fields"
 
 Based on the concepts in steps 1-7, determine whether you want 'Title' to display as a single or multi-valued field and make appropriate edits to the 'show' view and '_form' partial on your own.
 
+In general, you might not want to build all the views to edit your metadata by hand.  The [hydra-editor](https://github.com/projecthydra/hydra-editor) gem is used by many hydra adopters as a way to handle providing metadata editing forms without having to hand-code for each field.  It also provides javascript support for repeating fields like our author field above so you can add multiple values to a single term without having to save each time.
+
 # Next Step
-Proceed to additional hydra tutorials including [Tame Your XML With OM](https://github.com/projecthydra/om/wiki/Tame-your-XML-with-OM) and [Access Controls with Hydra](https://github.com/projecthydra/hydra-head/wiki/Access-Controls-with-Hydra) or go back to explore other [Dive into Hydra](Dive into Hydra#Bonus) tutorial bonus lessons.
+Proceed to additional hydra tutorials including [Tame your RDF Metadata with ActiveFedora](https://github.com/projecthydra/active_fedora/wiki/Tame-your-RDF-Metadata-with-ActiveFedora) [Tame Your XML With OM](https://github.com/projecthydra/om/wiki/Tame-your-XML-with-OM) and [Access Controls with Hydra](https://github.com/projecthydra/hydra-head/wiki/Access-Controls-with-Hydra) or go back to explore other [Dive into Hydra](Dive into Hydra#bonus) tutorial bonus lessons.