ansr 0.0.1

data/ansr_dpla/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'app/models'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec/autorun'
+require 'loggable'
+require 'ansr'
+require 'ansr_dpla'
+require 'adpla_test_api'
+require 'blacklight'
+require 'item'
+require 'collection'
+
+RSpec.configure do |config|
+
+end
+
+def fixture_path(path)
+  File.join(File.dirname(__FILE__), '..', 'fixtures', path)
+end
+
+def fixture path, &block
+  if block_given?
+    open(fixture_path(path)) &block
+  else
+    open(fixture_path(path))
+  end
+end
+
+def read_fixture(path)
+  _f = fixture(path)
+  _f.read
+ensure
+  _f and _f.close
+end

data/ansr_dpla/test/debug.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'app/models'))
+require 'rails'
+require 'adpla'
+require 'item'
+class Logger
+	def info(msg)
+		puts msg
+	end
+	alias :warn :info
+	alias :error :info
+	alias :debug :info
+end
+
+puts Item.table.inspect

data/ansr_dpla/test/system.rb

@@ -0,0 +1,50 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'app/models'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'ansr_dpla'
+require 'item'
+
+# you config the model with a hash including an API key for dp.la/v2, or the path to a YAML file
+Item.config('config/dpla.yml')
+
+# then you can find single items with known IDs
+puts Item.find("7eb617e559007e1ad6d95bd30a30b16b")
+
+
+# or you can search with ActiveRecord::Relations
+opts = {q: 'kittens', facets: 'sourceResource.contributor'}
+rel = Item.where(opts)
+# this means the results are lazy-loaded, #load or #to_a will load them
+rel.to_a
+# you can also assemble the queries piecemeal with the Relation's decorator pattern
+# the where decorator adds query fields
+# the select decorator adds response fields
+# the limit decorator adds a page size limit
+# the offset decorator adds a non-zero starting point in the response set
+# the filter decorator adds filter/facet fields and optionally values to query them on
+rel = Item.where(q: 'kittens').limit(2).filter('sourceResource.contributor').select('sourceResource.title')
+rel.to_a.each do |item|
+  puts "#{item["id"]} \"#{item['sourceResource.title']}\""
+end
+# the filter values for the query are available on the relation after it is loaded
+rel.filters.each do |k,f|
+  puts "#{k} values"
+  f.items.each do |item|
+    puts "filter:  \"#{item.value}\" : #{item.hits}"
+  end
+end
+# the loaded Relation has attributes describing the response set
+rel.count # the size of the response
+# the where decorator can be negated
+rel = rel.where.not(q: 'cats')
+
+rel.to_a.each do |item|
+  puts "#{item["id"]} \"#{item['sourceResource.title']}\" \"#{item['originalRecord']}\""
+end
+
+rel.filters.each do |k,f|
+  puts "#{k} values"
+  f.items.each do |item|
+    puts "  \"#{item.value}\" : #{item.hits}"
+  end
+end

data/lib/ansr.rb

@@ -0,0 +1,16 @@
+require 'active_support'
+module Ansr
+  extend ActiveSupport::Autoload
+  eager_autoload do
+    autoload :Configurable
+    autoload :Arel
+    autoload :Base
+    autoload :Model
+    autoload :Sanitization
+    autoload :Relation
+    autoload_under 'relation' do
+      autoload :ArelMethods
+      autoload :QueryMethods
+    end
+  end
+end

data/lib/ansr/arel.rb

@@ -0,0 +1,5 @@
+module Ansr
+  module Arel
+    require 'ansr/arel/big_table'
+  end
+end

data/lib/ansr/arel/big_table.rb

@@ -0,0 +1,24 @@
+module Ansr
+  module Arel
+  	class BigTable < ::Arel::Table
+      attr_reader :fields, :facets, :sorts
+
+      include Ansr::Configurable
+
+      attr_reader :klass
+      alias :model :klass
+
+      def initialize(klass, engine=nil)
+        super(klass.name, engine.nil? ? klass.engine : engine)
+        @klass = klass.model
+        @fields = []
+        @facets = []
+        @sorts = []
+      end
+
+      def view?
+        Ansr::Model::ViewProxy === model()
+      end
+    end
+  end
+end

data/lib/ansr/base.rb

@@ -0,0 +1,29 @@
+module Ansr
+  class Base < ActiveRecord::Base
+    extend Ansr::Model::Methods
+    extend Ansr::Configurable
+    extend Ansr::QueryMethods
+    extend Ansr::ArelMethods
+    include Ansr::Sanitization
+
+    self.abstract_class = true
+    
+    def initialize doc={}, options={}
+      super(filter_source_hash(doc), options)
+      @source_doc = doc
+    end
+
+    def filter_source_hash(doc)
+      fields = self.class.model().table().fields()
+      filtered = doc.select do |k,v|
+        fields.include? k.to_sym 
+      end
+      filtered.with_indifferent_access
+    end
+
+    def [](key)
+      @source_doc[key]
+    end
+
+  end
+end

data/lib/ansr/configurable.rb

@@ -0,0 +1,20 @@
+module Ansr
+  module Configurable
+    def config(yaml=nil)
+      yaml ? @config ||= begin
+        y = begin
+          case yaml
+          when String
+            File.open(yaml) {|blob| YAML.load(blob)}
+          else
+            yaml
+          end
+        end
+        y
+      end : @config
+    end
+
+    alias_method :configure, :config
+
+  end
+end

data/lib/ansr/model.rb

@@ -0,0 +1,159 @@
+module Ansr
+  module Model
+  	module Methods
+      def spawn
+        s = Ansr::Relation.new(model(), table())
+        s.references!(references())
+      end
+
+      def inherited(subclass)
+        super
+        # a hack for sanitize sql overrides to work, and some others where @klass used in place of klass()
+        subclass.instance_variable_set("@klass", subclass)
+        # a hack for the intermediate abstract model classes to work with table_name
+        subclass.instance_variable_set("@table_name", subclass.name)
+      end
+
+      def model
+        m = begin
+          instance_variable_get "@klass"
+        end
+        raise "#{name()}.model() -> nil" unless m
+        m
+      end
+
+      def references
+        []
+      end
+
+      def table
+        raise 'Implementing classes must provide a BigTable reader'
+      end
+
+      def table=(table)
+        raise 'Implementing classes must provide a BigTable writer'
+      end
+
+      def engine
+        model()
+      end
+
+	    def model
+	      @klass
+	    end
+
+	    def build_default_scope
+        Ansr::Relation.new(model(), table())
+	    end
+
+      def view(*wheres)
+        return ViewProxy.new(model(), *wheres)
+      end
+    end
+
+    class ViewProxy
+      attr_accessor :model
+      def initialize(model, *wheres)
+        if ViewProxy === model
+          @model = model.model
+          self.constraints = Array(model.constraints)
+          self.projections = model.projections.dup
+        else
+          @model = model
+        end
+        if wheres[0]
+          self.constraints = self.constraints + wheres
+        end
+      end
+
+      def view_arel(engine, table)
+        arel = ::Arel::SelectManager.new(engine, table)
+        constraints.each {|c| arel.where(c) }
+        arel.project projections()
+        arel
+      end
+
+      def find_by_nosql(arel, bind_values)
+        filter_context = nil
+        if self.view?
+          filter_context = view_arel(arel.engine, arel.source.left)
+          arel = arel.intersect filter_context
+        end
+        model.find_by_nosql(arel, bind_values)
+      end
+
+      def expand_hash_conditions_for_aggregates(attrs)
+        # this is a protected method in the AR sanitization module
+        model.send(:expand_hash_conditions_for_aggregates, attrs)
+      end
+
+      def constraints
+        @constraints ||= []
+      end
+
+      def constraints=(values)
+        @constraints = Array === (values) ? values : Array(values)
+      end
+
+      def projections
+        @projections ||= []
+      end
+
+      def projections=(values)
+        @projections = Array === (values) ? values : Array(values)
+      end
+
+      def view?
+        (@constraints and @constraints.length > 0) or (@projections and @projections.length > 0)
+      end
+
+      def view(*wheres)
+        ViewProxy.new(self, wheres)
+      end
+
+      def self.===(other)
+        other.is_a? ViewProxy
+      end
+
+      def connection_handler=(handler)
+        @connection_handler = handler
+      end
+
+      def build_default_scope
+        model().all
+      end
+
+      # model delegations
+      def connection
+        model().connection
+      end
+
+      def name
+        model().name
+      end
+
+      def table
+        model().table
+      end
+
+      def arel_table
+        model().arel_table
+      end
+
+      def current_scope=(scope)
+        model().current_scope=(scope)
+      end
+
+      def current_scope
+        model().current_scope
+      end
+
+      def method_missing(method, *args, &block)
+        model().send(method, *args, &block)
+      end
+    end
+
+    require 'ansr/model/connection'
+    require 'ansr/model/connection_handler'
+  end
+end

data/lib/ansr/model/connection.rb

@@ -0,0 +1,103 @@
+module Ansr
+	module Model
+    class Connection
+      def initialize(klass)
+        @table = klass.table
+      end
+
+      def primary_key(table_name)
+        'id'
+      end
+
+      def limit(arel_node)
+        case arel_node
+        when ::Arel::SelectManager
+          arel_node.limit
+        when ::Arel::Nodes::SelectStatement
+          arel_node.limit && arel_node.limit.expr
+        else
+          nil
+        end
+      end
+
+      def offset(arel_node)
+        case arel_node
+        when ::Arel::SelectManager
+          arel_node.offset
+        when ::Arel::Nodes::SelectStatement
+          arel_node.offset && arel_node.offset.expr
+        else
+          nil
+        end
+      end
+
+      def constraints(arel_node)
+        case arel_node
+        when ::Arel::SelectManager
+          arel_node.constraints
+        when ::Arel::Nodes::SelectStatement
+          arel_node.cores.last.wheres
+        else
+          nil
+        end
+      end
+
+      def projections(arel_node)
+        case arel_node
+        when ::Arel::SelectManager
+          arel_node.projections
+        when ::Arel::Nodes::SelectStatement
+          arel_node.cores.last.projections
+        else
+          nil
+        end
+      end        
+
+      def orders(arel_node)
+        case arel_node
+        when ::Arel::SelectManager
+          arel_node.orders
+        when ::Arel::Nodes::SelectStatement
+          arel_node.orders
+        else
+          nil
+        end
+      end        
+
+      def schema_cache
+        ActiveRecord::ConnectionAdapters::SchemaCache.new(self)
+      end
+
+      def table_exists?(table_name)
+        true
+      end
+
+      # this is called by the BigTable impl
+      def columns(table_name, *rest)
+        @table.fields.map {|s| ::ActiveRecord::ConnectionAdapters::Column.new(s.to_s, nil, nil)}
+      end
+
+      def sanitize_limit(limit_value)
+        if limit_value.to_s.to_i >= 0
+          limit_value
+        else
+          Ansr::Relation::DEFAULT_PAGE_SIZE
+        end
+      end
+
+      def sanitize_filter_name(filter_value)
+        if filter_value.is_a? Array
+          return filter_value.collect {|x| sanitize_filter_name(x)}.compact
+        else
+          if @table.facets.include? filter_value.to_sym
+            return filter_value
+          else
+            raise "#{filter_value} is not a facetable field"
+            #Rails.logger.warn "Ignoring #{filter_value} (not a filterable field)" if Rails.logger
+            #return nil
+          end
+        end
+      end
+    end
+  end
+end