fedora_lens 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af9796406a65d286343ded62b45876a28f2c542f
+  data.tar.gz: c1237758ac4f5fc1131f9add45cbddf5d657c840
+SHA512:
+  metadata.gz: 5bfca9e2b65760e3674ceb986153df14f6de8885c320287cd2367ade51aa1ca78cb0d97a824b479871df63e298442b4b49d590c6469b539984a00704cd440d2e
+  data.tar.gz: 9b4fe962ae9a7dc2e70fc9533129b2247e10acd14554247b3ebcdfa25c051f6620f779eadab9f4a3e7c1d4455af4e92c9c57e7e5cd989bf117102d805e3cfbfe

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle
+/fedora/*.war
+/fcrepo4-data/
+Gemfile.lock
+tags
+jetty
+tmp
+pkg

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p353

data/.travis.yml

@@ -0,0 +1,10 @@
+notifications:
+  email: false
+
+rvm:
+  - 2.1.0
+
+env:
+  global:
+    - NOKOGIRI_USE_SYSTEM_LIBRARIES=true
+

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem "ldp", github: 'cbeer/ldp'
+gem 'jettywrapper'
+
+group :development, :test do
+  gem 'byebug' unless ENV['TRAVIS']
+end

data/README.md

@@ -0,0 +1,29 @@
+## Usage
+
+Download and extract Fedora 4:
+```bash
+rake jetty:download
+rake jetty:unzip
+```
+
+Start Fedora:
+```bash
+rake jetty:start
+```
+
+```ruby
+# bundle console
+require 'test_class'
+b = TestClass.new(title: "New resource")
+b.uri
+b.save
+b.id
+a = TestClass.find(b.id)
+a.attributes
+a.primary_id = "some id"
+a.save
+b.reload
+b.attributes
+c = TestClass.create(title: "created resource")
+c.id
+```

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+Bundler::GemHelper.install_tasks
+
+
+RSpec::Core::RakeTask.new(:spec)
+
+ZIP_URL = "https://github.com/projecthydra/hydra-jetty/archive/fedora-4a4.zip"
+require 'jettywrapper'
+
+task default: :ci
+
+task ci: 'jetty:unzip' do
+  jetty_params = Jettywrapper.load_config('test')
+  error = Jettywrapper.wrap(jetty_params) do
+    Rake::Task[:spec].invoke
+  end
+  raise "test failures: #{error}" if error
+end

data/config/jetty.yml

@@ -0,0 +1,6 @@
+default:
+  jetty_port: <%= ENV['TEST_JETTY_PORT'] || 8983 %>
+  startup_wait: 90
+  java_opts:
+    - "-Xmx256m" 
+    - "-XX:MaxPermSize=128m"

data/demo.rb

@@ -0,0 +1,76 @@
+require 'fedora_lens'
+require 'active_support/core_ext/string'
+
+module GenericFileRdfDatastream
+  def self.mappings
+    {
+      part_of:        [RDF::DC.isPartOf],
+      resource_type:  [RDF::DC.type],
+      part_of:        [RDF::DC.isPartOf],
+      resource_type:  [RDF::DC.type],
+      title:          [RDF::DC.title],
+      creator:        [RDF::DC.creator],
+      contributor:    [RDF::DC.contributor],
+      description:    [RDF::DC.description],
+      tag:            [RDF::DC.relation],
+      rights:         [RDF::DC.rights],
+      publisher:      [RDF::DC.publisher],
+      date_created:   [RDF::DC.created],
+      date_uploaded:  [RDF::DC.dateSubmitted],
+      date_modified:  [RDF::DC.modified],
+      subject:        [RDF::DC.subject],
+      language:       [RDF::DC.language],
+      identifier:     [RDF::DC.identifier],
+      based_near:     [RDF::FOAF.based_near],
+      related_url:    [RDF::RDFS.seeAlso],
+    }
+  end
+end
+
+module Metadata
+  extend ActiveSupport::Concern
+
+  included do
+    # has_metadata "descMetadata", type: GenericFileRdfDatastream
+    # has_metadata "properties", type: PropertiesDatastream
+    # has_file_datastream "content", type: FileContentDatastream
+    # has_file_datastream "thumbnail"
+
+    # has_attributes :relative_path, :depositor, :import_url, datastream: :properties, multiple: false
+    has_attributes :date_uploaded, :date_modified, datastream: :descMetadata, multiple: false 
+    has_attributes :related_url, :based_near, :part_of, :creator,
+      :contributor, :title, :tag, :description, :rights,
+      :publisher, :date_created, :subject,
+      :resource_type, :identifier, :language, datastream: :descMetadata, multiple: true
+  end
+
+  def descMetadata
+    {path: [RDF::URI.new('http://digitalcurationexperts.com/example#descMetadata'),
+      FedoraLens::Lenses.single,
+      FedoraLens::Lenses.load_or_build_orm],
+      type: GenericFileRdfDatastream}
+  end
+  def properties
+    {path: [RDF::URI.new('http://digitalcurationexperts.com/example#properties'),
+      FedoraLens::Lenses.single,
+      FedoraLens::Lenses.load_or_build_orm],
+      type: PropertiesDatastream}
+  end
+  def has_attributes(*attributes)
+    opts = attributes.pop
+    attributes.each do |name|
+      path = opts[:datastream][:path] + opts[:datastream][:type].mappings[name]
+      path << FedoraLens::Lenses.single unless opts[:multiple]
+      attribute name, path
+    end
+  end
+end
+
+class Example
+  include FedoraLens
+  include FedoraLens::Lenses
+  extend Metadata
+  has_attributes :date_uploaded, datastream: descMetadata, multiple: true
+  has_attributes :title, datastream: descMetadata, multiple: true
+  # has_attributes :relative_path, datastream: properties, multiple: false
+end

data/fedora_lens.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fedora_lens/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fedora_lens"
+  spec.version       = FedoraLens::VERSION
+  spec.authors       = ["Justin Coyne", "Brian Maddy"]
+  spec.email         = ["justin@curationexperts.com"]
+  spec.summary       = %q{A client for Fedora Commons Repository (fcrepo) version 4}
+  spec.description   = %q{}
+  spec.homepage      = ""
+  spec.license       = "APACHE2"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "childprocess"
+
+  spec.add_dependency 'rdf-turtle', '~> 1.1.2'
+  spec.add_dependency 'activemodel', '>= 4.0.2', "< 5.0"
+  spec.add_dependency 'nokogiri', '~> 1.6.1'
+  spec.add_dependency 'ldp'
+end

data/lib/fedora_lens/errors.rb

@@ -0,0 +1,7 @@
+module FedoraLens
+  # generic exception class
+  class FedoraLensError < StandardError; end
+  # raised when a resource can't be saved
+  class RecordNotSaved < FedoraLensError; end
+  class AttributeNotSupportedError < FedoraLensError; end
+end

data/lib/fedora_lens/lens.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/hash'
+
+module FedoraLens
+  class Lens < ActiveSupport::HashWithIndifferentAccess
+    def get(source)
+      self[:get].call(source)
+    end
+    def put(source, value)
+      self[:put].call(source, value)
+    end
+    def create(value)
+      self[:create].call(value)
+    end
+  end
+end

data/lib/fedora_lens/lens_tests.rb

@@ -0,0 +1,60 @@
+module FedoraLens
+  module LensTests
+    # See page 6 of the manual for the Harmony language for a description
+    # on how lenses work
+    # http://www.seas.upenn.edu/~harmony/manual.pdf
+    # @example testing a lens that converts xml to a dom and back
+    #   test_lens(lens, Nokogiri::XML("<a/>"), Nokogiri::XML("<b/>") do |v|
+    #     v.to_xml
+    #   end
+    # @param  [lens]
+    #   the lens to test
+    # @param  [value]
+    #   the value to test with (when calling put)
+    # @param  [source]
+    #   the source document this lens operates on
+    # @yield  [converter]
+    #   a block that converts the value from the lens to something that can be
+    #   compared with #== (defaults to the identity function)
+    # @yieldparam [value or source]
+    #   a value that will be compared
+    def test_lens(lens, source, value, &block)
+      test_lens_get_put(lens, source, &block)
+      test_lens_put_get(lens, source, value, &block)
+      test_lens_create_get(lens, value, &block)
+    end
+
+    def test_lens_get_put(lens, source)
+      it "is well-behaved (GetPut: put(source, get(source)) == source)" do
+        converted = lens.put(source, lens.get(source))
+        if block_given?
+          yield(converted).should eq yield(source)
+        else
+          converted.should eq source
+        end
+      end
+    end
+
+    def test_lens_put_get(lens, source, value)
+      it "is well-behaved (PutGet: get(put(source, value)) == value)" do
+        converted = lens.get(lens.put(source, value))
+        if block_given?
+          yield(converted).should eq yield(value)
+        else
+          converted.should eq value
+        end
+      end
+    end
+
+    def test_lens_create_get(lens, value)
+      it "is well-behaved (CreateGet: get(create(value)) == value)" do
+        created = lens.get(lens.create(value))
+        if block_given?
+          yield(created).should eq yield(value)
+        else
+          created.should eq value
+        end
+      end
+    end
+  end
+end

data/lib/fedora_lens/lenses.rb

@@ -0,0 +1,149 @@
+require 'fedora_lens/lens'
+
+module FedoraLens
+  module Lenses
+    # We would like to use lenses like this: Lenses.at_css.get(...)
+    # Using a simple hash is gross because calls are like this: Lenses.at_css[:get].call(...)
+    # If we use a Module, we can't pass in parameters to build a more specific lens like
+    # in the case of the at_css lens.
+    # If we use a class, we need to call it like this: Lenses::AtCss.new('path').get(...)
+    # that's a lot of ".new" that just becomes line noise
+    # Classes don't seem to close over their environment as a function would (not sure why...)
+    # so we can create anonymous classes with functions
+    # Instead, we're just adding the helper functions to a simple hash.
+
+    class << self
+      def single
+        Lens[
+          get: :first.to_proc,
+          put: lambda {|source, value| source[0] = value; source},
+          create: lambda {|value| [value]}
+        ]
+      end
+
+      def literal_to_string
+        Lens[
+          get: :to_s.to_proc,
+          put: lambda do |source, value|
+            if source.is_a?(RDF::Literal)
+              RDF::Literal.new(value, language: source.language, datatype: source.datatype)
+            else
+              RDF::Literal.new(value)
+            end
+          end
+        ]
+      end
+
+      def hash_update
+        Lens[
+          get: lambda {|hash| hash[key]},
+          put: lambda {|hash, pair| hash.merge(pair[0] => pair[1])}
+        ]
+      end
+
+      def orm_to_hash(name_to_lens)
+        Lens[
+          get: lambda do |orm|
+            name_to_lens.reduce({}) do |hash, pair|
+              key, lens = pair
+              hash.merge(key => lens.get(orm))
+            end
+          end,
+          put: lambda do |orm, hash|
+            name_to_lens.each do |pair|
+              key, lens = pair
+              lens.put(orm, hash[key])
+            end
+            orm
+          end
+        ]
+      end
+
+      def as_dom
+        Lens[
+          # TODO figure out a memoizing strategy so we don't parse multiple times
+          get: lambda {|xml| Nokogiri::XML(xml)},
+          put: lambda {|xml, value| value.to_xml},
+          create: lambda {|value| value.to_xml}
+        ]
+      end
+
+      def at_css(selector)
+        Lens[
+          get: lambda {|doc| doc.at_css(selector).content},
+          put: lambda {|doc, value| 
+          doc.at_css(selector).content = value; doc},
+          # can't do a css create because we don't know the structure
+        ]
+      end
+
+      def get_predicate(predicate)
+        Lens[
+          get: lambda do |orm|
+            orm.value(predicate)
+          end,
+          put: lambda do |orm, values|
+            orm.graph.delete([orm.resource.subject_uri, predicate, nil])
+            (values || []).each do |value|
+              orm.graph.insert([orm.resource.subject_uri, predicate, value])
+            end
+            orm
+          end,
+          create: lambda do |values|
+            orm = Ldp::Orm.new(Ldp::Resource.new(nil, '', RDF::Graph.new))
+            values.each do |value|
+              orm.graph.insert([orm.resource.subject_uri, predicate, value])
+            end
+            orm
+          end
+        ]
+      end
+
+      def load_model(klass)
+        Lens[
+          get: lambda do |id|
+            klass.find(id)
+          end,
+          put: lambda do |id, model|
+            model.save
+            id
+          end
+        ]
+      end
+
+      def load_or_build_orm
+        Lens[
+          get: lambda do |uri|
+            if uri.present?
+              Ldp::Orm.new(Ldp::Resource.new(FedoraLens.connection, uri.to_s))
+            else
+              Ldp::Orm.new(Ldp::Resource.new(FedoraLens.connection, nil, RDF::Graph.new))
+            end
+          end,
+          put: lambda do |uri, orm|
+            if orm.resource.subject.present?
+              orm.save
+            else
+              orm.resource.create
+            end
+            orm.resource.subject_uri
+          end
+        ]
+      end
+
+      def compose(outer, inner)
+        Lens[
+          get: lambda do |source|
+            inner.get(outer.get(source))
+          end,
+          put: lambda do |source, value|
+            outer.put(source, inner.put(outer.get(source), value))
+          end
+        ]
+      end
+
+      def zip(first, second)
+      end
+    end
+  end
+end

data/lib/fedora_lens/version.rb

@@ -0,0 +1,3 @@
+module FedoraLens
+  VERSION = '0.0.1'
+end

data/lib/fedora_lens.rb

@@ -0,0 +1,181 @@
+require 'rdf'
+require 'ldp'
+require 'ldp_monkeypatch'
+require 'rdf/turtle'
+require 'nokogiri'
+require 'active_model'
+require 'active_support/concern'
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/hash'
+require 'fedora_lens/errors'
+
+module FedoraLens
+  extend ActiveSupport::Concern
+  HOST = "http://localhost:8983/fedora"
+  #HOST = "http://localhost:8080"
+  PATH = '/rest'
+
+  def self.connection
+    @@connection ||= Ldp::Client.new(HOST)
+  end
+
+  included do
+    extend ActiveModel::Naming
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+
+    class_attribute :attributes_as_lenses
+    self.attributes_as_lenses = {}.with_indifferent_access
+
+    attr_reader :attributes
+    attr_reader :orm
+  end
+
+  def initialize(subject_or_data = {}, data = nil)
+    init_core(subject_or_data, data)
+  end
+
+  def persisted?()      false end
+
+  def errors
+    obj = Object.new
+    def obj.[](key)         [] end
+    def obj.full_messages() [] end
+    obj
+  end
+
+  def read_attribute_for_validation(key)
+    @attributes[key]
+  end
+
+  def reload
+    @orm = @orm.reload
+    @attributes = get_attributes_from_orm(@orm)
+  end
+
+  def delete
+    @orm.resource.delete
+  end
+
+  def save
+    @orm = self.class.orm_to_hash.put(@orm, @attributes)
+    new_record? ? create_record : update_record
+  end
+
+  def save!
+    save || raise(RecordNotSaved)
+  end
+
+  def new_record?
+    @new_record
+  end
+
+  def uri
+    @orm.try(:resource).try(:subject_uri).try(:to_s)
+  end
+
+  def id
+    URI.parse(uri).to_s.sub(HOST + PATH, '') if uri.present?
+  end
+
+  protected
+    # This allows you to overide the initializer, but still use this behavior
+    def init_core(subject_or_data = {}, data = nil)
+      @new_record = true
+      case subject_or_data
+        when Ldp::Resource
+          @orm = Ldp::Orm.new(subject_or_data)
+          @attributes = get_attributes_from_orm(@orm)
+        when NilClass, Hash
+          data = subject_or_data || {}
+          @orm = Ldp::Orm.new(Ldp::Resource.new(FedoraLens.connection, nil, RDF::Graph.new))
+          @attributes = data.with_indifferent_access
+        when String
+          data ||= {}
+          @orm = Ldp::Orm.new(Ldp::Resource.new(FedoraLens.connection, subject_or_data, RDF::Graph.new))
+          @attributes = data.with_indifferent_access
+        else
+          raise ArgumentError, "#{data.class} is not acceptable"
+        end
+    end
+
+    def create_record
+      orm.resource.create
+      @new_record = false
+      true
+    end
+
+    def update_record
+      # Fedora errors out when you try to set the rdf:type
+      # see https://github.com/cbeer/ldp/issues/2
+      orm.graph.delete([@orm.resource.subject_uri,
+                         RDF::URI.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
+                         nil])
+      orm.save
+      orm.last_response.success?
+    end
+
+
+  private
+
+  def get_attributes_from_orm(orm)
+    self.class.orm_to_hash.get(orm).with_indifferent_access
+  end
+
+  module ClassMethods
+    def find(id)
+      resource = Ldp::Resource.new(FedoraLens.connection, id_to_uri(id))
+      self.new(resource)
+    end
+
+    def id_to_uri(id)
+      "#{HOST}#{PATH}#{id}"
+    end
+
+    def attribute(name, path, options={})
+      raise AttributeNotSupportedException if name.to_sym == :id
+      attributes_as_lenses[name] = path.map{|s| coerce_to_lens(s)}
+      define_method name do
+        @attributes[name]
+      end
+      define_method "#{name}=" do |value|
+        @attributes[name] = value
+      end
+      orm_to_hash = nil # force us to rebuild the aggregate_lens in case it was already built.
+    end
+
+    def create(data)
+      model = self.new(data)
+      model.save
+      model
+    end
+
+    def orm_to_hash
+      if @orm_to_hash.nil?
+        aggregate_lens = attributes_as_lenses.reduce({}) do |acc, pair|
+          name, path = pair
+          lens = path.reduce {|outer, inner| Lenses.compose(outer, inner)}
+          acc.merge(name => lens)
+        end
+        @orm_to_hash = Lenses.orm_to_hash(aggregate_lens)
+      end
+      @orm_to_hash
+    end
+
+    def coerce_to_lens(path_segment)
+      if path_segment.is_a? RDF::URI
+        Lenses.get_predicate(path_segment)
+      else
+        path_segment
+      end
+    end
+
+    # def has_one(name, scope = nil, options = {})
+    #   ActiveRecord::Associations::Builder::HasOne.build(self, name, scope, options)
+    # end
+  end
+end
+
+require 'fedora_lens/lenses'

data/lib/ldp_monkeypatch.rb

@@ -0,0 +1,22 @@
+require 'ldp'
+module Ldp
+
+  class Resource
+    def create
+      # create seems to not be working in ldp, but it's not entirely clear how it should work
+      # for example, :new? calls :get, which will raise an error when an object doesn't exist,
+      # this means it is impossible to create anything.
+      # raise "" if new?
+      # puts "MONKEY patch create #{client.inspect}"
+      # puts "Graph #{graph.dump(:ttl)}"
+      resp = client.post '/fedora/rest', graph.dump(:ttl) do |req|
+        # req.headers['Slug'] = subject
+      end
+
+      # puts "Heards #{resp.headers.inspect}"
+      @subject = resp.headers['Location']
+      # puts "Loc #{@subject.inspect}"
+      @subject_uri = nil
+    end
+  end
+end

data/lib/test_class.rb

@@ -0,0 +1,64 @@
+require 'fedora_lens'
+class TestClass
+  include FedoraLens
+  include FedoraLens::Lenses
+
+  def self.custom_lens(type)
+    Lens[
+      get: lambda do |doc|
+        if node = doc.at_css("relationship[type=#{type}]")
+          node.content
+        else
+          ""
+        end
+      end,
+      put: lambda do |doc, value|
+        # TODO: create missing nodes
+        # doc.at_css(selector).content = value; doc
+        doc << Nokogiri::XML::Node.new("relationships", doc) if doc.root.nil?
+        root = doc.root
+        relationship = root.at_css("relationship[type=#{type}]")
+        if relationship.nil?
+          relationship = Nokogiri::XML::Node.new("relationship", doc)
+          relationship.set_attribute("type", type)
+          root << relationship
+        end
+        relationship.content = value
+        doc
+      end,
+      create: lambda do |value|
+        Nokogiri::XML("<relationships>
+          <relationship type=\"#{type}\">#{value}</relationship>
+        </relationships>")
+      end
+    ]
+  end
+
+  attribute :title, [RDF::DC11.title, Lenses.single, Lenses.literal_to_string]
+  attribute :mixinTypes, [
+    RDF::URI.new("http://fedora.info/definitions/v4/repository#mixinTypes")]
+  attribute :primaryType, [
+    RDF::URI.new("http://fedora.info/definitions/v4/repository#primaryType"),
+    Lenses.single,
+    Lenses.literal_to_string]
+  attribute :primary_id, [
+    RDF::DC11.relation,
+    Lenses.single,
+    Lenses.literal_to_string,
+    Lenses.as_dom,
+    # Lenses.at_css("relationship[type=primary]")]
+    custom_lens("primary")]
+  attribute :secondary, [
+    RDF::DC11.relation,
+    Lenses.single,
+    Lenses.literal_to_string,
+    Lenses.as_dom,
+    custom_lens("secondary"),
+    # Lenses.at_css("relationship[type=secondary]"),
+    # Lenses.load_model(TestRelated)
+    ]
+  # def self.generated_feature_methods
+  # end
+  # has_one :primary
+end
+

data/spec/fedora_lens/lenses_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'fedora_lens/lens_tests'
+
+module FedoraLens
+  describe Lenses do
+    extend LensTests
+
+    describe ".single" do
+      it "gets the first item" do
+        Lenses.single.get([:first, :second]).should eq :first
+      end
+      it "sets the first item" do
+        Lenses.single.put([:first, :second], :changed).should eq [:changed, :second]
+      end
+      it "creates an item in an array" do
+        Lenses.single.create(:value).should eq [:value]
+      end
+      test_lens Lenses.single, [], :foo
+      test_lens Lenses.single, [:one], :foo
+      test_lens Lenses.single, [:one, :two], :foo
+    end
+
+    describe ".as_dom" do
+      it "converts xml to a Nokogiri::XML::Document" do
+        xml = "<foo><bar>content</bar></foo>"
+        Lenses.as_dom.get(xml).to_xml.should eq Nokogiri::XML(xml).to_xml
+      end
+      it "converts a modified Nokogiri::XML::Document back to xml" do
+        xml = "<foo><bar>content</bar></foo>"
+        modified = Nokogiri::XML("<foo><bar>changed</bar></foo>")
+        Lenses.as_dom.put(xml, modified.dup).should eq modified.to_xml
+      end
+      it "creates a new string of xml" do
+        value = Nokogiri::XML("<foo><bar>created</bar></foo>")
+        Lenses.as_dom.create(value).should eq value.to_xml
+      end
+      test_lens(Lenses.as_dom,
+        Nokogiri::XML("<foo><bar>content</bar></foo>").to_xml,
+        Nokogiri::XML("<foo><bar>new content</bar></foo>")){|v| v.to_s}
+    end
+
+    describe ".at_css" do
+      it "gets the content at the css selector" do
+        dom = Nokogiri::XML("<foo><bar>content</bar></foo>")
+        Lenses.at_css('foo bar').get(dom).should eq 'content'
+      end
+      it "sets the first item" do
+        dom = Nokogiri::XML("<foo><bar>content</bar></foo>")
+        expected = Nokogiri::XML("<foo><bar>changed</bar></foo>")
+        Lenses.at_css('foo bar').put(dom, :changed).to_xml.should eq expected.to_xml
+      end
+      test_lens_get_put(Lenses.at_css("foo bar"), Nokogiri::XML("<foo><bar>content</bar></foo>"))
+      test_lens_put_get(Lenses.at_css("foo bar"),
+                        Nokogiri::XML("<foo><bar>content</bar></foo>"),
+                        "new content")
+    end
+
+    describe ".get_predicate" do
+      let(:orm) do
+        graph = RDF::Graph.new
+        orm = Ldp::Orm.new(Ldp::Resource.new(nil, '', graph))
+        orm.graph.insert([orm.resource.subject_uri, RDF::DC11.title, "title"])
+        orm
+      end
+      it "converts an Ldp::Orm to the value of the specified predicate" do
+        Lenses.get_predicate(RDF::DC11.title).get(orm).first.should eq RDF::Literal.new("title")
+      end
+      it "sets the value of an Ldp::Orm for the specified predicate" do
+        Lenses.get_predicate(RDF::DC11.title).put(orm, [RDF::Literal.new("new")]).value(RDF::DC11.title).first.should eq RDF::Literal.new("new")
+      end
+      it "creates a new Ldp::Orm with the value for a specified predicate" do
+        converted = Lenses.get_predicate(RDF::DC11.title).create([RDF::Literal.new("title")])
+        converted.graph.dump(:ttl).should eq orm.graph.dump(:ttl)
+      end
+      graph = RDF::Graph.new
+      orm = Ldp::Orm.new(Ldp::Resource.new(nil, '', graph))
+      orm.graph.insert([orm.resource.subject_uri, RDF::DC11.title, "title"])
+      test_lens(Lenses.get_predicate(RDF::DC11.title), orm, [RDF::Literal.new("new title")]) do |v|
+        if v.is_a? Ldp::Orm
+          v.value(RDF::DC11.title)
+        else
+          v
+        end
+      end
+    end
+  end
+end

data/spec/fedora_lens_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe FedoraLens do
+  include ActiveModel::Lint::Tests
+
+  class TestClass
+    include FedoraLens
+    attribute :title, [RDF::DC11.title, Lenses.single, Lenses.literal_to_string]
+    # attribute :xml_title, [RDF::DC11.title, Lenses.single]
+  end
+
+  # for ActiveModel::Lint::Tests
+  def setup
+    @model = TestClass.new
+  end
+
+  subject { TestClass.new }
+
+  describe ".find" do
+    context "when the object doesn't exist" do
+      it "should raise an error" do
+        expect{ TestClass.find('bahvejlavawwv') }.to raise_error Ldp::NotFound
+      end
+    end
+
+    context "when the object exists" do
+      let(:existing) { TestClass.create(title: "created resource") }
+      subject { TestClass.find(existing.id) }
+      it { should be_kind_of TestClass }
+      its(:id) { should eq existing.id }
+    end
+  end
+
+  describe ".delete" do
+    subject { TestClass.create(title: "created resource") }
+
+    it "should be deleted" do
+      subject.delete
+      expect{ TestClass.find(subject.id) }.to raise_error Ldp::NotFound
+    end
+  end
+
+  describe ".create" do
+    subject { TestClass.create(attributes) }
+    context "with a hash" do
+      let(:attributes) { { title: "created resource" } }
+      it "creates a resource" do
+        expect(TestClass.find(subject.id).title).to eq "created resource"
+      end
+    end
+    context "with nil" do
+      let(:attributes) { nil }
+      it "creates a resource" do
+        expect(TestClass.find(subject.id)).to be_kind_of TestClass
+      end
+    end
+  end
+
+  describe "#id" do
+    it "should not have 'fedora' in the id" do
+      m = TestClass.new('http://localhost:8983/fedora/rest/41/0d/6b/47/410d6b47-ce9c-4fa0-91e2-d62765667c52')
+      expect(m.id).to eq '/41/0d/6b/47/410d6b47-ce9c-4fa0-91e2-d62765667c52'
+    end
+  end
+
+
+  describe ".save" do
+    it "saves a new resource" do
+      m = TestClass.new(title: "created resource")
+      m.save
+      TestClass.find(m.id).title.should eq "created resource"
+    end
+
+    it "saves an updated resource" do
+      m = TestClass.create(title: "created resource")
+      m.reload
+      m.title = "changed title"
+      m.save
+      TestClass.find(m.id).title.should eq "changed title"
+    end
+
+    context "with a supplied id" do
+      subject { TestClass.new(TestClass.id_to_uri('foobar')) }
+
+      it "saves with that id" do
+        expect(subject.new_record?).to be_true
+        expect(subject.save).to be_true
+        expect(subject.new_record?).to be_false
+      end
+
+    end
+
+  end
+
+  describe ".attribute" do
+    it "makes a setter/getter" do
+      subject.title = "foo"
+      subject.title.should eq "foo"
+    end
+
+    it "loads from rdf" do
+    end
+
+    it "mixes rdf and xml" do
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'bundler'
+require "bundler/setup"
+require 'fedora_lens'
+require 'fedora_lens/lenses'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: fedora_lens
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Justin Coyne
+- Brian Maddy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdf-turtle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.2
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.2
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: ldp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- justin@curationexperts.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-version
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- config/jetty.yml
+- demo.rb
+- fedora/.gitkeep
+- fedora_lens.gemspec
+- lib/fedora_lens.rb
+- lib/fedora_lens/errors.rb
+- lib/fedora_lens/lens.rb
+- lib/fedora_lens/lens_tests.rb
+- lib/fedora_lens/lenses.rb
+- lib/fedora_lens/version.rb
+- lib/ldp_monkeypatch.rb
+- lib/test_class.rb
+- spec/fedora_lens/lenses_spec.rb
+- spec/fedora_lens_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- APACHE2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: A client for Fedora Commons Repository (fcrepo) version 4
+test_files:
+- spec/fedora_lens/lenses_spec.rb
+- spec/fedora_lens_spec.rb
+- spec/spec_helper.rb
+has_rdoc: