ansr_dpla 0.0.4

data/lib/ansr_dpla/model.rb

@@ -0,0 +1,7 @@
+module Ansr::Dpla
+  module Model
+  	autoload :PseudoAssociate, 'ansr_dpla/model/pseudo_associate'
+  	require 'ansr_dpla/model/querying'
+  	require 'ansr_dpla/model/base'
+  end
+end

data/lib/ansr_dpla/model/base.rb

@@ -0,0 +1,24 @@
+require 'ansr'
+module Ansr::Dpla
+  module Model
+    class Base < Ansr::Base
+      self.abstract_class = true
+
+  	  include Querying
+
+      def self.inherited(subclass)
+        super(subclass)
+        subclass.configure do |config|
+          config[:table_class] = Ansr::Dpla::Arel::BigTable
+        end
+      end
+
+  		def assign_nested_parameter_attributes(pairs)
+	      pairs.each do |k, v|
+          v = PseudoAssociate.new(v) if Hash === v
+          _assign_attribute(k, v)
+        end
+	    end      	
+    end
+  end
+end

data/lib/ansr_dpla/model/pseudo_associate.rb

@@ -0,0 +1,14 @@
+# a class to pretend the unfindable "associations" are real models
+module Ansr::Dpla
+	module Model
+    class PseudoAssociate
+      def initialize(doc = {})
+        @doc = doc.with_indifferent_access
+      end
+
+      def method_missing(name, *args)
+        @doc[name] or super
+      end
+    end
+  end
+end

data/lib/ansr_dpla/model/querying.rb

@@ -0,0 +1,34 @@
+require 'active_record'
+module Ansr::Dpla
+  module Model
+  	module Querying
+    extend ActiveSupport::Concern
+
+      module ClassMethods
+        def build_default_scope
+          Ansr::Dpla::Relation.new(model(), table())
+        end
+
+        def api
+          @api ||= begin
+            a = (config[:api] || Ansr::Dpla::Api).new
+            a.config{|x| x.merge!(self.config)}
+            a
+          end
+        end
+
+        def api=(api)
+          @api = api
+        end
+
+        def connection_handler
+          @connection_handler ||= Ansr::Model::ConnectionHandler.new(Ansr::Dpla::ConnectionAdapters::NoSqlAdapter)
+        end
+
+        def references
+          ['provider', 'object']
+        end
+      end
+    end
+  end
+end

data/lib/ansr_dpla/relation.rb

@@ -0,0 +1,60 @@
+require 'yaml'
+module Ansr::Dpla
+  class Relation < ::Ansr::Relation
+
+    def initialize(klass, table, values = {})
+      raise "Cannot search nil model" if klass.nil?
+      super(klass, table, values)
+    end
+
+    def facet_values=(values)
+      values.each {|value| raise "#{value.expr.name.to_sym} is not facetable" unless table.facets.include? value.expr.name.to_sym}
+      super
+    end
+
+    def empty?
+      count == 0
+    end
+
+    def many?
+      count > 1
+    end
+
+    def offset!(value)
+      page_size = self.limit_value || default_limit_value
+      if (value.to_i % page_size.to_i) != 0
+        raise "Bad offset #{value} for page size #{page_size}"
+      end
+      self.offset_value=value
+      self
+    end
+
+    def count
+      self.load
+      @response['count']
+    end
+
+    def filters_from(response)
+      f = {}
+      (response['facets'] || {}).inject(f) do |h,(k,v)|
+
+        if v['total'] != 0
+          items = v['terms'].collect do |term|
+            Ansr::Facets::FacetItem.new(:value => term['term'], :hits => term['count'])
+          end
+          options = {:sort => 'asc', :offset => 0}
+          h[k] = Ansr::Facets::FacetField.new k, items, options
+        end
+        h
+      end
+      f
+    end
+
+    def docs_from(response)
+      response['docs']
+    end
+
+  end
+
+
+end

data/lib/ansr_dpla/request.rb

@@ -0,0 +1,5 @@
+module Ansr::Dpla
+  class Request < ::Ansr::OpenStructWithHashAccess
+    attr_accessor :path
+  end
+end

data/spec/adpla_test_api.rb

@@ -0,0 +1,9 @@
+module Ansr::Dpla
+  class TestApi
+  	include Ansr::Configurable
+    def items(opts={})
+    end
+    def collections(opts={})
+    end
+  end
+end

data/spec/lib/api_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Ansr::Dpla::Api do
+
+  describe '#config' do
+    before do
+      @test = Ansr::Dpla::Api.new
+    end
+
+    it "should be configurable with a Hash" do
+      config_fixture = {:api_key => :foo, :url => :bar}
+      @test.config{|x| x.merge!(config_fixture)}
+      expect(@test.url).to eql(:bar)
+    end
+
+    it "should be configurable with a path to a yaml" do
+      open(fixture_path('dpla.yml')) do |blob|
+        config = YAML.load(blob)
+        @test.config{|x| x.merge!(config)}
+      end
+      expect(@test.url).to eql('http://fake.dp.la/v0/')
+    end
+
+    it "should raise an error of the config doesn't have required fields" do
+      expect { Ansr::Dpla::Api.new.config{|x| x.merge!(:url => :foo)}}.to raise_error
+      Ansr::Dpla::Api.new.config {|x| x.merge!({:url => :foo, :api_key => :foo})}
+    end
+
+  end
+
+  describe '#path_for' do
+    before do
+      @test = Ansr::Dpla::Api.new
+      @test.config{|x| x.merge!(:api_key => :testing)}
+    end
+
+
+    describe 'queries' do
+      it "should build paths for basic queries" do
+        fixture = {:foo => ['kittens', 'cats'], :bar => ['puppies', 'dogs']}
+        expected = 'tests?api_key=testing&foo=kittens+AND+cats&bar=puppies+AND+dogs'
+        expect(@test.path_for('tests', fixture)).to eql(expected)
+        expect(@test.items_path(fixture)).to eql(expected.sub(/^tests/,'items'))
+        expect(@test.collections_path(fixture)).to eql(expected.sub(/^tests/,'collections'))
+        expect(@test.item_path('foo')).to eql('items/foo?api_key=testing')
+        expect(@test.collection_path('foo')).to eql('collections/foo?api_key=testing')
+      end
+
+      it "should build paths for OR and NOT queries" do
+        fixture = {:foo => ['kittens', 'NOT cats']}
+        expected = 'tests?api_key=testing&foo=kittens+AND+NOT+cats'
+        expect(@test.path_for('tests', fixture)).to eql(expected)
+
+        fixture = {:foo => ['NOT kittens', 'cats']}
+        expected = 'tests?api_key=testing&foo=NOT+kittens+AND+cats'
+        expect(@test.path_for('tests', fixture)).to eql(expected)
+
+        fixture = {:foo => ['kittens', 'OR cats']}
+        expected = 'tests?api_key=testing&foo=kittens+OR+cats'
+        expect(@test.path_for('tests', fixture)).to eql(expected)
+
+        fixture = {:foo => ['OR kittens', 'cats']} 
+        expected = 'tests?api_key=testing&foo=kittens+AND+cats'
+        expect(@test.path_for('tests', fixture)).to eql(expected)
+      end
+    end
+
+    it "should build paths for facets right" do
+      fixture = {:foo => 'kittens', :facets => :bar}
+      expected = 'tests?api_key=testing&foo=kittens&facets=bar'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+
+      fixture = {:foo => 'kittens', :facets => [:bar, :baz]}
+      expected = 'tests?api_key=testing&foo=kittens&facets=bar%2Cbaz'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+
+      fixture = {:foo => 'kittens', :facets => 'bar,baz'}
+      expected = 'tests?api_key=testing&foo=kittens&facets=bar%2Cbaz'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+    end
+
+    it "should build paths for sorts right" do
+      fixture = {:foo => 'kittens', :sort_by => [:bar, :baz]}
+      expected = 'tests?api_key=testing&foo=kittens&sort_by=bar%2Cbaz'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+
+      fixture = {:foo => 'kittens', :sort_by => 'bar,baz'}
+      expected = 'tests?api_key=testing&foo=kittens&sort_by=bar%2Cbaz'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+
+      fixture = {:foo => 'kittens', :sort_by => 'bar,baz', :sort_order => :desc}
+      expected = 'tests?api_key=testing&foo=kittens&sort_by=bar%2Cbaz&sort_order=desc'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+    end
+
+    it "should build paths for field selections right" do
+      fixture = {:foo => 'kittens', :fields => [:bar, :baz]}
+      expected = 'tests?api_key=testing&foo=kittens&fields=bar%2Cbaz'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+
+      fixture = {:foo => 'kittens', :fields => 'bar,baz'}
+      expected = 'tests?api_key=testing&foo=kittens&fields=bar%2Cbaz'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+    end
+
+    it "should build paths for limits and page sizes right" do
+      fixture = {:foo => 'kittens', :page_size=>25, :page=>4}
+      expected = 'tests?api_key=testing&foo=kittens&page_size=25&page=4'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+    end
+
+  end
+end

data/spec/lib/item_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Item do
+  describe '.configure' do
+    it "should store the configured Api class" do
+    	Item.configure {|x| x.merge!(:api=>Ansr::Dpla::TestApi, :api_key => :dummy)}
+    	expect(Item.api).to be_a Ansr::Dpla::TestApi
+    end
+  end
+
+  describe '.find' do
+    it "should find an item given an id" do
+      mock_api = double('api')
+      Item.api = mock_api
+      mock_api.should_receive(:items).with(:id=>"123", :page_size=>1).and_return(read_fixture('item.jsonld'))
+      Item.find('123')
+    end
+    it "should raise an exception for a bad id" do
+      mock_api = double('api')
+      Item.api = mock_api
+      mock_api.should_receive(:items).with(:id=>"123", :page_size=>1).and_return(read_fixture('empty.jsonld'))
+      expect {Item.find('123')}.to raise_error
+    end
+  end
+
+  describe '.where' do
+  	before do
+    	Item.configure{|x| x.merge!({:api=>Ansr::Dpla::TestApi, :api_key => :dummy})}
+    end
+  	it 'should return a Relation when there is query information' do
+      expect(Item.where({:q=>'kittens'})).to be_a Ansr::Relation
+  	end
+    it 'should return itself when there is no query information' do
+      expect(Item.where({})).to be Item
+    end
+  end
+
+  describe 'accessor methods' do
+    before do
+      mock_api = double('api')
+      Item.api = mock_api
+      @hash = JSON.parse(read_fixture('item.jsonld'))['docs'][0]
+      @test = Item.new(@hash)
+    end
+
+    it 'should dispatch method names to the hash' do
+      @test.dataProvider.should == "Boston Public Library"
+      @test.sourceResource.identifier.should == [ "Local accession: 08_06_000884" ]
+    end
+
+    it 'should miss methods for undefined fields' do
+      expect {@test.foo}.to raise_error
+    end
+  end
+
+
+end

data/spec/lib/relation/facet_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Ansr::Dpla::Relation do
+  before do
+    @kittens = read_fixture('kittens.jsonld')
+    @faceted = read_fixture('kittens_faceted.jsonld')
+    @empty = read_fixture('empty.jsonld')
+    @mock_api = double('api')
+    Item.config{ |x| x[:api_key] = :foo}
+    Item.engine.api= @mock_api
+  end
+
+  subject { Ansr::Dpla::Relation.new(Item, Item.table) }
+  describe '#filter' do
+	  describe "do a single field, single value filter" do
+      it "with facet" do
+  	    test = subject.filter(:object=>'kittens').facet(:object)
+  	    @mock_api.should_receive(:items).with(:object => 'kittens', :facets => :object).and_return('')
+  	    test.load
+      end
+      it "without facet" do
+        test = subject.filter(:object=>'kittens')
+        @mock_api.should_receive(:items).with(:object => 'kittens').and_return('')
+        test.load
+      end
+	  end
+	  it "do a single field, multiple value filter" do
+	    test = subject.filter(:object=>['kittens', 'cats']).facet(:object)
+	    @mock_api.should_receive(:items).with(:object => ['kittens','cats'], :facets => :object).and_return('')
+	    test.load
+	  end
+	  it "do merge single field, multiple value filters" do
+	    test = subject.filter(:"provider.name"=>'kittens').filter(:"provider.name"=>'cats').facet(:"provider.name")
+	    @mock_api.should_receive(:items).with(hash_including(:"provider.name" => ['kittens','cats'], :facets => :"provider.name")).and_return('')
+	    test.load
+	  end
+	  it "do a multiple field, single value filter" do
+	    test = subject.filter(:object=>'kittens',:isShownAt=>'bears').facet([:object, :isShownAt])
+	    @mock_api.should_receive(:items).with(hash_including(:object => 'kittens', :isShownAt=>'bears', :facets => [:object, :isShownAt])).and_return('')
+	    test.load
+	  end
+	  it "should keep scope distinct from spawned Relations" do
+	    test = subject.filter(:"provider.name"=>'kittens').facet(:"provider.name")
+	    test.where(:q=>'cats')
+	    @mock_api.should_receive(:items).with(:"provider.name" => 'kittens', :facets => :"provider.name").and_return('')
+	    test.load
+	  end
+	  it "should raise an error if the requested field is not a facetable field" do
+	    expect {subject.facet(:foo)}.to raise_error
+	  end
+    it "should facet without a filter" do
+      test = subject.facet(:object)
+      @mock_api.should_receive(:items).with(:facets => :object).and_return('')
+      test.load
+    end
+  end
+
+  describe '#filters' do
+    it 'should return Blacklight types' do
+      # Blacklight::SolrResponse::Facets::FacetItem.new(:value => s, :hits => v)
+      # options = {:sort => 'asc', :offset => 0}
+      # Blacklight::SolrResponse::Facets::FacetField.new name, items, options
+      test = subject.where(:q=>'kittens')
+      @mock_api.should_receive(:items).with(:q => 'kittens').and_return(@faceted)
+      test.load
+      fkey = test.filters.keys.first
+      facet = test.filters[fkey]
+      expect(facet).to be_a(Ansr::Facets::FacetField)
+      facet.items
+    end
+    it 'should dispatch a query with no docs requested if not loaded' do
+      test = subject.where(:q=>'kittens')
+      @mock_api.should_receive(:items).with(:q => 'kittens', :page_size=>0).once.and_return(@faceted)
+      fkey = test.filters.keys.first
+      facet = test.filters[fkey]
+      expect(facet).to be_a(Ansr::Facets::FacetField)
+      expect(test.loaded?).to be_false
+      test.filters # make sure we memoized the facet values
+    end
+  end
+
+end

data/spec/lib/relation/select_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Ansr::Relation do
+  before do
+    @kittens = read_fixture('kittens.jsonld')
+    @faceted = read_fixture('kittens_faceted.jsonld')
+    @empty = read_fixture('empty.jsonld')
+    @mock_api = double('api')
+    Item.config{ |x| x[:api_key] = :foo}
+    Item.engine.api= @mock_api
+  end
+
+  subject { Ansr::Dpla::Relation.new(Item, Item.table) }
+
+  describe '#select' do
+    describe 'with a block given' do
+      it "should build an array" do
+        test = subject.where(q:'kittens')
+        @mock_api.should_receive(:items).with(:q => 'kittens').and_return(@kittens)
+        actual = test.select {|d| true}
+        expect(actual).to be_a(Array)
+        expect(actual.length).to eql(test.limit_value)
+        actual = test.select {|d| false}
+        expect(actual).to be_a(Array)
+        expect(actual.length).to eql(0)
+      end
+    end
+    describe 'with a String or Symbol key given' do
+      it 'should change the requested document fields' do
+        test = subject.where(q:'kittens')
+        @mock_api.should_receive(:items).with(:q => 'kittens', :fields=>:name).and_return('')
+        test = test.select('name')
+        test.load
+      end
+    end
+    describe 'with a list of keys' do
+      it "should add all the requested document fields" do
+        test = subject.where(q:'kittens')
+        @mock_api.should_receive(:items).with(:q => 'kittens', :fields=>[:name,:foo]).and_return('')
+        test = test.select(['name','foo'])
+        test.load
+      end
+      it "should add all the requested document fields and proxy them" do
+        test = subject.where(q:'kittens')
+        @mock_api.should_receive(:items).with(:q => 'kittens', :fields=>:object).and_return(@kittens)
+        test = test.select('object AS my_object')
+        test.load
+        expect(test.to_a.first['object']).to be_nil
+        expect(test.to_a.first['my_object']).to eql('http://ark.digitalcommonwealth.org/ark:/50959/6682xj30d/thumbnail')
+      end
+    end
+  end
+
+end