ansr 0.0.1 → 0.0.3

data/ansr_dpla/lib/ansr_dpla/arel/visitors.rb

@@ -0,0 +1,6 @@
+module Ansr::Dpla::Arel
+  module Visitors
+    require 'ansr_dpla/arel/visitors/query_builder'
+    require 'ansr_dpla/arel/visitors/to_no_sql'
+  end
+end

data/ansr_dpla/lib/ansr_dpla/arel/visitors/query_builder.rb

@@ -0,0 +1,188 @@
+module Ansr::Dpla::Arel::Visitors
+  class QueryBuilder < Ansr::Arel::Visitors::QueryBuilder
+    attr_reader :query_opts
+    
+    def initialize(table, query_opts=nil)
+      super(table)
+      @query_opts = query_opts ||= Ansr::Dpla::Request.new
+      @query_opts.path = table.name
+    end
+
+    # determines whether multiple values should accumulate or overwrite in merges
+    def multiple?(field_key)
+      true
+    end
+
+    def visit_String o, a
+      case a
+      when Ansr::Arel::Visitors::From
+        query_opts.path = o
+      when Ansr::Arel::Visitors::Facet
+        filter_field(o.to_sym)
+      when Ansr::Arel::Visitors::Order
+        order(o)
+      else
+        raise "visited String \"#{o}\" with #{a.to_s}"
+      end
+    end
+
+    def visit_Arel_SqlLiteral(n, attribute)
+      select_val = n.to_s.split(" AS ")
+      case attribute
+      when Ansr::Arel::Visitors::Order
+        order(n.to_s)
+      when Ansr::Arel::Visitors::Facet
+        filter_field(select_val[0].to_sym)
+      else
+        field(select_val[0].to_sym)
+        if select_val[1]
+          query_opts.aliases ||= {}
+          query_opts.aliases[select_val[0]] = select_val[1]
+        end
+      end
+    end
+
+    def visit_Ansr_Arel_Nodes_Filter(object, attribute)
+      expr = object.expr
+      case expr
+      when ::Arel::SqlLiteral
+        visit expr, Ansr::Arel::Visitors::Filter.new(attribute) if object.select
+      when ::Arel::Attributes::Attribute
+        name = object.expr.name
+        name = "#{expr.relation.name}.#{name}" if expr.relation.name.to_s != table.name.to_s
+        visit name, Ansr::Arel::Visitors::Filter.new(attribute) if object.select
+      else
+        raise "Unexpected filter expression type #{object.expr.class}"
+      end
+    end
+
+    def visit_Ansr_Arel_Nodes_Facet(object, attribute)
+      expr = object.expr
+      case expr
+      when ::Arel::SqlLiteral
+        visit expr, Ansr::Arel::Visitors::Facet.new(attribute)
+      when ::Arel::Attributes::Attribute
+        name = object.expr.name
+        name = "#{expr.relation.name}.#{name}" if expr.relation.name.to_s != table.name.to_s
+        visit name, Ansr::Arel::Visitors::Facet.new(attribute) if object.select
+      else
+        raise "Unexpected filter expression type #{object.expr.class}"
+      end
+    end
+
+    def projections
+      query_opts[:fields] || []
+    end
+
+    def filter_projections
+      query_opts[:facets] || []
+    end
+
+
+    def field(field_name)
+      return unless field_name
+      old = query_opts[:fields] ? Array(query_opts[:fields]) : []
+      field_names = (old + Array(field_name)).uniq
+      if field_names[0]
+        query_opts[:fields] = field_names[1] ? field_names : field_names[0]
+      end
+    end
+
+    def filter_field(field_name)
+      return unless field_name
+      field_name = Array(field_name)
+      field_name.each {|fn| raise "#{fn} is not a facetable field" unless table.facets.include? fn.to_sym}
+      old = query_opts[:facets] ? Array(query_opts[:facets]) : []
+      field_names = (old + Array(field_name)).uniq
+      if field_names[0]
+        query_opts[:facets] = field_names[1] ? field_names : field_names[0]
+      end
+    end
+
+    def add_where_clause(attr_node, val)
+      field_key = field_key_from_node(attr_node)
+      if query_opts[field_key]
+        query_opts[field_key] = Array(query_opts[field_key]) << val
+      else
+        query_opts[field_key] = val
+      end
+    end
+
+    # the DPLA API makes no distinction between filter and normal queries
+    def visit_Arel_Nodes_Equality(object, attribute)
+      add_where_clause(object.left, object.right)
+    end
+
+    def visit_Arel_Nodes_NotEqual(object, attribute)
+      add_where_clause(object.left, "NOT " + object.right)
+    end
+    def visit_Arel_Nodes_Or(object, attribute)
+      add_where_clause(object.left, "OR " + object.right)
+    end
+
+    def visit_Arel_Nodes_Grouping(object, attribute)
+      visit object.expr, attribute
+    end
+
+    def visit_Arel_Nodes_Ordering(object, attribute)
+      if query_opts[:sort_by]
+        query_opts[:sort_by] = Array[query_opts[:sort_by]] << object.expr.name
+      else
+        query_opts[:sort_by] = object.expr.name
+      end
+      direction = :asc if (::Arel::Nodes::Ascending === object and direction)
+      direction = :desc if (::Arel::Nodes::Descending === object)
+      query_opts[:sort_order] = direction if direction
+    end      
+
+    def order(*arel_nodes)
+      direction = nil
+      nodes = []
+      arel_nodes.inject(nodes) do |c, n|
+        if ::Arel::Nodes::Ordering === n
+          c << n
+        elsif n.is_a? String
+          _ns = n.split(',')
+          _ns.each do |_n| 
+            _p = _n.split(/\s+/)
+            if (_p[1])
+              _p[1] = _p[1].downcase.to_sym
+            else
+              _p[1] = :asc
+            end
+            c << table[_p[0].to_sym].send(_p[1])
+          end
+        end
+        c
+      end
+      nodes.each do |node|
+        if ::Arel::Nodes::Ordering === node
+          if query_opts[:sort_by]
+            query_opts[:sort_by] = Array[query_opts[:sort_by]] << node.expr.name
+          else
+            query_opts[:sort_by] = node.expr.name
+          end
+          direction = :asc if (::Arel::Nodes::Ascending === node and direction)
+          direction = :desc if (::Arel::Nodes::Descending === node)
+        end
+      end
+      query_opts[:sort_order] = direction if direction
+    end
+
+    def visit_Arel_Nodes_Limit(object, attribute)
+      value = object.expr
+      if value and (value = value.to_i)
+        raise "Page size cannot be > 500 (#{value}" if value > 500
+        query_opts[:page_size] = value
+      end
+    end
+
+    def visit_Arel_Nodes_Offset(object, attribute)
+      value = object.expr
+      if value
+        query_opts[:page] = (value.to_i / (query_opts[:page_size] || Ansr::Relation::DEFAULT_PAGE_SIZE)) + 1
+      end
+    end        
+
+  end    
+end

data/ansr_dpla/lib/ansr_dpla/arel/visitors/to_no_sql.rb

@@ -0,0 +1,9 @@
+module Ansr::Dpla::Arel::Visitors
+  class ToNoSql < Ansr::Arel::Visitors::ToNoSql
+
+    def query_builder(opts = nil)
+      Ansr::Dpla::Arel::Visitors::QueryBuilder.new(table, opts)
+    end
+
+  end
+end

data/ansr_dpla/lib/ansr_dpla/connection_adapters/no_sql_adapter.rb

@@ -0,0 +1,58 @@
+module Ansr::Dpla
+  module ConnectionAdapters
+    class NoSqlAdapter < Ansr::ConnectionAdapters::NoSqlAdapter
+
+      def self.connection_for(klass)
+        klass.api
+      end
+
+      def initialize(klass, logger = nil, pool = nil) #:nodoc:
+        super(klass, klass.api, logger, pool)
+        @visitor = Ansr::Dpla::Arel::Visitors::ToNoSql.new(@table)
+      end
+
+      def to_sql(*args)
+        to_nosql(*args)
+      end
+
+      def execute(query, name='ANSR-DPLA')
+        method = query.path
+        query = query.to_h if Ansr::Dpla::Request === query
+        query = query.dup
+        aliases = query.delete(:aliases)
+        json = @connection.send(method, query)
+        json = json.length > 0 ? JSON.load(json) : {'docs' => [], 'facets' => []}
+        if json['docs'] and aliases
+          json['docs'].each do |doc|
+            aliases.each do |k,v|
+              if doc[k]
+                old = doc.delete(k)
+                if old and doc[v]
+                  doc[v] = Array(doc[v]) if doc[v]
+                  Array(old).each {|ov| doc[v] << ov}
+                else
+                  doc[v] = old
+                end
+              end
+            end
+          end
+        end
+        json
+      end
+
+      def table_exists?(table_name)
+        ['Collection', 'Item'].include? table_name
+      end
+
+      def sanitize_limit(limit_value)
+        if (0..500) === limit_value.to_s.to_i
+          limit_value
+        else
+          Ansr::Relation::DEFAULT_PAGE_SIZE
+        end
+      end
+
+    end
+  end
+ 
+end

data/ansr_dpla/lib/ansr_dpla/model/base.rb

@@ -6,6 +6,13 @@ module Ansr::Dpla
 
   	  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

data/ansr_dpla/lib/ansr_dpla/model/querying.rb

@@ -5,10 +5,14 @@ module Ansr::Dpla
     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(self.config)
+            a.config{|x| x.merge!(self.config)}
             a
           end
         end
@@ -17,16 +21,8 @@ module Ansr::Dpla
           @api = api
         end
 
-        def table
-          @big_table ||= Ansr::Dpla::Arel::BigTable.new(model(), {:config => config()})
-        end
-
-        def table=(val)
-          @big_table = val
-        end
-
         def connection_handler
-          @connection_handler ||= Ansr::Model::ConnectionHandler.new(Ansr::Dpla::Arel::Connection)
+          @connection_handler ||= Ansr::Model::ConnectionHandler.new(Ansr::Dpla::ConnectionAdapters::NoSqlAdapter)
         end
 
         def references

data/ansr_dpla/lib/ansr_dpla/relation.rb

@@ -0,0 +1,61 @@
+require 'yaml'
+require 'blacklight'
+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|
+            Blacklight::SolrResponse::Facets::FacetItem.new(:value => term['term'], :hits => term['count'])
+          end
+          options = {:sort => 'asc', :offset => 0}
+          h[k] = Blacklight::SolrResponse::Facets::FacetField.new k, items, options
+        end
+        h
+      end
+      f
+    end
+
+    def docs_from(response)
+      response['docs']
+    end
+
+  end
+
+
+end

data/ansr_dpla/lib/ansr_dpla/request.rb

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

data/ansr_dpla/spec/lib/api_spec.rb

@@ -9,18 +9,21 @@ describe Ansr::Dpla::Api do
 
     it "should be configurable with a Hash" do
       config_fixture = {:api_key => :foo, :url => :bar}
-      @test.config(config_fixture)
+      @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
-      @test.config(fixture_path('dpla.yml'))
+      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({:url => :foo})}.to raise_error
-      Ansr::Dpla::Api.new.config({:url => :foo, :api_key => :foo})
+      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
@@ -28,7 +31,7 @@ describe Ansr::Dpla::Api do
   describe '#path_for' do
     before do
       @test = Ansr::Dpla::Api.new
-      @test.config({:api_key => :testing})
+      @test.config{|x| x.merge!(:api_key => :testing)}
     end
 
 

data/ansr_dpla/spec/lib/item_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Item do
   describe '.configure' do
     it "should store the configured Api class" do
-    	Item.configure({:api=>Ansr::Dpla::TestApi, :api_key => :dummy})
+    	Item.configure {|x| x.merge!(:api=>Ansr::Dpla::TestApi, :api_key => :dummy)}
     	expect(Item.api).to be_a Ansr::Dpla::TestApi
     end
   end
@@ -25,7 +25,7 @@ describe Item do
 
   describe '.where' do
   	before do
-    	Item.configure({:api=>Ansr::Dpla::TestApi, :api_key => :dummy})
+    	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

data/ansr_dpla/spec/lib/relation/facet_spec.rb

@@ -1,47 +1,55 @@
 require 'spec_helper'
 
-describe Ansr::Relation do
+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({:api_key => :foo})
+    Item.config{ |x| x[:api_key] = :foo}
     Item.engine.api= @mock_api
   end
+
+  subject { Ansr::Dpla::Relation.new(Item, Item.table) }
   describe '#filter' do
-	  it "do a single field, single value filter" do
-	    test = Ansr::Relation.new(Item, Item.table).filter(:object=>'kittens')
-	    @mock_api.should_receive(:items).with(:object => 'kittens', :facets => :object).and_return('')
-	    test.load
+	  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 = Ansr::Relation.new(Item, Item.table).filter(:object=>['kittens', 'cats'])
+	    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 = Ansr::Relation.new(Item, Item.table).filter(:"provider.name"=>'kittens').filter(:"provider.name"=>'cats')
-	    @mock_api.should_receive(:items).with(:"provider.name" => ['kittens','cats'], :facets => :"provider.name").and_return('')
+	    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 = Ansr::Relation.new(Item, Item.table).filter(:object=>'kittens',:isShownAt=>'bears')
-	    @mock_api.should_receive(:items).with(:object => 'kittens', :isShownAt=>'bears', :facets => [:object, :isShownAt]).and_return('')
+	    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 = Ansr::Relation.new(Item, Item.table).filter(:"provider.name"=>'kittens')
+	    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 filtered field" do
-	    test = Ansr::Relation.new(Item, Item.table)
-	    expect {test.filter(:foo=>'kittens')}.to raise_error
+	  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 not require a search value for the filter" do
-      test = Ansr::Relation.new(Item, Item.table).filter(:object)
+    it "should facet without a filter" do
+      test = subject.facet(:object)
       @mock_api.should_receive(:items).with(:facets => :object).and_return('')
       test.load
     end
@@ -52,7 +60,7 @@ describe Ansr::Relation do
       # Blacklight::SolrResponse::Facets::FacetItem.new(:value => s, :hits => v)
       # options = {:sort => 'asc', :offset => 0}
       # Blacklight::SolrResponse::Facets::FacetField.new name, items, options
-      test = Ansr::Relation.new(Item, Item.table).where(:q=>'kittens')
+      test = subject.where(:q=>'kittens')
       @mock_api.should_receive(:items).with(:q => 'kittens').and_return(@faceted)
       test.load
       fkey = test.filters.keys.first
@@ -61,7 +69,7 @@ describe Ansr::Relation do
       facet.items
     end
     it 'should dispatch a query with no docs requested if not loaded' do
-      test = Ansr::Relation.new(Item, Item.table).where(:q=>'kittens')
+      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]