ladder 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b9a1843bcc9f4d0ff1d006c83df08c744fb96c93
-  data.tar.gz: 2c7ed1fbff81db63f50bc3d55ae0999895b409b9
+  metadata.gz: 9239651dbb526c85d77203a89abcaf134ad353a4
+  data.tar.gz: e6c5b9a8bf16d50899a9d1ba9b5457d4bbd6c47b
 SHA512:
-  metadata.gz: c0544b5405bdee76c45d6fe64caa87dad1d4273d54e74bbc7c2779169222ef59570685b0e4d8230e9d2c9abf7965f14c9e4ff43ecb77f18406b53f873fec7a76
-  data.tar.gz: c962ddc67778d0ab32653ebead42aab4caff5e911850cf0e42adf2898bdfd5acc7a925c126526844221b7832d37ba95f4a7bdc331247b5dce4cf26ab6337eee5
+  metadata.gz: d05d9401849734c2292ad8a4d0e1caf252132ee75b76c5a8941c440e0c54297097a75bf6bdbee5f5509fad19eb0ba511ad4284bfb5d55b4ac190b08033898d5d
+  data.tar.gz: 2fa63d70f71f806d83212032b1acde913963ccdf07e4336ee05ab6a0d0b86aea45e2f1866dbc226a2ae3081cd04a3dc88d68def4952a559d1d64527ec77ad074

data/README.md

@@ -41,13 +41,13 @@ Or install it yourself as:
 * [Resources](#resources)
   * [Configuring Resources](#configuring-resources)
   * [Dynamic Resources](#dynamic-resources)
-* [Files](#files)
 * [Indexing for Search](#indexing-for-search)
+* [Files](#files)
+  * [Indexing Files](#indexing-files)
 
 ### Resources
 
-Much like ActiveTriples, Resources are the core of Ladder.  Resources implement all the functionality of a Mongoid::Document and an ActiveTriples::Resource.  To add Ladder integration for your model, require 
-and include the main module in your class:
+Much like ActiveTriples, Resources are the core of Ladder.  Resources implement all the functionality of a Mongoid::Document and an ActiveTriples::Resource.  To add Ladder integration for your model, require and include the main module in your class:
 
 ```ruby
 require 'ladder'
@@ -61,12 +61,13 @@ class Person
   property :description, predicate: RDF::DC.description
 end
 
-steve = Person.new
-steve.first_name = 'Steve'
-steve.description = 'Funny-looking'
-
+steve = Person.new(first_name: 'Steve', description: 'Funny-looking')
+=> #<Person _id: 542f0c124169720ea0000000, first_name: {"en"=>"Steve"}, description: {"en"=>"Funny-looking"}>
+	
 steve.as_document
- => {"_id"=>BSON::ObjectId('542f0c124169720ea0000000'), "first_name"=>{"en"=>"Steve"}, "description"=>{"en"=>"Funny-looking"}}
+=> {"_id"=>BSON::ObjectId('542f0c124169720ea0000000'),
+ "first_name"=>{"en"=>"Steve"},
+ "description"=>{"en"=>"Funny-looking"}}
 
 steve.as_jsonld
  # => {
@@ -249,8 +250,6 @@ Person.resource_class.base_uri
 => #<RDF::URI:0x3fecf69da274 URI:http://example.org/people>
 
 Person.configure base_uri: 'http://some.other.uri/'
-
-Person.resource_class.base_uri
 => "http://some.other.uri/"
 ```
 
@@ -268,12 +267,16 @@ class Person
 end
 
 steve = Person.new(first_name: 'Steve')
+=> #<Person _id: 546669234169720397000000, first_name: {"en"=>"Steve"}>
 
 steve.description
 => NoMethodError: undefined method 'description' for #<Person:0x007fb54eb1d0b8>
 
 steve.property :description, predicate: RDF::DC.description
+=> {:description=>"http://purl.org/dc/terms/description"}
+
 steve.description = 'Funny-looking'
+=> "Funny-looking"
 
 steve.as_document
 => {"_id"=>BSON::ObjectId('546669234169720397000000'),
@@ -340,73 +343,6 @@ steve.as_jsonld
 
 Note that due to the way Mongoid handles dynamic fields, dynamic properties **can not** be localized.  They can be any kind of literal, but they **can not** be a related object. They can, however, contain a reference to the related object's URI.
 
-### Files
-
-Files are bytestreams that store binary content using MongoDB's GridFS storage system.  They are still identifiable by a URI, and contain technical metadata about the File's contents.
-
-```ruby
-class Person
-  include Ladder::Resource
-
-  configure type: RDF::FOAF.Person
-
-  property :first_name, predicate: RDF::FOAF.name
-  property :thumbnails,  predicate: RDF::FOAF.depiction, class_name: 'Image', inverse_of: nil
-end
-
-class Image
-  include Ladder::File
-end
-```
-
-Similar to Resources, using `#property` as above will create a has-many relation for a File by default; however, because Files must be the target of a one-way relation, the `inverse_of: nil` option is required. Note that due to the way GridFS is designed, Files **can not** be embedded.
-
-```ruby
-steve = Person.new(first_name: 'Steve')
-thumb = Image.new(file: open('http://some.image/pic.jpg'))
-steve.thumbnails << thumb
-
-steve.as_jsonld
- # => {
- #     "@context": {
- #         "foaf": "http://xmlns.com/foaf/0.1/"
- #     },
- #     "@id": "http://example.org/people/549d83c64169720b32010000",
- #     "@type": "foaf:Person",
- #     "foaf:depiction": {
- #         "@id": "http://example.org/images/549d83c24169720b32000000"
- #     },
- #     "foaf:name": {
- #         "@language": "en",
- #         "@value": "Steve"
- #     }
- # }
-
-steve.save
- # ... File is stored to GridFS ...
-=> true
-```
-
-Files have all the attributes of a GridFS file, and the stored binary content is accessed using `#data`.
-
-```ruby
-thumb.reload
-thumb.as_document
-=> {"_id"=>BSON::ObjectId('549d86184169720b6a000000'),
- "length"=>59709,
- "chunkSize"=>4194304,
- "uploadDate"=>2014-12-26 16:00:29 UTC,
- "md5"=>"0d4a486e2cd71c51b7a92cfe96f29324",
- "contentType"=>"image/jpeg",
- "filename"=>"549d86184169720b6a000000/open-uri20141226-2922-u66ap6"}
-
-thumb.length
-=> 59709
-
-thumb.data
-=> # ... binary data ...
-```
-
 ### Indexing for Search
 
 You can also index your model classes for keyword searching through ElasticSearch by mixing in the Ladder::Searchable module:
@@ -422,9 +358,8 @@ class Person
   property :description, predicate: RDF::DC.description
 end
 
-kimchy = Person.new
-kimchy.first_name = 'Shay'
-kimchy.description = 'Real genius'
+kimchy = Person.new(first_name: 'Shay', description: 'Real genius')
+=> #<Person _id: 543b457b41697231c5000000, first_name: {"en"=>"Shay"}, description: {"en"=>"Real genius"}>
 ```
 
 In order to enable indexing, call the `#index_for_search` method on the class:
@@ -516,10 +451,14 @@ end
 Person.property :projects, predicate: RDF::FOAF.made, class_name: 'Project'
 
 es = Project.new(project_name: 'ElasticSearch', description: 'You know, for search')
+=> #<Project _id: 544562c24169728b4e010000, project_name: {"en"=>"ElasticSearch"}, description: {"en"=>"You know, for search"}, developer_ids: nil>
+
 es.developers << kimchy
+=> [#<Person _id: 543b457b41697231c5000000, first_name: {"en"=>"Shay"}, description: {"en"=>"Real genius"}, project_ids: [BSON::ObjectId('544562c24169728b4e010000')]>]
 
 Person.index_for_search as: :jsonld, related: true
 => :as_indexed_json
+
 Project.index_for_search as: :jsonld, related: true
 => :as_indexed_json
 
@@ -593,6 +532,7 @@ es.as_indexed_json
 
 Person.index_for_search as: :qname, related: true
 => :as_indexed_json
+
 Project.index_for_search as: :qname, related: true
 => :as_indexed_json
 
@@ -647,6 +587,175 @@ es.as_indexed_json
  # }
 ```
 
+### Files
+
+Files are bytestreams that store binary content using MongoDB's GridFS storage system.  They are still identifiable by a URI, and contain technical metadata about the File's contents.
+
+```ruby
+class Person
+  include Ladder::Resource
+
+  configure type: RDF::FOAF.Person
+
+  property :first_name, predicate: RDF::FOAF.name
+  property :thumbnails, predicate: RDF::FOAF.depiction, class_name: 'Image', inverse_of: nil
+end
+
+class Image
+  include Ladder::File
+end
+```
+
+Similar to Resources, using `#property` as above will create a has-many relation for a File by default; however, because Files must be the target of a one-way relation, the `inverse_of: nil` option is required. Note that due to the way GridFS is designed, Files **can not** be embedded.
+
+```ruby
+steve = Person.new(first_name: 'Steve')
+=> #<Person _id: 549d83c64169720b32010000, first_name: {"en"=>"Steve"}>
+
+thumb = Image.new(file: open('http://some.image/pic.jpg'))
+=> #<Image _id: 549d83c24169720b32000000>
+
+steve.thumbnails << thumb
+=> [#<Image _id: 549d83c24169720b32000000, >]
+
+steve.as_jsonld
+ # => {
+ #     "@context": {
+ #         "foaf": "http://xmlns.com/foaf/0.1/"
+ #     },
+ #     "@id": "http://example.org/people/549d83c64169720b32010000",
+ #     "@type": "foaf:Person",
+ #     "foaf:depiction": {
+ #         "@id": "http://example.org/images/549d83c24169720b32000000"
+ #     },
+ #     "foaf:name": {
+ #         "@language": "en",
+ #         "@value": "Steve"
+ #     }
+ # }
+
+steve.save
+ # ... File is stored to GridFS ...
+=> true
+```
+
+Files have all the attributes of a GridFS file, and the stored binary content is accessed using `#data`.
+
+```ruby
+thumb.reload
+=> #<Image _id: 549d86184169720b6a000000, >
+
+thumb.as_document
+=> {"_id"=>BSON::ObjectId('549d86184169720b6a000000'),
+ "length"=>59709,
+ "chunkSize"=>4194304,
+ "uploadDate"=>2014-12-26 16:00:29 UTC,
+ "md5"=>"0d4a486e2cd71c51b7a92cfe96f29324",
+ "contentType"=>"image/jpeg",
+ "filename"=>"549d86184169720b6a000000/open-uri20141226-2922-u66ap6"}
+
+thumb.length
+=> 59709
+
+thumb.data
+=> # ... binary data ...
+```
+
+#### Indexing Files
+
+Files that contain textual content (eg. HTML, PDF, ePub, DOC, etc) can be automatically indexed when they are persisted, again just by mixing in the Ladder::Searchable module (there is no need to call `#index_for_search` on the class).  Note that this requires the [Mapper Attachments Plugin for Elasticsearch](https://github.com/elasticsearch/elasticsearch-mapper-attachments) to be installed.
+
+```ruby
+class OCR
+  include Ladder::File
+  include Ladder::Searchable
+end
+
+pdf = OCR.new(file: open('http://some.location/ocr.pdf'))
+=> #<OCR _id: 54add77a4169721c23000000>
+
+pdf.save
+=> true
+
+results = OCR.search 'Moomintroll'
+ # => #<Elasticsearch::Model::Response::Response:0x007fa2ca82a9f0
+ # @klass=[PROXY] OCR,
+ # @search=
+ # #<Elasticsearch::Model::Searching::SearchRequest:0x007fa2ca830a58
+ #  @definition={:index=>"ocrs", :type=>"ocr", :q=>"Moomintroll"},
+ #  @klass=[PROXY] OCR,
+ #  @options={}>>
+ 
+results.count
+=> 1
+
+results.records.first == pdf
+=> true
+
+results.records.first.as_document
+=> {"_id"=>BSON::ObjectId('54add77a4169721c23000000'),
+ "length"=>12941,
+ "chunkSize"=>4194304,
+ "uploadDate"=>2015-01-08 01:03:54 UTC,
+ "md5"=>"831a47b953d6e11d17cee7de9abd73c4",
+ "contentType"=>"application/pdf",
+ "filename"=>"54add77a4169721c23000000/ocr.pdf"}
+
+results.records.first.data
+=> # ... binary data ...
+```
+
+This can be useful if you want to retrieve a File by searching for the textual content that it contains.  Note the use of `#records` to access the Ladder::File instances directly ([see here for more information](https://github.com/elasticsearch/elasticsearch-rails/tree/master/elasticsearch-model#search-results-as-database-records)).  However, if you want to get information about the file characteristics (including the extracted textual content), you can use a modified search query:
+
+```ruby
+results = OCR.search 'Moomintroll', fields: '*'
+ # => #<Elasticsearch::Model::Response::Response:0x007fc36cadaa20
+ # @klass=[PROXY] OCR,
+ # @search=
+ # #<Elasticsearch::Model::Searching::SearchRequest:0x007fc36cadab10
+ #  @definition={:index=>"ocrs", :type=>"ocr", :body=>{:query=>{:query_string=>{:query=>"Moomintroll"}}, :fields=>"*"}},
+ #  @klass=[PROXY] OCR,
+ #  @options={}>>
+ 
+results.count
+=> 1
+
+results.first.fields
+=> {
+ "file.content_type"=>["application/pdf"],
+ "file.keywords"=>[""],
+ "file"=>
+  ["\nAnd so Moomintroll was helplessly thrown out into a strange and dangerous world and \ndropped up to his ears in the first snowdrift of his experience. It felt unpleasantly prickly \nto his velvet skin, but at the same time his nose caught a new smell. It was a more \nserious smell than any he had met before, and slightly frightening. But it made him wide \nawake and greatly interested.\n\n\n"],
+ "file.date"=>["2014-12-19T15:32:58Z"],
+ "file.title"=>["Untitled"]}
+```
+
+In this case, the `#fields` Hash contains all of the technical metadata obtained by Elasticsearch during indexing. Note that this is **not the same** as the metadata stored by GridFS (with the possible exception of content type). Finally, we can also provide contextual highlighting for search results by using a slightly more complex search query:
+
+```ruby
+results = OCR.search query: { query_string: { query: 'his' } }, highlight: { fields: { file: {} } }
+ # => #<Elasticsearch::Model::Response::Response:0x007fd653dc8b48
+ # @klass=[PROXY] OCR,
+ # @search=
+ # #<Elasticsearch::Model::Searching::SearchRequest:0x007fd653dc8b48
+ #  @definition={:index=>"ocrs", :type=>"ocr", :body=>{:query=>{:query_string=>"Moomintroll"},
+ #  :highlight=>{:fields=>{:file=>{}}}}},
+ #  @klass=[PROXY] OCR,
+ #  @options={}>>
+ 
+results.count
+=> 1
+
+results.first.highlight.file.count
+=> 2
+
+results.first.highlight.file
+=> [" <em>his</em> ears in the first snowdrift of <em>his</em> experience. It felt unpleasantly prickly \nto <em>his</em> velvet skin",
+    ", but at the same time <em>his</em> nose caught a new smell. It was a more \nserious smell than any he had met"]
+```
+
+More information about performing highlighting queries is available in the [Elasticsearch documentation](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-highlighting.html).
+
 ## Contributing
 
 Anyone and everyone is welcome to contribute.  Go crazy.
@@ -670,4 +779,4 @@ Many thanks to Christopher Knight [@NomadicKnight](https://twitter.com/Nomadic_K
 ## License
 
 Apache License Version 2.0
-http://apache.org/licenses/LICENSE-2.0.txt
+http://apache.org/licenses/LICENSE-2.0.txt

data/ladder.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.platform      = Gem::Platform::RUBY
   spec.authors       = "MJ Suhonos"
   spec.email         = "mj@suhonos.ca"
-  spec.summary       = %q{Opinionated ActiveModel framework.}
-  spec.description   = %q{Ladder is a metadata framework for RDF modelling, persistence, and full-text indexing.}
+  spec.summary       = %q{ActiveModel Linked Data framework.}
+  spec.description   = %q{Dynamic framework for Linked Data modelling, persistence, and full-text indexing.}
   spec.homepage      = "https://github.com/ladder/ladder"
   spec.license       = "APACHE2"
   spec.required_ruby_version     = '>= 1.9.3'

data/lib/ladder/file.rb

@@ -25,10 +25,15 @@ module Ladder::File
   ##
   # Make save behave like Mongoid::Document as much as possible
   def save
+    # FIXME: this raises on a freshly-retrieved document; should either set @file or catch @grid_file
     raise Mongoid::Errors::InvalidValue.new(IO, NilClass) if file.nil?
 
-    attributes[:content_type] = file.content_type if file.respond_to? :content_type
-    @grid_file ? @grid_file.save : !! @grid_file = self.class.grid.put(file, attributes.symbolize_keys)
+    persisted? ? run_callbacks(:update) : run_callbacks(:create)
+
+    run_callbacks(:save) do
+      attributes[:content_type] = file.content_type if file.respond_to? :content_type
+      @grid_file ? @grid_file.save : !! @grid_file = self.class.grid.put(file, attributes.symbolize_keys)
+    end
   end
 
   ##

data/lib/ladder/searchable.rb

@@ -5,83 +5,14 @@ require 'elasticsearch/model/callbacks'
 module Ladder::Searchable
   extend ActiveSupport::Concern
 
+  autoload :Resource, 'ladder/searchable/resource'
+  autoload :File,     'ladder/searchable/file'
+
   included do
     include Elasticsearch::Model
     include Elasticsearch::Model::Callbacks
-  end
-
-  ##
-  # Generate a qname-based JSON representation
-  #
-  def as_qname(opts = {})
-    qname_hash = type.empty? ? {} : {rdf: {type: type.first.pname }}
-
-    resource_class.properties.each do |field_name, property|
-      ns, name = property.predicate.qname
-      qname_hash[ns] ||= Hash.new
-
-      object = self.send(field_name)
-
-      if relations.keys.include? field_name
-        if opts[:related]
-          qname_hash[ns][name] = object.to_a.map { |obj| obj.as_qname }
-        else
-          qname_hash[ns][name] = object.to_a.map { |obj| "#{obj.class.name.underscore.pluralize}:#{obj.id}" }
-        end
-      elsif fields.keys.include? field_name
-        qname_hash[ns][name] = read_attribute(field_name)
-      end
-    end
-
-    qname_hash
-  end
-
-  private
-
-    ##
-    # Return a framed, compacted JSON-LD representation
-    # by embedding related objects from the graph
-    #
-    # NB: Will NOT embed related objects with same @type. Spec under discussion, see https://github.com/json-ld/json-ld.org/issues/110
-    def as_framed_jsonld
-      json_hash = as_jsonld related: true
-      context = json_hash['@context']
-      frame = {'@context' => context, '@type' => type.first.pname}
-      JSON::LD::API.compact(JSON::LD::API.frame(json_hash, frame), context)
-    end
-    
-    ##
-    # Force autosave of related documents using Mongoid-defined methods
-    # Required for explicit autosave prior to after_update index callbacks
-    #
-    def autosave
-      methods.select{|i| i[/autosave_documents/] }.each{|m| send m}
-    end
-
-  module ClassMethods
-
-    ##
-    # Specify type of serialization to use for indexing
-    #
-    def index_for_search(opts = {})
-      case opts[:as]
-      when :jsonld
-        if opts[:related]
-          define_method(:as_indexed_json) { |opts = {}| autosave; as_framed_jsonld }
-        else
-          define_method(:as_indexed_json) { |opts = {}| as_jsonld }
-        end
-      when :qname
-        if opts[:related]
-          define_method(:as_indexed_json) { |opts = {}| as_qname related: true }
-        else
-          define_method(:as_indexed_json) { |opts = {}| as_qname }
-        end
-      else
-        define_method(:as_indexed_json) { |opts = {}| as_json(except: ['id', '_id']) }
-      end
-    end
 
-  end
-    
+    include Ladder::Searchable::Resource if self.ancestors.include? Ladder::Resource
+    include Ladder::Searchable::File     if self.ancestors.include? Ladder::File
+  end  
 end

data/lib/ladder/searchable/file.rb

@@ -0,0 +1,30 @@
+module Ladder::Searchable::File
+  extend ActiveSupport::Concern
+
+  included do
+    # Index binary content using Elasticsearch mapper attachment plugin
+    # https://github.com/elasticsearch/elasticsearch-mapper-attachments
+    mapping _source: { enabled: false } do
+      indexes :file, type: 'attachment', fields: {
+        file: { store: true },
+        title: { store: true },
+        date: { store: true },
+        author: { store: true },
+        keywords: { store: true },
+        content_type: { store: true },
+        content_length: { store: true },
+        language: { store: true }
+      }
+    end
+
+    # Explicitly set mapping definition on index
+    self.__elasticsearch__.create_index!
+  end
+
+  ##
+  # Return a Base64-encoded copy of data
+  def as_indexed_json(opts = {})
+    { file: Base64.encode64(data) }
+  end
+
+end

data/lib/ladder/searchable/resource.rb

@@ -0,0 +1,78 @@
+module Ladder::Searchable::Resource
+  extend ActiveSupport::Concern
+
+  ##
+  # Generate a qname-based JSON representation
+  #
+  def as_qname(opts = {})
+    qname_hash = type.empty? ? {} : {rdf: {type: type.first.pname }}
+
+    resource_class.properties.each do |field_name, property|
+      ns, name = property.predicate.qname
+      qname_hash[ns] ||= Hash.new
+
+      object = self.send(field_name)
+
+      if relations.keys.include? field_name
+        if opts[:related]
+          qname_hash[ns][name] = object.to_a.map { |obj| obj.as_qname }
+        else
+          qname_hash[ns][name] = object.to_a.map { |obj| "#{obj.class.name.underscore.pluralize}:#{obj.id}" }
+        end
+      elsif fields.keys.include? field_name
+        qname_hash[ns][name] = read_attribute(field_name)
+      end
+    end
+
+    qname_hash
+  end
+
+  private
+
+    ##
+    # Return a framed, compacted JSON-LD representation
+    # by embedding related objects from the graph
+    #
+    # NB: Will NOT embed related objects with same @type. Spec under discussion, see https://github.com/json-ld/json-ld.org/issues/110
+    def as_framed_jsonld
+      json_hash = as_jsonld related: true
+      context = json_hash['@context']
+      frame = {'@context' => context, '@type' => type.first.pname}
+      JSON::LD::API.compact(JSON::LD::API.frame(json_hash, frame), context)
+    end
+    
+    ##
+    # Force autosave of related documents using Mongoid-defined methods
+    # Required for explicit autosave prior to after_update index callbacks
+    #
+    def autosave
+      methods.select{|i| i[/autosave_documents/] }.each{|m| send m}
+    end
+
+  module ClassMethods
+
+    ##
+    # Specify type of serialization to use for indexing
+    #
+    def index_for_search(opts = {})
+      case opts[:as]
+      when :jsonld
+        if opts[:related]
+          define_method(:as_indexed_json) { |opts = {}| autosave; as_framed_jsonld }
+        else
+          define_method(:as_indexed_json) { |opts = {}| as_jsonld }
+        end
+      when :qname
+        if opts[:related]
+          define_method(:as_indexed_json) { |opts = {}| as_qname related: true }
+        else
+          define_method(:as_indexed_json) { |opts = {}| as_qname }
+        end
+      else
+        define_method(:as_indexed_json) { |opts = {}| as_json(except: [:id, :_id]) }
+      end
+    end
+
+  end
+    
+end

data/lib/ladder/version.rb

@@ -1,3 +1,3 @@
 module Ladder
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/spec/ladder/file/searchable_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Ladder::Searchable::File do
+  before do
+    Mongoid.load!('mongoid.yml', :development)
+    Mongoid.logger.level = Moped.logger.level = Logger::DEBUG
+    Mongoid.purge!
+
+    Elasticsearch::Model.client = Elasticsearch::Client.new host: 'localhost:9200', log: true
+    Elasticsearch::Model.client.indices.delete index: '_all'
+
+    LADDER_BASE_URI = 'http://example.org'
+
+    class Datastream
+      include Ladder::File
+      include Ladder::Searchable
+    end
+  end
+
+  shared_context 'searchable' do
+    before do
+      subject.save
+      Elasticsearch::Model.client.indices.flush
+    end
+
+    it 'should exist in the index' do
+      results = subject.class.search('Moomin*')
+      expect(results.count).to eq 1
+      expect(results.first.id).to eq subject.id.to_s
+    end
+    
+    it 'should contain full-text content' do
+      results = subject.class.search 'Moomin*', fields: '*'
+      expect(results.count).to eq 1
+      expect(results.first.fields.file.first).to include 'Moomin'
+    end
+  end
+
+  context 'with data from file' do
+    TEST_FILE = './spec/shared/moomin.pdf'
+
+    let(:subject) { Datastream.new file: open(TEST_FILE) }
+    let(:source) { open(TEST_FILE).read } # ASCII-8BIT (binary)
+
+    it_behaves_like 'a File'
+
+    include_context 'searchable'
+  end
+
+  context 'with data from string after creation' do
+    data = "And so Moomintroll was helplessly thrown out into a strange and dangerous world and dropped up to his ears in the first snowdrift of his experience. It felt unpleasantly prickly to his velvet skin, but at the same time his nose caught a new smell. It was a more serious smell than any he had met before, and slightly frightening. But it made him wide awake and greatly interested."
+    
+    let(:subject) { Datastream.new }
+    let(:source) { data } # UTF-8 (string)
+
+    before do
+      subject.file = StringIO.new(source)
+    end
+
+    it_behaves_like 'a File'
+
+    include_context 'searchable'
+  end
+
+  after do
+    Object.send(:remove_const, "Datastream") if Object
+  end
+end

data/spec/ladder/{searchable_spec.rb → resource/searchable_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Ladder::Searchable do
+describe Ladder::Searchable::Resource do
   before do
     Mongoid.load!('mongoid.yml', :development)
     Mongoid.logger.level = Moped.logger.level = Logger::DEBUG

data/spec/shared/file.rb

@@ -38,7 +38,7 @@ shared_examples 'a File' do
 
   describe '#data' do
     it 'should return a data stream' do
-      expect(subject.data).to eq source
+      expect(subject.data).to eq source.force_encoding(subject.data.encoding)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ladder
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - MJ Suhonos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-06 00:00:00.000000000 Z
+date: 2015-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
@@ -178,7 +178,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-description: Ladder is a metadata framework for RDF modelling, persistence, and full-text
+description: Dynamic framework for Linked Data modelling, persistence, and full-text
   indexing.
 email: mj@suhonos.ca
 executables: []
@@ -199,13 +199,16 @@ files:
 - lib/ladder/resource.rb
 - lib/ladder/resource/dynamic.rb
 - lib/ladder/searchable.rb
+- lib/ladder/searchable/file.rb
+- lib/ladder/searchable/resource.rb
 - lib/ladder/version.rb
 - logo.png
 - mongoid.yml
+- spec/ladder/file/searchable_spec.rb
 - spec/ladder/file_spec.rb
 - spec/ladder/resource/dynamic_spec.rb
+- spec/ladder/resource/searchable_spec.rb
 - spec/ladder/resource_spec.rb
-- spec/ladder/searchable_spec.rb
 - spec/shared/file.rb
 - spec/shared/moomin.pdf
 - spec/shared/resource.rb
@@ -233,12 +236,13 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Opinionated ActiveModel framework.
+summary: ActiveModel Linked Data framework.
 test_files:
+- spec/ladder/file/searchable_spec.rb
 - spec/ladder/file_spec.rb
 - spec/ladder/resource/dynamic_spec.rb
+- spec/ladder/resource/searchable_spec.rb
 - spec/ladder/resource_spec.rb
-- spec/ladder/searchable_spec.rb
 - spec/shared/file.rb
 - spec/shared/moomin.pdf
 - spec/shared/resource.rb