hydra 10.0.0 → 10.0.1

data/hydra.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |gem|
   gem.license = 'APACHE2'
 
   gem.add_dependency 'fcrepo_wrapper', '~> 0.5.1'
-  gem.add_dependency 'solr_wrapper', '~> 0.12.1'
+  gem.add_dependency 'solr_wrapper', '~> 0.15.0'
   gem.add_dependency 'active-fedora', '~> 10.0.0'
   gem.add_dependency 'hydra-head', '~> 10.0.0'
   gem.add_dependency 'rails', '~> 4.2'

data/lib/hydra/version.rb

@@ -1,3 +1,3 @@
 module Hydra
-  VERSION = "10.0.0".freeze
+  VERSION = "10.0.1".freeze
 end

data/script/grant_revoke_gem_authority.rb

@@ -34,7 +34,7 @@ KNOWN_COMMITTER_EMAIL_ADDRESSES = {
   'jkeck' => "jessie.keck@gmail.com",
   'coblej' => "jim.coble@duke.edu",
   'jpstroop' => "jpstroop@gmail.com",
-  'jcoyne' => "justin@curationexperts.com",
+  'jcoyne' => "digger250@gmail.com",
   'mjgiarlo' => "leftwing@alumni.rutgers.edu",
   'mark-dce' => "mark@curationexperts.com",
   'mbklein' => "mbklein@gmail.com",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hydra
 version: !ruby/object:Gem::Version
-  version: 10.0.0
+  version: 10.0.1
 platform: ruby
 authors:
 - Jeremy Friesen
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-10 00:00:00.000000000 Z
+date: 2016-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fcrepo_wrapper
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.12.1
+        version: 0.15.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.12.1
+        version: 0.15.0
 - !ruby/object:Gem::Dependency
   name: active-fedora
   requirement: !ruby/object:Gem::Requirement
@@ -229,30 +229,31 @@ files:
 - doc/Dive-into-Hydra.md
 - doc/Filtering-search-results-with-hydra-access-controls.md
 - doc/For-Developers.md
+- doc/Hackfest-ideas.md
 - doc/Home.md
 - doc/Hydra-Recipes.md
 - doc/Indexing-non-English-content.md
-- doc/Lesson:-Define-Relationships-Between-Objects.md
-- doc/Lesson:-Generate-Rails-Scaffolding-for-Creating-and-Editing-Books.md
-- doc/Lesson:-Reading-Hydra-rightsMetadata-XML.md
-- doc/Lesson:-Use-Hydra-Access-Controls-to-Control-Access-to-Blacklight-show-Pages.md
-- doc/Lesson:-Using-Hydra-Access-Controls-and-CanCan-to-conditionally-render-part-of-a-page.md
-- doc/Lesson:-add-the-Hydra-dependencies.md
-- doc/Lesson:-adding-content-datastreams.md
-- doc/Lesson:-build-a-book-model.md
-- doc/Lesson:-generate-a-rails-application.md
-- doc/Lesson:-install-hydra-jetty.md
-- doc/Lesson:-make-blacklight-return-search-results.md
-- doc/Lesson:-set-up-your-Rails-Application-to-use-rspec.md
-- doc/Lesson:-start-the-application-&-search-for-results.md
+- doc/LDP-Containers-for-the-perplexed.md
+- doc/Lesson---Adding-attached-files.md
+- doc/Lesson---Build-a-Codex-model-with-XML.md
+- doc/Lesson---Build-a-book-model-with-RDF.md
+- doc/Lesson---Define-Relationships-Between-Objects.md
+- doc/Lesson---Generate-Rails-Scaffolding-for-Creating-and-Editing-Books.md
+- doc/Lesson---Start-FCRepo-and-Solr.md
+- doc/Lesson---add-the-Hydra-dependencies.md
+- doc/Lesson---generate-a-rails-application.md
+- doc/Lesson---make-blacklight-return-search-results.md
+- doc/Lesson---start-the-application-&-search-for-results.md
 - doc/Migrating-to-Hydra-6.2.md
 - doc/Migration-Notes.md
 - doc/Models---Defining-a-Custom-Hydra-Model.textile
 - doc/Rake-Tasks-in-Hydra-Head.textile
+- doc/Recipe:-Add-full-text-indexing-to-your-app.md
 - doc/Reference.textile
 - doc/Solr-Schema.rdoc
 - doc/Tools-for-Developing-and-Testing-your-Application.textile
 - doc/Use-HTTP-POST-for-Solr-requests.md
+- doc/Using-rdf:resource-within-your-models.md
 - doc/YOUR-Hydra-Application---Initial-Modifications.textile
 - hydra.gemspec
 - lib/generators/hydra/install_generator.rb

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

@@ -1,131 +0,0 @@
-# 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: Create an OM Terminology for Page metadata
-
-Next we're going to add a Page model.  We'll start by creating another simple metadata datastream.  This time open ```app/models/datastreams/page_metadata.rb``` and add this content:
-```ruby
-class Datastreams::PageMetadata < ActiveFedora::OmDatastream
- 
-  set_terminology do |t|
-    t.root(path: "fields")
-    t.number index_as: :stored_searchable, type: :integer
-    t.text index_as: :stored_searchable
- 
-  end
- 
-  def self.xml_template
-    Nokogiri::XML.parse("<fields/>")
-  end
-
-  def prefix
-    '' # add a prefix for solr index terms if you need to namespace identical terms in multiple data streams 
-  end
-
-end
-
-```
-
-### Step 2: Create a Page model and make Pages aware of which Book they belong to
-
-Then we'll build a Page model that uses the datastream. Open ```app/models/page.rb``` and paste this in:
-
-```ruby
-class Page < ActiveFedora::Base
-  has_metadata 'descMetadata', type: Datastreams::PageMetadata
- 
-  belongs_to :book, :property=> :is_part_of
- 
-  has_attributes :number, datastream: 'descMetadata', multiple: false
-  has_attributes :text, datastream: 'descMetadata', multiple: false
-
-end
-```
-
-This is very similar to how our Book class looks, with the exception of the line ```belongs_to :book```.  This establishes a relationship between the book and page model nearly the same as you would do with ActiveRecord.  In ActiveFedora, we have to add the :property attribute as well.  Relationships are stored as RDF within the RELS-EXT datastream.  The :property is actually an RDF predicate. 
-
-### Step 3: 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, :property=> :is_part_of
-```
-
-### Step 4: 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("changeme:1")
- => #<Book pid:"changeme:1", title:"Anna Karenina", author:"Tolstoy, Leo"> 
-p = Page.new(number: 1, text: "Happy families are all alike; every unhappy family is unhappy in its own way.")
- => #<Page pid:"", number:1, text:"Happy families are all alike; every unhappy family is unhappy in its own way."> 
-p.book = b
- => #<Book pid:"changeme:1", title:"Anna Karenina", author:"Tolstoy, Leo"> 
-p.save
- => true 
-b.reload
- => #<Book pid:"changeme:1", title:"Anna Karenina", author:"Tolstoy, Leo"> 
-b.pages
- => [#<Page pid:"changeme:2", number:1, text:"Happy families are all alike; every unhappy family is unhappy in its own way.">] 
-```
-
-### Step 5: 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.  This metadata is written into the RELS-EXT datastream of your objects.  To see that content, either output it on the command line like this:
-
-```ruby
-puts p.datastreams["RELS-EXT"].to_rels_ext
-```
-Alternatively, look at the datastream in your browser at [http://localhost:8983/fedora/objects/changeme:2/datastreams/RELS-EXT/content](http://localhost:8983/fedora/objects/changeme:2/datastreams/RELS-EXT/content)  (You might need to change the pid in the URL if your page's pid isn't changeme:2)
-
-Either way, you should see RDF that looks like this:
-
-```text
-<?xml version="1.0" encoding="UTF-8"?>
-<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ns0="info:fedora/fedora-system:def/model#" xmlns:ns1="info:fedora/fedora-system:def/relations-external#">
-  <rdf:Description rdf:about="info:fedora/changeme:2">
-    <ns0:hasModel rdf:resource="info:fedora/afmodel:Page"/>
-    <ns1:isPartOf rdf:resource="info:fedora/changeme:1"/>
-  </rdf:Description>
-</rdf:RDF>
-```
-
-As you can see, it is creating rdf assertions of `info:fedora/fedora-system:def/relations-external#isPartOf` `info:fedora/changeme:1` and `info:fedora/fedora-system:def/model#hasModel` `info:fedora/afmodel:Page`.  
-
-The model assertion is created automatically based on the name of your ActiveFedora model (in this case, Page), but how did ActiveFedora know to use the predicate `info:fedora/fedora-system:def/relations-external#isPartOf` when your `belongs_to` specified a property called :is_part_of?
-
-In other words, how did we get from 
-
-```ruby
-belongs_to :book, :property=> :is_part_of
-```
-
-to ``info:fedora/fedora-system:def/relations-external#isPartOf`?
-
-The answer is that active-fedora has a config file that it uses to look up RDF predicates based on the property name you specify in your model.  By default, these predicates are read from the active-fedora gem, but you can override them by creating your own copy in config/predicate_mappings.yml in your own application.  To see the default mappings, look at active-fedora's default [predicate mappings YAML file] (https://github.com/projecthydra/active_fedora/blob/master/config/predicate_mappings.yml) on github.
-
-### Step 6: 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 book page model with relationship to the book model"
-```
-
-# Next Step
-Go on to **BONUS** [[Lesson: Adding Content Datastreams]] or 
-explore other [Dive into Hydra](Dive into Hydra#Bonus) tutorial bonus lessons.

data/doc/Lesson:-Reading-Hydra-rightsMetadata-XML.md

@@ -1,87 +0,0 @@
-This Tutorial is known to work with hydra-head version 6.0.0..  
-_Please update this wiki to reflect any other versions that have been tested._
-
-# Steps
-
-Given a book whose permissions look like this:
-```text
-puts book.permissions
-{:type=>"group", :access=>"discover", :name=>"group2"}
-{:type=>"group", :access=>"read", :name=>"group3"}
-{:type=>"group", :access=>"read", :name=>"group9"}
-{:type=>"group", :access=>"read", :name=>"group8"}
-{:type=>"user", :access=>"read", :name=>"user3"}
-{:type=>"user", :access=>"edit", :name=>"bob1"}
-{:type=>"user", :access=>"edit", :name=>"sally2"}
-```
-
-The permissions will be written into the rightsMetadata datstream like so
-```xml
-puts book.rightsMetadata.to_xml
-<rightsMetadata xmlns="http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1" version="0.1">
-  <copyright>
-    <human type="title"/>
-    <human type="description"/>
-    <machine type="uri"/>
-  </copyright>
-  <access type="discover">
-    <human/>
-    <machine>
-      <group>group2</group>
-    </machine>
-  </access>
-  <access type="read">
-    <human/>
-    <machine>
-      <group>group3</group>
-      <group>group9</group>
-      <group>group8</group>
-      <person>user3</person>
-    </machine>
-  </access>
-  <access type="edit">
-    <human/>
-    <machine>
-      <person>bob1</person>
-      <person>sally2</person>
-    </machine>
-  </access>
-  <embargo>
-    <human/>
-    <machine/>
-  </embargo>
-</rightsMetadata>
-```
-
-If we remove the nodes that aren't relevant to this lesson, the XML looks like this:
-
-```xml
-<rightsMetadata xmlns="http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1" version="0.1">
-  <access type="discover">
-    <machine>
-      <group>group2</group>
-    </machine>
-  </access>
-  <access type="read">
-    <machine>
-      <group>group3</group>
-      <group>group9</group>
-      <group>group8</group>
-      <person>user3</person>
-    </machine>
-  </access>
-  <access type="edit">
-    <machine>
-      <person>bob1</person>
-      <person>sally2</person>
-    </machine>
-  </access>
-</rightsMetadata>
-```
-
-As you can see, group ids are put into `<group>` nodes and user ids are put into `<person>` nodes.  The type of access being granted is decided by the @type attribute on the `<access>` nodes.
-
-The intermediary `<machine>` node is meant to allow you to insert human-readable information into the 'access/human' node while inserting the machine-readable assertions into 'access/machine' node.
-
-# Next Step
-Go on to [[Lesson: Indexing Hydra Rights Metadata into Solr]] or return to the [[Access Controls with Hydra]] tutorial.

data/doc/Lesson:-Use-Hydra-Access-Controls-to-Control-Access-to-Blacklight-show-Pages.md

@@ -1,37 +0,0 @@
-This Tutorial is known to work with hydra-head version 6.0.0.  
-_Please update this wiki to reflect any other versions that have been tested._
-
-# Goals
-
-# Explanation
-
-# Steps
-
-### Step 1: Enforce Show permissions on Blacklight search results
-
-When we turned off access controls as part of the [[Dive into Hydra]] tutorial, we commented out two lines.  The first line was turning on gated discovery.  We covered that in the previous lesson.  The other line was telling Blacklight to prevent unauthorized access to `show` views for items from your searches.  Let's enable that filter and see what it does.
-
-Open app/controllers/catalog_controller.rb and find these lines
-```ruby
-  # These before_filters apply the hydra access controls
-  # before_filter :enforce_show_permissions, :only=>:show
-```
-
-Uncomment the line with the `before_filter`
-```ruby
-  # These before_filters apply the hydra access controls
-  before_filter :enforce_show_permissions, :only=>:show
-```
-
-### Step 2: Test the enforcement of Show permissions on Blacklight search results
-
-In your browser, log into the application as yourself, run a search, and click on the link to a book that you only have `discover` access to.  Depending on what experiments you've done based on the previous lesson, you might have to go into the `rails console` and either create a new book that you have discover access to or modify an existing book to give you discover access.  
-
-You should have been redirected back to the search results page with a message reading _"You do not have sufficient access privileges to read this document, which has been marked private."_
-
-**Note:** For this example, it's important that you to _only_ have discover access (not `read` or `edit`) and that none of the groups you belong to have `read` or `edit` access either.  If you or one of your groups has `read` or `edit` access then you will see the book's `show` page instead of being redirected by the access controls.
-
-In the `rails console`, grant yourself 'read' or 'edit' access to the book and save the book.  Then in the browser you will be able to visit the `show` page for that book instead of being redirected like before.
-
-# Next Step
-Go on to [[Lesson: Use Hydra Access Controls and CanCan to decide whether to render a page]] or return to the [[Access Controls with Hydra]] tutorial.

data/doc/Lesson:-Using-Hydra-Access-Controls-and-CanCan-to-conditionally-render-part-of-a-page.md

@@ -1,29 +0,0 @@
-This Tutorial is known to work with hydra-head version 6.0.0.  
-_Please update this wiki to reflect any other versions that have been tested._
-
-# Goals
-
-# Explanation
-
-# Steps
-
-### Step: Use `can?` to conditionally render html on a page
-
-In `app/views/books/show.html.erb` find the code that's displaying the "Edit" and "Back" links at the bottom of the page.
-```erb
-<%= link_to 'Edit', edit_book_path(@book) %> |
-<%= link_to 'Back', books_path %>
-```
-
-Use an `if ... end` clause to only show the "Edit" link if the current user has permission to edit the current book.
-```erb
-<%- if can?(:edit, @book) %>
-  <%= link_to 'Edit', edit_book_path(@book) %> |
-<%- end %>
-<%= link_to 'Back', books_path %>
-```
-
-Now go into the `rails console` and give yourself `edit` access to one book but only `read` access for another.  Look at the show views for the two books.  You should see the "Edit" link on the book that you have permission to edit and you should not see the "Edit" link for the book that you do not have permission to edit.
-
-# Next Step
-Return to the [[Access Controls with Hydra]] tutorial.

data/doc/Lesson:-adding-content-datastreams.md

@@ -1,57 +0,0 @@
-# Goals
-* Add "file-bearing" Datastreams to models and objects
-* See where files are stored in Fedora objects and how to retrieve them
-
-# Explanation
-
-So far, we've only added datastreams that bear metadata.  Let's add a datastream that has some content to it.  For example, this could be a content datastream in our book model that is an image of the book's cover, or a datastream added to the page model that is an image or pdf of that actual page.
-
-In this case, we'll add a file datastream where we can store a pdf of a page.
-
-# Steps
-
-### Step 1: Add a "pageContent" file datastream to the Page model
-
-In our Page model ```app/models/page.rb```, we'll add the following line underneath our descMetadata datastream:
-
-```ruby
-has_file_datastream "pageContent"
-```
-
-Now we have a datastream called "pageContent" that can hold any kind of file we wish to add to it.  
-
-### Step 2: In the console, add a file to a Page object and save it
-
-To add the file to one of our page objects, open up the console again:
-
-```ruby
- > p = Page.find("changeme:2")
- => #<Page pid:"changeme:2", number:[1], text:["Happy families are all alike; every unhappy family is unhappy in its own way."]> 
- > p.datastreams.keys
- => ["DC", "RELS-EXT", "descMetadata", "pageContent"] 
-```
-
-Now you're ready to add the file.  Choose a file on your computer that you want to add as the "pageContent".  In the lines below we're pretending that the path to the file is "/Users/adamw/Desktop/page1.pdf".  Replace that with the correct local path for the file you want to use.
-
-```ruby
- > p.pageContent.content = File.open("../AK Page 4.pdf")
- => #<File:../AK Page 4.pdf>  
- > p.save
- => true
-```
-
-### Step 3: See where the file Datastream was saved in Fedora
-
-Now if you go to [[http://localhost:8983/fedora/objects/changeme:2/datastreams]], you'll see the pageContent datastream in Fedora.  Following the links to it will allow us to view or download the file we've added.
-
-### Step 4: Commit your changes
-
-Now that we've added a content datastream, it's a great time to commit to git:
-
-```bash
-git add .
-git commit -m "Created a content datastream"
-```
-
-# Next Step
-Proceed to **BONUS** [[Lesson: Generate Rails Scaffolding for Creating and Editing Books]] or explore other [Dive into Hydra](Dive into Hydra#bonus) tutorial bonus lessons.