speedy-af 0.1.1

data/Rakefile

@@ -0,0 +1,46 @@
+require 'solr_wrapper'
+require 'fcrepo_wrapper'
+require 'active_fedora/rake_support'
+
+require 'rspec/core/rake_task'
+desc 'Run tests only'
+RSpec::Core::RakeTask.new(:rspec) do |spec|
+  spec.rspec_opts = ['--backtrace'] if ENV['CI']
+end
+
+require 'rubocop/rake_task'
+desc 'Run style checker'
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.requires << 'rubocop-rspec'
+  task.fail_on_error = true
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.rcov = true
+end
+
+desc "CI build"
+task :ci do
+  Rake::Task['rubocop'].invoke unless ENV['NO_RUBOCOP']
+  ENV['environment'] = "test"
+  with_test_server do
+    Rake::Task[:coverage].invoke
+  end
+end
+
+desc "Execute specs with coverage"
+task :coverage do
+  # Put spec opts in a file named .rspec in root
+  ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby"
+  ENV['COVERAGE'] = 'true' unless ruby_engine == 'jruby'
+  Rake::Task[:spec].invoke
+end
+
+desc "Execute specs with coverage"
+task :spec do
+  with_test_server do
+    Rake::Task[:rspec].invoke
+  end
+end
+
+task default: :ci

data/lib/speedy-af.rb

@@ -0,0 +1 @@
+require 'speedy_af'

data/lib/speedy_af.rb

@@ -0,0 +1,7 @@
+require 'active_fedora'
+module SpeedyAF
+  module Proxy; end
+  autoload :IndexedContent, 'speedy_af/indexed_content'
+  autoload :Base, 'speedy_af/base'
+  autoload :OrderedAggregationIndex, 'speedy_af/ordered_aggregation_index'
+end

data/lib/speedy_af/base.rb

@@ -0,0 +1,214 @@
+require 'ostruct'
+
+module SpeedyAF
+  class Base
+    class NotAvailable < RuntimeError; end
+
+    SOLR_ALL = 10_000_000
+
+    attr_reader :attrs, :model
+
+    def self.defaults
+      @defaults ||= {}
+    end
+
+    def self.defaults=(value)
+      raise ArgumentError unless value.respond_to?(:merge)
+      @defaults = value
+    end
+
+    def self.proxy_class_for(model)
+      klass = "::SpeedyAF::Proxy::#{model.name}".safe_constantize
+      if klass.nil?
+        namespace = model.name.deconstantize
+        name = model.name.demodulize
+        klass_module = namespace.split(/::/).inject(::SpeedyAF::Proxy) do |mod, ns|
+          mod.const_defined?(ns, false) ? mod.const_get(ns, false) : mod.const_set(ns, Module.new)
+        end
+        klass = klass_module.const_set(name, Class.new(self))
+      end
+      klass
+    end
+
+    def self.config(model, &block)
+      proxy_class = proxy_class_for(model) { Class.new(self) }
+      proxy_class.class_eval(&block) if block_given?
+    end
+
+    def self.find(id, opts = {})
+      where(%(id:"#{id}"), opts).first
+    end
+
+    def self.where(query, opts = {})
+      docs = ActiveFedora::SolrService.query(query, rows: SOLR_ALL)
+      from(docs, opts)
+    end
+
+    def self.from(docs, opts = {})
+      hash = docs.each_with_object({}) do |doc, h|
+        proxy = proxy_class_for(model_for(doc))
+        h[doc['id']] = proxy.new(doc, opts[:defaults])
+      end
+      return hash.values if opts[:order].nil?
+      opts[:order].call.collect { |id| hash[id] }.to_a
+    end
+
+    def self.model_for(solr_document)
+      solr_document[:has_model_ssim].first.safe_constantize
+    end
+
+    def initialize(solr_document, instance_defaults = {})
+      instance_defaults ||= {}
+      @model = Base.model_for(solr_document)
+      @attrs = self.class.defaults.merge(instance_defaults)
+      solr_document.each_pair do |k, v|
+        attr_name, value = parse_solr_field(k, v)
+        @attrs[attr_name.to_sym] = value
+      end
+    end
+
+    def real_object
+      if @real_object.nil?
+        @real_object = model.find(id)
+        @attrs.clear
+      end
+      @real_object
+    end
+
+    def real?
+      !@real_object.nil?
+    end
+
+    def reload
+      dup = Base.find(id)
+      @attrs = dup.attrs
+      @model = dup.model
+      @real_object = nil
+      self
+    end
+
+    def to_query(key)
+      "#{key}=#{id}"
+    end
+
+    def respond_to_missing?(sym, _include_private = false)
+      @attrs.key?(sym) ||
+        model.reflections[sym].present? ||
+        model.instance_methods.include?(sym)
+    end
+
+    def method_missing(sym, *args)
+      return real_object.send(sym, *args) if real?
+
+      return @attrs[sym] if @attrs.key?(sym)
+
+      reflection = reflection_for(sym)
+      unless reflection.nil?
+        begin
+          return load_from_reflection(reflection, sym.to_s =~ /_ids?$/)
+        rescue NotAvailable => e
+          ActiveFedora::Base.logger.warn(e.message)
+        end
+      end
+
+      if model.instance_methods.include?(sym)
+        ActiveFedora::Base.logger.warn("Reifying #{model} because #{sym} called from #{caller.first}")
+        return real_object.send(sym, *args)
+      end
+      super
+    end
+
+    protected
+
+      def reflection_for(sym)
+        return nil unless model.respond_to?(:reflections)
+        reflection_name = sym.to_s.sub(/_id(s?)$/, '\1').to_sym
+        model.reflections[reflection_name] || model.reflections[:"#{reflection_name.to_s.singularize}_proxies"]
+      end
+
+      def parse_solr_field(k, v)
+        # :nocov:
+        transforms = {
+          'dt' => ->(m) { Time.parse(m) },
+          'b'  => ->(m) { m },
+          'db' => ->(m) { m.to_f },
+          'f'  => ->(m) { m.to_f },
+          'i'  => ->(m) { m.to_i },
+          'l'  => ->(m) { m.to_i },
+          nil  => ->(m) { m }
+        }
+        # :nocov:
+        attr_name, type, _stored, _indexed, _multi = k.scan(/^(.+)_(.+)(s)(i?)(m?)$/).first
+        return [k, v] if attr_name.nil?
+        value = Array(v).map { |m| transforms.fetch(type, transforms[nil]).call(m) }
+        value = value.first unless @model.respond_to?(:properties) && multiple?(@model.properties[attr_name])
+        [attr_name, value]
+      end
+
+      def multiple?(prop)
+        prop.present? && prop.respond_to?(:multiple?) && prop.multiple?
+      end
+
+      def load_from_reflection(reflection, ids_only = false)
+        if reflection.options.key?(:through)
+          return load_through_reflection(reflection, ids_only)
+        end
+        if reflection.belongs_to? && reflection.respond_to?(:predicate_for_solr)
+          return load_belongs_to_reflection(reflection.predicate_for_solr, ids_only)
+        end
+        if reflection.has_many? && reflection.respond_to?(:predicate_for_solr)
+          return load_has_many_reflection(reflection.predicate_for_solr, ids_only)
+        end
+        if reflection.is_a?(ActiveFedora::Reflection::HasSubresourceReflection)
+          return load_subresource_content(reflection)
+        end
+        # :nocov:
+        raise NotAvailable, "`#{reflection.name}' cannot be quick-loaded. Falling back to model."
+        # :nocov:
+      end
+
+      def load_through_reflection(reflection, ids_only = false)
+        ids = case reflection.options[:through]
+              when 'ActiveFedora::Aggregation::Proxy' then proxy_ids(reflection)
+              else subresource_ids(reflection)
+              end
+        return ids if ids_only
+        query = ActiveFedora::SolrQueryBuilder.construct_query_for_ids(ids)
+        Base.where(query, order: -> { ids })
+      end
+
+      def proxy_ids(reflection)
+        docs = ActiveFedora::SolrService.query %(id:#{id}/#{reflection.name}/*), rows: SOLR_ALL
+        docs.collect { |doc| doc['proxyFor_ssim'] }.flatten
+      end
+
+      def subresource_ids(reflection)
+        subresource = reflection.options[:through]
+        docs = ActiveFedora::SolrService.query %(id:"#{id}/#{subresource}"), rows: 1
+        return [] if docs.empty?
+        ids = docs.first['ordered_targets_ssim']
+        return [] if ids.nil?
+        ids
+      end
+
+      def load_belongs_to_reflection(predicate, ids_only = false)
+        id = @attrs[predicate.to_sym]
+        return id if ids_only
+        Base.find(id)
+      end
+
+      def load_has_many_reflection(predicate, ids_only = false)
+        query = %(#{predicate}_ssim:#{id})
+        return Base.where(query) unless ids_only
+        docs = ActiveFedora::SolrService.query query, rows: SOLR_ALL
+        docs.collect { |doc| doc['id'] }
+      end
+
+      def load_subresource_content(reflection)
+        subresource = reflection.name
+        docs = ActiveFedora::SolrService.query(%(id:"#{id}/#{subresource}"), rows: 1)
+        raise NotAvailable, "`#{subresource}' is not indexed" if docs.empty? || !docs.first.key?('has_model_ssim')
+        @attrs[subresource] = Base.from(docs).first
+      end
+  end
+end

data/lib/speedy_af/indexed_content.rb

@@ -0,0 +1,34 @@
+module SpeedyAF
+  module IndexedContent
+    extend ActiveSupport::Concern
+    MAX_CONTENT_SIZE = 8192
+
+    included do
+      after_save :update_external_index
+    end
+
+    def to_solr(solr_doc = {}, opts = {})
+      return solr_doc unless opts[:external_index]
+      solr_doc.tap do |doc|
+        doc[:id] = id
+        doc[:has_model_ssim] = self.class.name
+        doc[:uri_ss] = uri.to_s
+        doc[:mime_type_ss] = mime_type
+        doc[:original_name_ss] = original_name
+        doc[:size_is] = content.present? ? content.size : 0
+        doc[:'empty?_bs'] = content.nil? || content.empty?
+        doc[:content_ss] = content if index_content?
+      end
+    end
+
+    def update_external_index
+      ActiveFedora::SolrService.add(to_solr({}, external_index: true), softCommit: true)
+    end
+
+    protected
+
+      def index_content?
+        has_content? && mime_type =~ /(^text\/)|([\/\+]xml$)/ && size < MAX_CONTENT_SIZE && content !~ /\x00/
+      end
+  end
+end

data/lib/speedy_af/ordered_aggregation_index.rb

@@ -0,0 +1,26 @@
+module SpeedyAF
+  module OrderedAggregationIndex
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def indexed_ordered_aggregation(name)
+        target_class = reflections[name].class_name
+        contains_key = reflections[:"ordered_#{name.to_s.singularize}_proxies"].options[:through]
+        mixin = generated_association_methods
+        mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def indexed_#{name}
+            ids = self.indexed_#{name.to_s.singularize}_ids
+            ids.lazy.collect { |id| #{target_class}.find(id) }
+          end
+
+          def indexed_#{name.to_s.singularize}_ids
+            return [] unless persisted?
+            docs = ActiveFedora::SolrService.query "id: \#{self.id}/#{contains_key}", rows: 1
+            return [] if docs.empty? or docs.first['ordered_targets_ssim'].nil?
+            docs.first['ordered_targets_ssim']
+          end
+        CODE
+      end
+    end
+  end
+end

data/lib/speedy_af/version.rb

@@ -0,0 +1,3 @@
+module SpeedyAF
+  VERSION = '0.1.1'.freeze
+end

data/spec/fixture_classes.rb

@@ -0,0 +1,48 @@
+class IndexedFile < ActiveFedora::File
+  include SpeedyAF::IndexedContent
+end
+
+class Chapter < ActiveFedora::Base
+  property :title, predicate: ::RDF::Vocab::DC.title, multiple: false do |index|
+    index.as :stored_searchable
+  end
+  property :contributor, predicate: ::RDF::Vocab::DC.contributor, multiple: true do |index|
+    index.as :stored_searchable
+  end
+end
+
+module DowncaseBehavior
+  def lowercase_title
+    title.downcase
+  end
+end
+
+class Book < ActiveFedora::Base
+  include DowncaseBehavior
+  include SpeedyAF::OrderedAggregationIndex
+
+  belongs_to :library, predicate: ::RDF::Vocab::DC.isPartOf
+  has_subresource 'indexed_file', class_name: 'IndexedFile'
+  has_subresource 'unindexed_file', class_name: 'ActiveFedora::File'
+  property :title, predicate: ::RDF::Vocab::DC.title, multiple: false do |index|
+    index.as :stored_searchable
+  end
+  property :publisher, predicate: ::RDF::Vocab::DC.publisher, multiple: false do |index|
+    index.as :stored_searchable
+  end
+  ordered_aggregation :chapters, through: :list_source
+  indexed_ordered_aggregation :chapters
+
+  def uppercase_title
+    title.upcase
+  end
+end
+
+class Library < ActiveFedora::Base
+  has_many :books, predicate: ::RDF::Vocab::DC.isPartOf
+end
+
+module SpeedySpecs
+  class DeepClass < ActiveFedora::Base
+  end
+end

data/spec/integration/base_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+require 'rdf/vocab/dc'
+
+describe SpeedyAF::Base do
+  before { load_fixture_classes!   }
+  after  { unload_fixture_classes! }
+
+  let!(:library) { Library.create }
+  let!(:book) { Book.new title: 'Ordered Things', publisher: 'ActiveFedora Performance LLC', library: library }
+  let!(:chapters) {[
+    Chapter.create(title: 'Chapter 3', contributor: ['Hopper', 'Lovelace', 'Johnson']),
+    Chapter.create(title: 'Chapter 1', contributor: ['Rogers', 'Johnson', 'Stark', 'Romanoff']),
+    Chapter.create(title: 'Chapter 2', contributor: ['Alice', 'Bob', 'Charlie'])
+  ]}
+  let!(:indexed_content) {
+    <<-IPSUM
+    Zombie ipsum reversus ab viral inferno, nam rick grimes malum cerebro. De carne lumbering
+    animata corpora quaeritis. Summus brains sit, morbo vel maleficia? De apocalypsi gorger
+    omero undead survivor dictum mauris. Hi mindless mortuis soulless creaturas, imo evil
+    stalking monstra adventus resi dentevil vultus comedat cerebella viventium.
+    IPSUM
+  }
+  let!(:unindexed_content) {
+    <<-IPSUM
+    Qui animated corpse, cricket bat max brucks terribilem incessu zomby. The voodoo sacerdos
+    flesh eater, suscitat mortuos comedere carnem virus. Zonbi tattered for solum oculi eorum
+    defunctis go lum cerebro. Nescio brains an Undead zombies. Sicut malus putrid voodoo horror.
+    Nigh tofth eliv ingdead.
+    IPSUM
+  }
+  let(:book_presenter) { described_class.find(book.id) }
+
+  context 'lightweight presenter' do
+    before do
+      book.indexed_file.content = indexed_content
+      book.unindexed_file.content = unindexed_content
+      book.chapters = chapters
+      book.ordered_chapters = chapters.sort_by(&:title)
+      book.save!
+    end
+
+    it '#respond_to?' do
+      expect(book_presenter).to respond_to(:title)
+      expect(book_presenter).to respond_to(:chapters)
+      expect(book_presenter).to respond_to(:indexed_file)
+      expect(book_presenter).to respond_to(:unindexed_file)
+      expect { book_presenter.fthagn }.to raise_error(NoMethodError)
+    end
+
+    it '.find' do
+      expect(book_presenter).to be_a(described_class)
+      expect(book_presenter.publisher).to eq(book.publisher)
+    end
+
+    it '.where' do
+      chapter_presenter = described_class.where('contributor_tesim:"Johnson"')
+      expect(chapter_presenter.length).to eq(2)
+    end
+
+    it '.to_query' do
+      expect(book.to_query('book_id')).to eq("book_id=#{URI.encode(book.id, /[^\-_.!~*'()a-zA-Z\d;?:@&=+$,\[\]]/)}")
+    end
+
+    context 'reflections' do
+      let!(:library_presenter) { described_class.find(library.id) }
+
+      it 'loads via indexed proxies' do
+        expect(book_presenter.chapter_ids).to match_array(book.chapter_ids)
+      end
+
+      it 'loads indexed targets' do
+        expect(book_presenter.ordered_chapter_ids).to eq(book.ordered_chapter_ids)
+        chapter_presenters = book_presenter.ordered_chapters
+        expect(chapter_presenters.length).to eq(chapters.length)
+        expect(chapter_presenters.all? { |cp| cp.is_a?(described_class) }).to be_truthy
+        expect(chapter_presenters.collect(&:title)).to eq(book.ordered_chapters.to_a.collect(&:title))
+        expect(book_presenter).not_to be_real
+      end
+
+      it 'loads indexed subresources' do
+        ipsum_presenter = book_presenter.indexed_file
+        expect(ipsum_presenter.model).to eq(IndexedFile)
+        expect(ipsum_presenter.content).to eq(indexed_content)
+        expect(book_presenter).not_to be_real
+        expect(ipsum_presenter).not_to be_real
+      end
+
+      it 'loads has_many reflections' do
+        library.books.create(title: 'Ordered Things II')
+        library.save
+        presenter = library_presenter.books
+        expect(presenter.length).to eq(2)
+        expect(presenter.all? { |bp| bp.is_a?(described_class) }).to be_truthy
+        expect(library_presenter.book_ids).to match_array(library.book_ids)
+        expect(library_presenter).not_to be_real
+      end
+
+      it 'loads belongs_to reflections' do
+        expect(book_presenter.library_id).to eq(library.id)
+        expect(book_presenter.library).to be_a(described_class)
+        expect(book_presenter.library.model).to eq(library.class)
+        expect(book_presenter).not_to be_real
+      end
+    end
+
+    context 'configuration' do
+      before do
+        described_class.config Book do
+          include DowncaseBehavior
+          self.defaults = { foo: 'bar!' }
+        end
+
+        described_class.config SpeedySpecs::DeepClass do
+          self.defaults = { baz: 'quux!' }
+        end
+      end
+
+      it 'adds default values' do
+        expect(book_presenter.foo).to eq('bar!')
+      end
+
+      it 'mixes in the mixins' do
+        expect(book_presenter.lowercase_title).to eq(book.lowercase_title)
+        expect(book_presenter).not_to be_real
+      end
+
+      it 'works with nested classes' do
+        expect(described_class.proxy_class_for(SpeedySpecs::DeepClass)).to eq(SpeedyAF::Proxy::SpeedySpecs::DeepClass)
+      end
+    end
+
+    context 'reification' do
+      it 'knows when it is real' do
+        expect(book_presenter).not_to be_real
+        expect(book_presenter.real_object).to be_a(Book)
+        expect(book_presenter).to be_real
+      end
+
+      it '#reload (Base)' do
+        expect(book_presenter.real_object).to be_a(Book)
+        book_presenter.reload
+        expect(book_presenter).not_to be_real
+      end
+
+      it '#reload (File)' do
+        ipsum_presenter = book_presenter.indexed_file
+        expect(ipsum_presenter.real_object).to be_a(IndexedFile)
+        ipsum_presenter.reload
+        expect(ipsum_presenter).not_to be_real
+      end
+
+      it 'reifies when it has to' do
+        expect(book_presenter.uppercase_title).to eq(book.title.upcase)
+        expect(book_presenter).to be_real
+      end
+
+      it 'reifies indexed subresources' do
+        ipsum_presenter = book_presenter.indexed_file
+        expect(ipsum_presenter.metadata).to be_a(ActiveFedora::WithMetadata::MetadataNode)
+        expect(ipsum_presenter).to be_real
+      end
+
+      it 'loads unindexed subresources' do
+        expect(book_presenter.unindexed_file.content).to eq(unindexed_content)
+        expect(book_presenter).to be_real
+      end
+    end
+  end
+end