drawbridge 0.2.0

data/lib/drawbridge/refinement_scrubber.rb

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+module Drawbridge
+  class RefinementScrubber
+
+    def self.scrub(data)
+      Array(data).each do |ref|
+        add_aggrbins_key(ref) if ref['dimensionvalues'].present?
+      end
+    end
+
+    private
+
+    def self.add_aggrbins_key(ref)
+      ref['dimensionvalues'].each do |val|
+        next unless has_aggr_bins?(val)
+        val['dimvalueproperties']['aggrbins'] = val['dimvalueproperties']['dgraph.aggrbins']
+      end
+    end
+
+    def self.has_aggr_bins?(value)
+      props = value['dimvalueproperties']
+      value.present? && props.present? && props['dgraph.aggrbins'].present?
+    end
+
+  end
+end

data/lib/drawbridge/request.rb

@@ -0,0 +1,92 @@
+# -*- encoding: utf-8 -*-require 'oj'
+require 'oj'
+require 'curb'
+
+module Drawbridge
+
+  class Request
+    class RequestError < StandardError; end
+
+    ERROR_CODE = 0
+    ResultsError = {'status' => ERROR_CODE}
+
+    attr_accessor :uri, :query, :timeout
+
+    def self.perform(uri, query, timeout = (Drawbridge.config.timeout || 5))
+      raise RequestError, "Must provide a uri" unless uri
+      new(uri, query, timeout).perform
+    end
+
+    # Initialize
+    # @params: uri
+    # @params: query
+    # @params: timeout
+    def initialize(uri, query, timeout)
+      @uri = uri
+      @query = query
+      @timeout = timeout
+    end
+
+    # Perform HTTP call
+    # @return: json response
+    def perform
+      @perform ||= handle_response get_response
+    end
+
+    private
+
+    # Build full qualified uri
+    # @instance variable: query
+    # @instance variable: uri
+    def full_uri
+      @full_uri ||= query ? URI.escape("#{uri}?#{query}") : uri
+    end
+
+    # Make get request to assembler
+    # @instance variable: full_url
+    # @sucess: json data
+    # @failed: raising RequestError
+    def get_response
+      Drawbridge::Debug.log "ENDECA_QUERY", full_uri
+
+      Curl::Easy.perform(full_uri) do |curl|
+        curl.timeout = timeout
+      end
+    rescue Curl::Err::TimeoutError => e
+      raise e, e.message
+    rescue StandardError => e
+      puts "Request to: #{full_uri} failed: #{e.message}"
+      raise RequestError, e.message
+    end
+
+    # Handle response from assembler
+    # @success: Parse data with Oj gem
+    # @failed: defaul json {'status' => 0}
+    def handle_response(response)
+      case response.response_code.to_s
+      when "200"
+        begin
+          Oj.load(clean_bad_json(response.body_str))
+        rescue Oj::ParseError => e
+          raise RequestError, "JSON Parse error: #{e}"
+        end
+      else
+        puts "Unsuccessful response from #{full_uri}: #{response}\nbody:#{response.body_str unless response.nil?}"
+        Request::ResultsError
+      end
+    end
+
+    private
+
+    def clean_bad_json(str)
+      str.encode!('UTF-16', 'UTF-8', :invalid => :replace, :replace => '')
+      str.encode!('UTF-8', 'UTF-16')
+      str.gsub!("\t",'')
+      str.gsub!("\\ ","\\\\\\ ")
+      str.gsub!(/\'/, "&#39;") unless Drawbridge.config.skip_single_quote_encoding
+      str
+    end
+
+  end
+
+end

data/lib/drawbridge/result.rb

@@ -0,0 +1,146 @@
+module Drawbridge
+  class Result
+
+    attr_accessor :data
+
+    def initialize(params)
+      @data = may_be_success_response params
+    end
+
+    def refinements
+      @refinements ||= RefinementScrubber.scrub(downcased_refinements)
+    end
+
+    def breadcrumbs
+      Array(downcase_element(data["Breadcrumbs"]))
+    end
+
+    def meta_info
+      downcase_element(data["MetaInfo"]) || {}
+    end
+
+    def records
+      @records ||= parse_records_array
+    end
+
+    def status
+      data['status'] || 1
+    end
+
+    def to_stats_hash
+      { meta_info: meta_info, breadcrumbs: breadcrumbs, refinements: refinements }
+    end
+
+    private
+
+    def downcased_refinements
+      downcase_array(@data['Refinements'])
+    end
+
+    def parse_records_array
+      is_aggregate? ? parse_aggregate_records : parse_records
+    end
+
+    def parse_aggregate_records
+      aggregate_records.map { |aggregate_record| merge_derived_properties aggregate_record }
+    end
+
+    def merge_derived_properties(aggregate_record)
+      first_parsed_record = parse_records(aggregate_record["Records"]).first
+      derived_properties  = aggregate_record["DerivedProperties"]
+      first_parsed_record.merge derived_properties
+    end
+
+    def parse_records(records = unaggregate_records)
+      mod_records = records.map do |record|
+        record["Dimensions"].merge record['Properties']
+      end
+      special_handling mod_records
+    end
+
+    def is_aggregate?
+      data.has_key? 'AggrRecords'
+    end
+
+    def aggregate_records
+      Array(data['AggrRecords'])
+    end
+
+    def unaggregate_records
+      Array(data['Records'])
+    end
+
+    def downcase_hash(subject_hash)
+      return {} if subject_hash.nil?
+      subject_hash.each_with_object({}) { |(k, v), h| h[k.downcase] = downcase_element(v) }
+    end
+
+    def downcase_array(subject_array)
+      Array(subject_array).map { |element| downcase_element(element) }
+    end
+
+    def downcase_element(element)
+      if element.instance_of? Array
+        downcase_array element
+      elsif element.instance_of? Hash
+        downcase_hash element
+      else
+        element
+      end
+    end
+
+    def special_handling(records)
+      records.each do |record|
+        record['miles_to_geocode']      = parse_geocode record, 'miles'
+        record['kilometers_to_geocode'] = parse_geocode record, 'kilometers'
+        record['matched_on']            = parse_matched_on record
+      end
+    end
+
+    def parse_geocode(record, units)
+      units_to_geocode = /#{units}_to_geocode/
+      record[record.keys.detect{ |key| key =~ units_to_geocode }]
+    end
+
+    def parse_matched_on(record)
+      whymatch = record['DGraph.WhyDidItMatch']
+      return unless whymatch.to_s.include?(':')
+
+      if whymatch.instance_of? String
+        whymatch_string_to_hash whymatch
+      else
+        whymatch_array_to_hash whymatch
+      end
+    end
+
+    def whymatch_string_to_hash(str)
+      parts = str.split(':').map(&:strip)
+      { parts[0] => parts[1] }
+    end
+
+    def whymatch_array_to_hash(arr)
+      arr.each_with_object({}) do |s, hash|
+        arr = s.split(':').collect(&:strip)
+        hash[arr[0]] = arr[1]
+      end
+    end
+
+    # If Error returned by Endeca, return default structure
+    def may_be_success_response(params)
+      return params unless params['methodResponse']
+
+      status = response_params_contain_fault?(params) ? 404 : 500
+
+      { 'MetaInfo' => {}, 'Refinements' => [], 'Breadcrumbs' => [], 'AggrRecords' => [], 'status' => status }
+    end
+
+    def response_params_contain_fault?(params)
+      fault_string_from_params(params) =~ /HTTP Error 404/i
+    end
+
+    def fault_string_from_params(params)
+      params['methodResponse']['fault']['value']['faultString']
+    end
+
+  end
+end

data/lib/drawbridge/transformer.rb

@@ -0,0 +1,190 @@
+module Drawbridge
+  module Transformer
+    KM = 0.62137
+    PLUS = '+'
+    PIPE = '|'
+
+    def transform(adapter)
+      query = []
+
+      clean_adapter_keys(adapter).keys.each do |key|
+        begin
+          query << send(key, adapter[key])
+        rescue NoMethodError => e
+          raise NoMethodError, "Method #{key} is not supported"
+        end
+      end
+      query.compact!
+
+      Drawbridge::Debug.log "ENDECA PARAMS", query
+
+      query.join('&')
+    end
+
+    private
+
+    def clean_adapter_keys(adapter)
+      return {} if adapter.nil?
+
+      adapter[:rollup] && adapter[:rollup].blank? ?
+        adapter.delete(:aggregate_offset) :
+        adapter.delete(:offset)
+
+      adapter
+    end
+
+    # N - root navigation request, or one or more dimension value ID
+    # N=123+234
+    # @params Array
+    def root_navigtion(filters)
+      filters = [0] if filters.blank?
+
+      "N=#{filters.join(PLUS)}"
+    end
+
+    # Ns - sort keys
+    # @params - Array of Hashes [{'showapartments' => 1}, {'searchonly' => 1}]
+    # Ns=showapartments|1||searchonly|1
+    def order(sort_order)
+      return nil if sort_order.blank?
+
+      separator = '||'
+      sort_arr = []
+      sort_order.each do |item|
+        item.each_pair{|k,v| sort_arr << "#{k}#{PIPE}#{v}"}
+      end
+
+      "Ns=#{sort_arr.join(separator)}"
+    end
+
+    # Nf - Range filter
+    # key|GCLY latitude,longitude radius in Kilometers
+    # @params - Hash {lat: 123, lng: -12, radius: 10}
+    # Nf=geocode|GCLY 42.365615,-71.075647 10
+    def geo_filter(geo)
+      return nil if geo.blank?
+
+      "Nf=#{geo[:field]}|GCLT #{geo[:lat]},#{geo[:lng]} #{geo[:radius]/KM}"
+    end
+
+    # Nf - Range filter
+    # Sets a range filter with one of these formats:
+    # key|LT+number
+    # key|LTEQ+number
+    # key|GT+number
+    # key|GTEQ+number
+    # key|BTWN+num1+num2
+    # Nf=Price|LT+25
+    # Nf=Price|BTWN+8+15
+    # @params Array of hashes.
+    # Hash structure
+    # {
+    #   :field => 'latitude',
+    #   :values => ['30.123', '34.456'],
+    #   :operator => 'BTWN'
+    # }
+    def range_filter(filters)
+      return nil if filters.blank?
+
+      filters.map! do |filter|
+        values = filter[:values].join(PLUS)
+        "#{filter[:field]}#{PIPE}#{filter[:operator]}#{PLUS}#{values}"
+      end
+
+      "Nf=#{filters.join(PIPE)}"
+    end
+
+    # Ne - indicating which dimension navigation refinements will be exposed
+    # @params - Array [123, 345, 678]
+    # Ne=123+345+678
+    def expand_refinements(refinements)
+      return nil if refinements.blank?
+
+      "Ne=#{refinements.join(PLUS)}"
+    end
+
+    # Ntk - Search filters key
+    # Ntt - Search filters term
+    # Ntk=showapartments|showcollege&Ntt=1|0
+    def where(where)
+      return nil if where.blank?
+
+      ntt = []
+      ntk = []
+
+      where.each_pair do |key, value|
+        ntk << key
+        ntt << value
+      end
+
+      "Ntk=#{ntk.join(PIPE)}&Ntt=#{ntt.join(PIPE)}"
+    end
+
+    # Nr - Record filters
+    # @params - Array: ['NOT(132831)', 'propertyB:valueY']
+    # Nr=AND(132831,propertyA:valueX,OR(propertyB:valueY,propertyC:valueZ))
+    # Nr=NOT(132831)&Nr=propertyB:valueY
+    def record_filters(filters)
+      return nil if filters.blank?
+
+      filters.collect! do |filter|
+        "Nr=#{filter}"
+      end.join('&')
+    end
+
+    # Nao - Aggregate records offset
+    # Nao=20
+    def aggregate_offset(offset)
+      offset.to_i == 0 ? nil : "Nao=#{offset}"
+    end
+
+    # No - Record offset
+    # No=20
+    def offset(offset)
+      offset.to_i == 0 ? nil : "No=#{offset}"
+    end
+
+    # M - Records per page
+    # @parms - number
+    # M=recs_per_page:10
+    def limit(limit)
+      limit.blank? ? nil : "M=recs_per_page:#{limit}"
+    end
+
+    # F - fields to selct
+    # @params - Array
+    # ['listingid', 'propertyname'] => 'F=listingid:1|propertyname:1'
+    def select(fields)
+      return nil if fields.blank?
+
+      field_list = []
+      fields.each do |field|
+        field_list << "#{field}:1" unless field.blank?
+      end
+
+      "F=#{field_list.join(PIPE)}"
+    end
+
+    # Nu - rollup records
+    # @params - String (listingid)
+    # Nu=listingid
+    def rollup(rolled_by)
+      return nil if rolled_by.blank?
+
+      "Nu=#{rolled_by}"
+    end
+
+    # Ntx - match mode
+    # @params - Array
+    # ['matchany', 'matchboolean'] => 'Ntx=mode matchany|mode matchboolean'
+    def match_mode(modes)
+      return nil if modes.blank?
+      mode_string = modes.map do |m|
+        "mode #{m}"
+      end.join(PIPE)
+
+      "Ntx=#{mode_string}"
+    end
+
+  end
+end