gsa 0.5.0

data/lib/gsa/feeder.rb

@@ -0,0 +1,19 @@
+module GSA
+  class Feeder
+    extend Filer
+    
+    def self.feed(file_name, datasource_name)
+
+      file = open_file(file_name)
+
+      RestClient.post(
+        "#{GSA.base_uri}#{GSA::FEED_EXTENSION}", 
+        {
+          :feedtype   => GSA::FEED_TYPE, 
+          :datasource => datasource_name, 
+          :data       => file.read
+        }
+      )
+    end
+  end
+end

data/lib/gsa/modules/filer.rb

@@ -0,0 +1,26 @@
+module GSA
+  module Filer
+    
+    def build_xml_file(file_name, contents)
+      close_file(
+        add_content_to_file(new_file(file_name), contents)
+      ).path
+    end
+
+    def new_file(file_name)
+      File.new("#{file_name}.xml", "w")
+    end
+
+    def open_file(file_name)
+      File.open(file_name)
+    end
+
+    def add_content_to_file(file, content)
+      file.puts(content); file
+    end
+
+    def close_file(file)
+      file.close; file
+    end
+  end
+end

data/lib/gsa/modules/injector.rb

@@ -0,0 +1,16 @@
+module GSA
+  module Injector
+    
+    def inject_s(items, &block)
+      inject("", items, &block)
+    end
+
+    def inject_a(items, &block)
+      inject([], items, &block)
+    end
+
+    def inject(injected, items, &block)
+      items.each.inject(injected) {|result, item| result << block.call(item)}
+    end
+  end
+end

data/lib/gsa/modules/xmlizer.rb

@@ -0,0 +1,24 @@
+module GSA
+  module XMLizer
+    include Injector
+
+    def xml(content)
+      GSA::XML_TYPE << "\n" << GSA::DOC_TYPE << "\n" << content
+    end
+
+    # for single-line tags
+    def tag(tag, attributes={})
+      "<#{tag.to_s}#{attributor(attributes)}/>\n"
+    end
+
+    # for container tags
+    def block(tag, value, attributes={})
+      "<#{tag.to_s}#{attributor(attributes)}>\n" << value.to_s << "</#{tag.to_s}>\n"
+    end
+
+    # for creating attributes on tags
+    def attributor(attributes)
+      inject_s(attributes) {|key, value| " #{key.to_s}='#{value.to_s}'"}
+    end
+  end
+end

data/lib/gsa/records_converter.rb

@@ -0,0 +1,61 @@
+module GSA
+  class RecordsConverter
+    extend XMLizer
+    extend Injector
+    extend Filer
+
+    def self.convert(args)
+      records         = args[:records]
+      file_name       = args[:file_name]
+      searchable      = args[:searchable]
+      datasource_name = args[:datasource_name]
+      datasource_uri  = args[:datasource_uri]
+      datasource_uid  = args[:datasource_uid]
+      action          = args[:delete?] ? GSA::DELETE_ACTION : GSA::ADD_ACTION
+
+      # if there is only one record, convert to the expected array.
+      records = [records] if records.is_a? Hash
+
+      build_xml_file(file_name, layout(records, searchable, datasource_name, datasource_uri, datasource_uid, action))
+    end
+
+    #######
+    private
+    #######
+
+    def self.layout(records, searchable, datasource_name, datasource_uri, datasource_uid, action)
+      xml(
+        block(:gsafeed,
+              block(:header,
+                    block(:datasource, datasource_name) << 
+                    block(:feedtype, GSA::FEED_TYPE)
+              ) <<
+              block(:group, 
+                record_blocks(records, searchable, datasource_uri, datasource_uid), 
+                {:action => action}
+              )
+        )
+      )
+    end
+
+    def self.record_blocks(records, searchable, datasource_uri, datasource_uid)
+      inject_s(records) {|record| record_block(record, searchable, datasource_uri, datasource_uid)}
+    end
+
+    def self.record_block(record, searchable, datasource_uri, datasource_uid)
+      block(:record,
+        block(:metadata, record_metadata(record)) <<
+        block(:content, record_searchable(record, searchable)),
+        {:url => "#{datasource_uri}/#{record[datasource_uid]}", :mimetype => GSA::MIME_TYPE} # ABSTRACT URL STRING VALUE (id)
+      )
+    end
+
+    def self.record_searchable(record, searchable)
+      inject_s(searchable) {|search| " #{record[search.to_s]}"}
+    end
+
+    def self.record_metadata(record)
+      inject_s(record) {|key, value| tag(:meta, {:name => key, :content => value})}
+    end
+  end
+end

data/lib/gsa/search_converter.rb

@@ -0,0 +1,41 @@
+module GSA
+  class SearchConverter
+    extend Injector
+
+    def self.convert(convertable)
+      parse result_sets_from results_param_in convertable
+    end
+
+    def self.results_param_in(convertable)
+      convertable[GSA::GOOGLE_SEARCH_PROTOCOL][GSA::RESULTS]
+    end
+
+    def self.result_sets_from(results)
+      (results.keep_if {|key, value| key == GSA::RESULT })[GSA::RESULT]
+    end
+
+    def self.parse(result_sets)
+
+      # if there is only one result, convert to the expected array.
+      result_sets = [result_sets] if result_sets.is_a? Hash
+
+      inject_a(result_sets) {|set|
+        { 
+          :result_number          => set[GSA::RESULT_NUMBER], 
+          :url                    => set[GSA::URL],
+          :title                  => set[GSA::TITLE],
+          :metatags               => parse_metatags(set[GSA::METATAGS]),
+          :search_result_snippet  => set[GSA::SEARCH_RESULT_SNIPPET]
+        }
+      }
+    end
+
+    def self.parse_metatags(metatags)
+      inject_a(metatags) {|meta_pair| convert_meta_pair(meta_pair) }
+    end
+
+    def self.convert_meta_pair(meta_pair)
+      {:meta_name => meta_pair[GSA::META_NAME], :meta_value => meta_pair[GSA::META_VALUE]}
+    end
+  end
+end

data/lib/gsa/searcher.rb

@@ -0,0 +1,32 @@
+module GSA
+  class Searcher
+    def self.search(query, args={})
+      query           = clean_query(query)
+      filter          = args[:filter]    || GSA::DEFAULT_FILTER
+      getfields       = args[:getfields] || GSA::DEFAULT_GETFIELDS
+      sort            = args[:sort]      || GSA::DEFAULT_SORT
+      num             = args[:num]       || GSA::DEFAULT_NUM  
+      output          = args[:output]    || GSA::DEFAULT_OUTPUT
+      requiredfields  = args[:filters]   || nil
+
+      search = "#{GSA.base_uri}/search?q=#{query}&filter=#{filter}&getfields=#{getfields}&sort=#{sort}&num=#{num}&output=#{output}"
+      search = "#{search}&requiredfields=#{clean_query(requiredfields)}" if requiredfields
+
+      search_results = parsed_json( RestClient.get(search) )
+
+      results_found?(search_results) ? search_results : GSA::NO_RESULTS
+    end
+
+    def self.clean_query(query)
+      query.tr(' ', '+')
+    end
+
+    def self.parsed_json(xml)
+      JSON.parse(Hash.from_xml(xml).to_json)
+    end
+
+    def self.results_found?(search_results)
+      search_results[GSA::GOOGLE_SEARCH_PROTOCOL].has_key? GSA::RESULTS
+    end
+  end
+end

data/lib/gsa/uid_extractor.rb

@@ -0,0 +1,24 @@
+module GSA
+  class UIDExtractor
+    def self.extract(search_results, uid)
+      iterate_results([], search_results, uid)
+    end
+
+    def self.iterate_results(uids, search_results, uid)
+      search_results.each {|result| get_uids_from_record(uids, result, uid)}
+      uids
+    end
+
+    def self.get_uids_from_record(uids, record, uid)
+      record[:metatags].each {|tag| add_uid(uids, tag) if uid?(tag, uid)}
+    end
+
+    def self.add_uid(uids, meta_tag)
+      uids << meta_tag[:meta_value]
+    end
+
+    def self.uid?(tag, uid)
+      tag[:meta_name] == uid
+    end
+  end
+end

data/lib/gsa/version.rb

@@ -0,0 +1,3 @@
+module GSA
+  VERSION = "0.5.0"
+end

data/spec/fixtures.rb

@@ -0,0 +1,73 @@
+module Fixtures
+  def many_records
+    read 'fixtures/feeds/15_records.txt'
+  end
+
+  def one_records
+    read 'fixtures/feeds/1_records.txt'
+  end
+
+  def many_query
+    read 'fixtures/queries/many.txt'
+  end
+
+  def one_query
+    read 'fixtures/queries/single.txt'
+  end
+
+  def none_query
+    read 'fixtures/queries/none.txt'
+  end
+
+  def many_results
+    read 'fixtures/result_sets/many.txt'
+  end
+
+  def one_results
+    read 'fixtures/result_sets/single.txt'
+  end
+
+  def many_facets
+    read 'fixtures/facets/many.txt'
+  end
+
+  def one_facets
+    read 'fixtures/facets/single.txt'
+  end
+
+  def many_facet_results
+    read 'fixtures/result_sets/many_facets.txt'
+  end
+
+  def one_facet_results
+    read 'fixtures/result_sets/single_facets.txt'
+  end
+
+  def many_uids
+    read 'fixtures/uids/many.txt'
+  end
+
+  def one_uids
+    read 'fixtures/uids/single.txt'
+  end
+
+  def success_text
+    "Success"
+  end
+
+  def uid
+    "id"
+  end
+
+  def gsa_base_uri
+    "http://dev-gsa.1000bulbs.com"
+  end
+
+  #######
+  private
+  #######
+
+  def read(file_path)
+    eval(File.read(file_path))
+  end
+end

data/spec/lib/gsa_spec.rb

@@ -0,0 +1,318 @@
+require 'spec_helper'
+
+describe GSA do
+  include Fixtures
+
+  before(:each) do
+    GSA.base_uri = gsa_base_uri
+  end
+
+  describe "#feed" do
+
+    context "add" do
+
+      context "many records" do
+
+        it "successfully adds the records to the gsa index" do
+          VCR.use_cassette("many_records") do
+            results = GSA.feed(
+              :file_name       => "out", :records => many_records, 
+              :searchable      => [:name, :description], 
+              :datasource_name => "products",
+              :datasource_uri  => "http://0.0.0.0:3000/products",
+              :datasource_uid  => "id"
+            )
+            results.should eq success_text
+          end
+        end
+      end
+
+      context "a single record" do
+
+        it "successfully adds the records to the gsa index" do
+          VCR.use_cassette("single_record") do
+            results = GSA.feed(
+              :file_name       => "out", :records => many_records, 
+              :searchable      => [:name, :description], 
+              :datasource_name => "products",
+              :datasource_uri  => "http://0.0.0.0:3000/products",
+              :datasource_uid  => "id"
+            )
+            results.should eq success_text
+          end
+        end
+      end
+    end
+
+    context "delete" do
+
+      context "many records" do
+
+        it "successfully deletes the records from the gsa index" do
+          VCR.use_cassette("delete_many_records") do
+            results = GSA.feed(
+              :file_name       => "out", :records => many_records, 
+              :searchable      => [:name, :description], 
+              :datasource_name => "products",
+              :datasource_uri  => "http://0.0.0.0:3000/products",
+              :datasource_uid  => "id",
+              :delete?         => true
+            )
+            results.should eq success_text
+          end
+        end
+      end
+
+      context "a single record" do
+
+        it "successfully deletes the record from the gsa index" do
+          VCR.use_cassette("delete_single_record") do
+            results = GSA.feed(
+              :file_name       => "out", 
+              :records         => one_records, 
+              :searchable      => [:name, :description], 
+              :datasource_name => "products",
+              :datasource_uri  => "http://0.0.0.0:3000/products",
+              :datasource_uid  => "id",
+              :delete?         => true
+            )
+            results.should eq success_text
+          end
+        end
+      end
+    end
+
+    context "without a base_uri set" do
+
+      before(:each) do
+        GSA.base_uri = nil
+      end
+
+      it "raises an error" do
+        expect { 
+
+          GSA.feed(
+            :file_name       => "out", 
+            :records         => one_records, 
+            :searchable      => [:name, :description], 
+            :datasource_name => "products",
+            :datasource_uri  => "http://0.0.0.0:3000/products",
+            :datasource_uid  => "id",
+            :delete?         => true
+          ) 
+          
+        }.to raise_error GSA::URINotSetError
+      end
+    end
+  end
+
+  describe "#search" do
+
+    context "with no filters" do
+
+      context "with a query yielding many matches" do
+
+        let(:query)       { many_query }
+        let(:results_set) { many_results }
+
+        it "returns many records" do
+          VCR.use_cassette("many_results_no_filters") do
+            results = GSA.search(query)
+            results.count.should eq results_set.count
+          end
+        end
+
+        it "returns results in the expected 'pretty' format" do
+          VCR.use_cassette("many_results_no_filters") do
+            results = GSA.search(query)
+            results.should eq results_set
+          end
+        end
+      end
+
+      context "with a query yielding a single match" do
+
+        let(:query)      { one_query }
+        let(:result_set) { one_results }
+
+        it "returns a single record" do
+          VCR.use_cassette("single_result_no_filters") do
+            results = GSA.search(query)
+            results.count.should eq 1
+          end
+        end
+
+        it "returns the single result in the expected 'pretty' format" do
+          VCR.use_cassette("single_result_no_filters") do
+            results = GSA.search(query)
+            results.should eq result_set
+          end
+        end
+      end
+
+      context "with a query yielding no matches" do
+
+        let(:query) { none_query }
+
+        it "returns the no record flag" do
+          VCR.use_cassette("no_result_no_filters") do
+            results = GSA.search(query)
+            results.should eq GSA::NO_RESULTS
+          end
+        end
+      end
+    end
+
+    context "with filters" do
+
+      context "with a query yielding many results" do
+
+        let(:query)        { many_query }
+        let(:results_set)  { many_results }
+        let(:filter_name)  { "brand" }
+        let(:filter_value) { "Philips" }
+        let(:filters)      { "#{filter_name}:#{filter_value}" }
+
+        it "returns less than the unfiltered results" do
+          VCR.use_cassette("many_results_with_filters") do
+            results = GSA.search(query, :filters => filters)
+            results.count.should be < results_set.count
+          end
+        end
+
+        it "should only contain results matched in the unfiltered results" do
+          VCR.use_cassette("many_results_with_filters") do
+            results = GSA.search(query, :filters => filters)
+
+            filtered_results = []
+            results_set.each {|result| 
+              result[:metatags].each {|tag| 
+                if tag[:meta_name] == filter_name && tag[:meta_value] == filter_value
+                  filtered_results << result
+                end
+              }
+            }
+
+            result_uids   = GSA.uids(results, uid)
+            filtered_uids = GSA.uids(filtered_results, uid)
+            result_uids.should eq filtered_uids
+          end
+        end
+      end
+
+      context "with a query yielding a single result" do
+
+        let(:query)          { many_query }
+        let(:results_set)    { many_results }
+        let(:filter_1_name)  { "brand" }
+        let(:filter_1_value) { "Philips" }
+        let(:filter_2_name)  { "material" }
+        let(:filter_2_value) { "Brass" }
+        let(:filters)        { "#{filter_1_name}:#{filter_1_value}.#{filter_2_name}:#{filter_2_value}" }
+
+        it "returns a single filtered result" do
+          VCR.use_cassette("single_result_with_filters") do
+            results = GSA.search(query, :filters => filters)
+            results.count.should eq 1
+          end
+        end
+
+        it "returns a result with the expected matching filters" do
+          VCR.use_cassette("single_result_with_filters") do
+            results = GSA.search(query, :filters => filters)
+
+            results.each.inject([]) {|flags, result| result[:metatags].each {|tag|
+                flags << 1 if tag[:meta_name] == filter_1_name && tag[:meta_value] == filter_1_value
+                flags << 1 if tag[:meta_name] == filter_2_name && tag[:meta_value] == filter_2_value
+              }
+              flags
+            }.should eq [1, 1]
+          end
+        end
+      end
+
+      context "with a query yielding no results" do
+
+        let(:query)   { many_query }
+        let(:filters) { "brand:FooBar" }
+
+        it "returns the no record flag" do
+          VCR.use_cassette("no_result_with_filters") do
+            results = GSA.search(query, :filters => filters)
+            results.should eq GSA::NO_RESULTS
+          end
+        end
+      end
+
+      context "without a base_uri set" do
+
+        let(:query)   { many_query }
+        let(:filters) { "brand:Philips" }
+
+        before(:each) do
+          GSA.base_uri = nil
+        end
+
+        it "raises an error" do
+          expect { 
+
+            GSA.search(query, :filters => filters) 
+
+          }.to raise_error GSA::URINotSetError
+        end
+      end
+    end
+  end
+
+  describe "#facet" do
+
+    let(:results_set) { many_results }
+
+    context "with multiple facets" do
+
+      let(:facetables)    { many_facets }
+      let(:facet_results) { many_facet_results }
+
+      it "returns multiple facets in the expected form" do
+        results = GSA.facet(results_set, facetables)
+        results.should eq facet_results
+      end
+    end
+
+    context "with a single facet" do
+
+      let(:facetables)    { one_facets }
+      let(:facet_results) { one_facet_results }
+
+      it "returns a single facet in the expected form" do
+        results = GSA.facet(results_set, facetables)
+        results.should eq facet_results
+      end
+    end
+  end
+
+  describe "#uids" do
+
+    context "with multiple records passed in" do
+
+      let(:results_set) { many_results }
+      let(:uids)        { many_uids }
+
+      it "returns multiple uids" do
+        results = GSA.uids(results_set, uid)
+        results.should eq uids
+      end
+    end
+
+    context "with a single record passed in" do
+
+      let(:results_set) { one_results }
+      let(:uids)        { one_uids }
+
+      it "returns a single uid" do
+        results = GSA.uids(results_set, uid)
+        results.should eq uids
+      end
+    end
+  end
+end