Use custom class to handle autocomplete loading

Author: subbarao

.gitignore

@@ -10,3 +10,4 @@
 /spec/reports/
 /tmp/
 vendor
+.byebug_history

Guardfile

@@ -0,0 +1,17 @@
+guard :rspec, cmd: "bundle exec rspec --color --format documentation" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+  watch(%r{^spec/(.*)\/?(.*)_spec\.rb$})
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

lib/trample.rb

@@ -3,9 +3,11 @@
 require "trample/version"
 require "trample/aggregation"
 require "trample/serializable"
+require "trample/lookup_not_found"
 require "trample/condition"
 require "trample/condition_proxy"
 require "trample/metadata"
+require "trample/text_lookup"
 require "trample/search"
 require "trample/backend/searchkick"
 require "trample/results"

lib/trample/condition.rb

@@ -1,7 +1,6 @@
 module Trample
   class Condition
     include Virtus.model
-
     attribute :name, Symbol
     attribute :query_name, Symbol, default: :name
     attribute :values, Array
@@ -20,12 +19,32 @@ class Condition
     attribute :fields, Array
     attribute :user_query, Hash
     attribute :transform, Proc, default: ->(_,_) { ->(val) { val } }
+    attribute :search_klass
+    attribute :lookup, Hash
 
     def initialize(attrs)
       attrs.merge!(single: true) if attrs[:name] == :keywords
       super(attrs)
     end
 
+    def lookup_autocomplete
+      if require_autocomplete_lookup?
+        options = (lookup || {}).dup
+        klass   = options.delete(:klass) || '::Trample::TextLookup'
+
+        options.assert_valid_keys(:key, :label)
+
+        options = options.merge({
+          search_klass: search_klass,
+          condition_name: name
+        })
+
+        lookup_instance = klass.to_s.constantize.new(options)
+
+        self.values = lookup_instance.load(values) 
+      end
+    end
+
     def blank?
       values.reject { |v| v == "" || v.nil? }.empty? && !range?
     end
@@ -204,5 +223,10 @@ def to_range_query
 
       { runtime_query_name => hash }
     end
+
+    def require_autocomplete_lookup?
+      (values.present? && values.first.is_a?(Hash)) && 
+        values.any? { |v| v[:text].blank? }
+    end
   end
 end

lib/trample/lookup_not_found.rb

@@ -0,0 +1,37 @@
+module Trample
+  class LookupNotFoundError < StandardError
+
+    attr_reader :condition, :lookup_results, :corresponding_lookup
+
+    def initialize(condition, lookup_results, corresponding_lookup)
+      @condition = condition
+      @lookup_results = lookup_results
+      @corresponding_lookup = corresponding_lookup
+      super(message)
+    end
+
+    def message
+      msg = <<-MSG.strip_heredoc
+            No corresponding lookup found for condition #{condition.name}
+
+            Corresponding Lookup Result: #{ corresponding_lookup }
+
+            Criteria Keys:        #{ criteria_keys.join(", ") }
+            Lookup Result Keys:   #{ lookup_keys.join(", ") }
+            Missing:              #{ diff.join(", ") }
+            MSG
+    end
+
+    def criteria_keys
+      @criteria_keys ||= Array(condition.values).map { |l| l[:key] }.sort
+    end
+
+    def lookup_keys
+      @lookup_keys ||= Array(lookup_results).map {|l| l[:key] }.sort
+    end
+
+    def diff
+      criteria_keys - lookup_keys
+    end
+  end
+end

lib/trample/search.rb

@@ -23,7 +23,8 @@ def self.inherited(klass)
     end
 
     def self.condition(name, attrs = {})
-      attrs.merge!(name: name)
+      attrs.merge!(name: name, search_klass: self)
+
       @_conditions[name] = Condition.new(attrs)
     end
 
@@ -133,9 +134,12 @@ def backend
       @backend ||= Backend::Searchkick.new(metadata, self.class._models)
     end
 
-    def query!
+    def query!(options = { lookup: true })
       @records = nil
       hash = backend.query!(conditions, aggregations)
+
+      load_autocompletes if options[:lookup]
+
       self.metadata.took = hash[:took]
       self.metadata.scroll_id = hash[:scroll_id]
       self.metadata.pagination.total = hash[:total]
@@ -191,5 +195,8 @@ def deep_dup(o)
       Marshal.load(Marshal.dump(o))
     end
 
+    def load_autocompletes
+      self.conditions.values.each(&:lookup_autocomplete)
+    end
   end
 end

lib/trample/text_lookup.rb

@@ -0,0 +1,27 @@
+module Trample
+  class TextLookup
+    include Virtus.model
+    attribute :search_klass
+    attribute :condition_name,  Symbol
+    attribute :key,             Symbol, default: :id
+    attribute :label,           Symbol, default: :text
+
+    def load(values)
+      search = search_klass.new
+      search.condition(condition_name).in(values)
+      search.query!(lookup: false)
+
+      values.map do | value |
+        result = find_corresponding_value(value, search.results)
+        value[:text] = result[label]
+        value
+      end
+    end
+
+    private 
+
+    def find_corresponding_value(value, results)
+      results.find { |result| value[:key].to_s == result[key].to_s  }
+    end
+  end
+end

spec/condition_spec.rb

@@ -5,6 +5,81 @@
   let(:attrs)    { {} }
   let(:instance) { described_class.new(attrs) }
 
+  class Myklass
+    include Virtus.model
+    def load(values)
+      []
+    end
+  end
+
+  describe "#lookup_autocomplete" do
+    context "with custom default lookup klass" do
+      before do
+        attrs[:lookup] = { key: :test_id, label: :test_label, klass: :Myklass }
+      end
+      it "should load autocomplete labels using custom klass" do
+        results = [{key: 2, text: "two"}, {key: 4, text: "four"}]
+        expect(Myklass).to receive(:new).and_return(double(load: results))
+        instance.values = [{key: 2}, {key: 4}]
+        instance.lookup_autocomplete
+
+        expect(instance.values).to eql(results)
+      end
+    end
+
+    context "with default lookup klass" do
+      before do
+        attrs[:lookup] = { key: :test_id, label: :test_label }
+      end
+      context "when all values has missing text key" do
+        context "when all labels are missing" do
+          it "should load autocomplete labels" do
+            results = [{key: 2, text: "two"}, {key: 4, text: "four"}]
+            expect(Trample::TextLookup).to receive(:new).and_return(double(load: results))
+            instance.values = [{key: 2}, {key: 4}]
+            instance.lookup_autocomplete
+
+            expect(instance.values).to eql(results)
+          end
+        end
+
+        context "when any labels are missing" do
+          it "should load autocomplete labels" do
+            results = [{key: 2, text: "two"}, {key: 4, text: "four"}]
+            expect(Trample::TextLookup).to receive(:new).and_return(double(load: results))
+            instance.values = [{key: 2, text: "two"}, {key: 4}]
+            instance.lookup_autocomplete
+
+            expect(instance.values).to eql(results)
+          end
+        end
+
+        context "when all labels are present" do
+          it "should not load autocomplete labels" do
+            expect(Trample::TextLookup).not_to receive(:new)
+            instance.values = [{key: 2, text: "two"}, {key: 4, text: "four"}]
+            instance.lookup_autocomplete
+          end
+        end
+
+        context "when condition is not autocomplete type" do
+          it "should not load autocomplete labels" do
+            expect(Trample::TextLookup).not_to receive(:new)
+            instance.values = ['test']
+            instance.lookup_autocomplete
+          end
+        end
+
+        context "when condition value is blank" do
+          it "should not load autocomplete labels" do
+            expect(Trample::TextLookup).not_to receive(:new)
+            instance.lookup_autocomplete
+          end
+        end
+      end
+    end
+  end
+
   describe "#as_json" do
     context "when single-value" do
       before do
@@ -45,5 +120,4 @@
       end
     end
   end
-
 end

spec/integration/search_spec.rb

@@ -1,6 +1,16 @@
 require 'spec_helper'
 
 RSpec.describe "searching", elasticsearch: true do
+  class MyLookup
+    include Virtus.model
+
+    def load(values)
+      values.map do | value |
+        value[:text] = "#{value[:key]} - test"
+        value
+      end
+    end
+  end
 
   let(:klass) do
     Class.new(Trample::Search) do
@@ -14,20 +24,59 @@
       condition :_name_prefix, query_name: :name, prefix: true
 
       condition :simple_name, query_name: 'name', single: true
+      condition :company_ids, query_name: 'company_id', 
+                              lookup: { 
+                                key: :company_id, 
+                                label: :company_name 
+                              }
+      condition :company_custom_ids, query_name: 'company_id', 
+                              lookup: { 
+                                key: :company_id, 
+                                label: :company_name,
+                                klass: 'MyLookup'
+                               }
     end
   end
 
   before do
     Searchkick.client.indices.delete index: '_all'
-    Person.create!(name: 'Homer', tags: ['funny', 'stupid', 'bald'], age: 38)
-    Person.create!(name: 'Lisa', tags: ['funny', 'smart', 'kid'], age: 8)
-    Person.create!(name: 'Marge', tags: ['motherly'], age: 34)
-    Person.create!(name: 'Bart', tags: ['funny', 'stupid', 'kid'], age: 10)
+    foo = Company.create!(name: 'Foo Inc')
+    bar = Company.create!(name: 'Bar Inc')
+    apex = Company.create!(name: 'Apex Inc')
+    Person.create!(name: 'Homer', tags: ['funny', 'stupid', 'bald'], age: 38, company: foo)
+    Person.create!(name: 'Lisa', tags: ['funny', 'smart', 'kid'], age: 8, company: bar)
+    Person.create!(name: 'Marge', tags: ['motherly'], age: 34, company: foo)
+    Person.create!(name: 'Bart', tags: ['funny', 'stupid', 'kid'], age: 10, company: apex)
     Person.reindex
 
     klass.model(Person)
   end
 
+  it "should fetch autocomplete labels by default" do
+    search = klass.new
+    search.condition(:company_ids).in([{key: Company.first.id.to_s}, { key: Company.last.id.to_s, text: Company.last.name  }])
+    search.query!
+
+    expect(search.conditions.as_json['company_ids'][:values]).to eq([{:key=>"1", :text=>"Foo Inc"}, {:key=>"3", :text=>"Apex Inc"}])
+  end
+
+  it "should not fetch autocomplete labels when lookup: false" do
+    search = klass.new
+    values = [{key: Company.first.id.to_s}, { key: Company.last.id.to_s, text: Company.last.name  }]
+    search.condition(:company_ids).in(values)
+    search.query!(lookup: false)
+
+    expect(search.conditions.as_json['company_ids'][:values]).to eq([{:key=>"1"}, {:key=>"3", :text=>"Apex Inc"}])
+  end
+
+  it "should fetch autocomplete labels using custom lookup_class" do
+    search = klass.new
+    search.condition(:company_custom_ids).in([{key: Company.first.id.to_s}, { key: Company.last.id.to_s, text: Company.last.name  }])
+    search.query!
+
+    expect(search.conditions.as_json['company_custom_ids'][:values]).to eq([{:key=>"1", :text=>"#{Company.first.id} - test"}, {:key=>"3", :text=> "#{Company.last.id} - test"}])
+  end
+
   it "records time the search took" do
     search = klass.new
     search.query!