endeca 1.3.7

data/lib/endeca/readers.rb

@@ -0,0 +1,93 @@
+module Endeca
+  class ReaderError < ::StandardError; end
+
+  module Readers
+    module ClassMethods
+      def add_reader(name, &block)
+        meta = (class << self; self; end)
+        meta.instance_eval do
+          define_method(name) { |*attrs| reader(*attrs, &block) }
+        end
+      end
+
+      # Maps key/value pairs from the data structure used to initialize a
+      # Endeca object. Allows attribute renaming. Use a block to perform data
+      # injunction on the value as it is set.
+      #
+      # ==== Examples
+      #
+      #   # Specify basic attributes
+      #   reader :title
+      #
+      #   # Attribute renaming
+      #   reader :long_desc => :description
+      #
+      #   # Data injunction
+      #   reader(:title => :upcased_title) { |title| title.upcase }
+      def reader(*attrs,&block)
+        hash = {}
+        block ||= lambda {|x| x}
+
+        hash.update(attrs.pop) if Hash === attrs.last
+
+        attrs.each{ |attr| hash[attr] = attr }
+
+        hash.each do |variable, method|
+          reader_names << method if respond_to?(:reader_names)
+          define_method(method) do
+            begin
+              block.call(attributes[variable.to_s])
+            rescue StandardError => e
+              raise Endeca::ReaderError, e.message
+            end
+          end
+        end
+      end
+
+      # Typecasts attributes as integers.
+      #
+      # ==== Examples
+      #   integer_reader :id, :rating
+      def integer_reader(*attrs)
+        reader(*attrs) { |value| value.blank? ? 0 : Integer(value) }
+      end
+
+      # Typecasts attributes as BigDecimal
+      #
+      # ==== Examples
+      #   decimal_reader :price
+      def decimal_reader(*attrs)
+        require 'bigdecimal' unless defined?(BigDecimal)
+        reader(*attrs) { |value| BigDecimal(value.to_s) }
+      end
+
+      # Typecasts attributes as floats 
+      #
+      # ==== Examples
+      #   float_reader :latitude, :longitude
+      def float_reader(*attrs)
+        reader(*attrs) { |value| Float(value) if value }
+      end
+
+      # Typecasts attributes as a Perly boolean ("0" == false, "1" == true")
+      #
+      # ==== Examples
+      #   boolean_reader :price
+      def boolean_reader(*attrs)
+        reader(*attrs) { |value| value == "1" ? true : false }
+      end
+
+    end
+
+    module InstanceMethods      
+      def method_missing(method_id)
+        raise NoMethodError, "undefined method '#{method_id}' for #{self.inspect}. Do you need to add a reader for it?"
+      end
+    end
+    
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+end

data/lib/endeca/refinement.rb

@@ -0,0 +1,42 @@
+module Endeca
+  class Refinement
+    include Readers
+    extend ClassToProc
+
+    reader 'DimensionName' => :name,
+      'ExpansionLink' => :expansion_link,
+      'ContractionLink' => :contraction_link
+
+    integer_reader 'DimensionID' => :id
+
+    reader('DimensionValues' => :dimension_values) do |values|
+      values.map(&Dimension) if values
+    end
+
+    reader('Dimensions' => :dimensions) do |values|
+      values.map(&RefinementDimension) if values
+    end
+
+    attr_reader :raw
+    def initialize(raw={})
+      @raw = raw
+    end
+
+    def ==(other)
+      id == other.id
+    end
+
+    def inspect
+      "#<#{self.class}=0x#{self.object_id.to_s(16)} id=#{id} name=#{name.inspect}>"
+    end
+
+    def attributes
+      (@raw['Dimensions'] || []).first || {}
+    end
+
+    def to_endeca_params
+      expansion_link || contraction_link
+    end
+
+  end
+end

data/lib/endeca/refinement_dimension.rb

@@ -0,0 +1,32 @@
+module Endeca
+  class RefinementDimension
+    include Comparable
+    include Readers
+    extend ClassToProc
+
+    reader \
+      "DimensionName"  => :name,
+      "ExpansionLink" => :to_endeca_params
+
+    integer_reader \
+      "DimensionID"      => :id
+
+    attr_reader :raw
+    def initialize(raw={})
+      @raw=raw
+    end
+    alias_method :attributes, :raw
+    
+    def inspect
+      "#<#{self.class}=0x#{self.object_id.to_s(16)} id=#{id} name=#{name.inspect}>"
+    end
+
+    def ==(other)
+      id == other.id
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+  end
+end

data/lib/endeca/request.rb

@@ -0,0 +1,88 @@
+require 'uri'
+
+module Endeca
+  class RequestError < ::StandardError; end
+
+  class Request
+    def self.perform(path, query=nil)
+      raise RequestError, "Must provide a path" unless path
+      new(path, query).perform
+    end
+
+    def initialize(path, query=nil)
+      @path  = path.strip
+      @query = query
+    end
+
+    def perform
+      raise RequestError, endeca_error[:message] if endeca_error?
+      Endeca.increase_metric(:request_count, 1)
+      return response
+    end
+    
+    def response
+      @response ||= handle_response(get_response)
+    end
+
+    def uri
+      return @uri if @uri
+
+      @uri = URI.parse(@path)
+      @uri.query = query_string unless !@query || @query.include?("/_/")
+      @uri = URI.parse("#{@path}#{@query}") if @query && @query.include?("/_/")
+      @uri
+    end
+
+    private
+    
+    def endeca_error
+      method_response = response["methodResponse"]
+      fault = method_response && method_response["fault"]
+      values = fault && fault["value"]
+      return nil unless values
+      {
+        :code => values["faultCode"].to_i,
+        :message => values["faultString"]
+      }
+    end
+
+    def endeca_error?
+      !endeca_error.nil?
+    end
+
+    def get_response #:nodoc:
+      Endeca.log "ENDECA ADAPTER REQUEST"
+      Endeca.log "    parameters => " + @query.inspect
+      Endeca.log "           uri => " + uri.to_s
+      Endeca.bm(:request_time, "#{@path} #{@query.inspect}") do 
+        Endeca.timer.timeout(Endeca.timeout) do
+          @response = Net::HTTP.get_response(uri) 
+        end
+      end
+
+      return @response
+    end
+
+    # Raises exception Net::XXX (http error code) if an http error occured
+    def handle_response(response) #:nodoc:
+      case response
+      when Net::HTTPSuccess
+        Endeca.bm :parse_time do
+          @json = JSON.parse(response.body)
+        end
+      else
+        response.error! # raises exception corresponding to http error Net::XXX
+      end
+
+    rescue => e
+      raise RequestError, e.message
+    end
+
+    def query_string
+      query_string_parts = [@uri.query, @query.to_endeca_params]
+      query_string_parts.reject!{ |s| s.nil? || s.empty? }
+
+      query_string_parts.empty? ? nil : query_string_parts.join('&')
+    end
+  end
+end

data/lib/endeca/transformer.rb

@@ -0,0 +1,43 @@
+module Endeca
+  module Transformer
+    # Requires existence of mappings accessor (Hash)
+    #
+    # ==== Examples
+    #   # Standard map call that returns an Endeca::Map object
+    #   map(:old_name => :new_name)
+    #
+    #   # Allows to to create a map object to perform other functionality such
+    #   # as transformations.
+    #   map(:new_name)
+    def map(mapping = {})
+      mapping = {mapping => mapping} if Symbol === mapping
+      mapping = mapping.symbolize_keys
+
+      if mapping.length > 1
+        raise ArgumentError, "map only accepts one key=>value pair" 
+      end
+
+      mapping.each do |key, transformed_key|
+        transformed_key = key unless transformed_key
+        return mappings[key] = Map.new(key, transformed_key)
+      end
+    end
+
+    # Use the mappings hash to replace domain level query query_options with
+    # their Endeca equivalent.
+    def transform_query_options(query_options)
+      # {"apartments" => true}
+      query = query_options.symbolize_keys
+      # {:apartments => true}
+      query.each do |key, _|
+        if mapping = mappings[key]
+          new_options = mapping.perform(query)
+          query.delete(key)
+          query.update(new_options)
+        end
+      end
+      query
+    end
+ 
+  end
+end

data/spec/core_ext_spec.rb

@@ -0,0 +1,134 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Array do
+  describe "#to_endeca_params" do
+    it "should join the elements with ampersand" do
+      ["foo=1","bar=3"].to_endeca_params.should == "foo=1&bar=3"
+    end
+
+    it "should escape all elements" do
+      ['|=|','||=||'].to_endeca_params.should == '%7C=%7C&%7C%7C=%7C%7C'
+    end
+  end
+end
+
+describe Benchmark do
+  describe ".realtime" do
+    it "should check the time twice" do
+      Time.should_receive(:now).exactly(2).times
+      Benchmark.realtime(){}
+    end
+
+    it "should return the time difference as a float" do
+      Benchmark.realtime(){}.should be_a_kind_of(Float)
+    end
+  end
+  
+  describe ".ms" do
+    it "should be 1000 times the realtime value" do
+      Benchmark.stub!(:realtime).and_return(1)
+      Benchmark.ms.should == 1000
+    end
+  end
+end
+
+describe Hash do
+  describe "#to_endeca_params" do
+    it "should join a key-value pair with equals" do
+      {:foo => :bar}.to_endeca_params.should == 'foo=bar'
+    end
+
+    it "should join two key-value pairs with ampersand" do
+      result = {:foo => :bar, :bizz => :bazz}.to_endeca_params
+      (result == 'foo=bar&bizz=bazz' || result == 'bizz=bazz&foo=bar').should be_true
+    end
+
+    it "should use brackets to indicate a nested hash" do
+      {:foo => {:foo => :bar}}.to_endeca_params.should == 'foo[foo]=bar'
+    end
+
+    it "should escape all elements" do
+      {'|' => '||'}.to_endeca_params.should == '%7C=%7C%7C'
+    end
+  end
+end
+
+describe NilClass do
+  describe "to_endeca_params" do
+    it "should return the empty string" do
+      nil.to_endeca_params.should == ''
+    end
+  end
+end
+
+describe String do
+  describe "#to_endeca_params" do
+    it "should URI escape the contents" do
+      '|'.to_endeca_params.should == '%7C'
+    end
+    
+    it "should URI escape a colon" do
+      ':'.to_endeca_params.should == "%3A"
+    end
+  end
+end
+
+describe "#inherited_accessor" do
+    
+  class SomeParent
+    inherited_accessor :a_hash, {:m => "my_value"}
+    inherited_accessor :a_string, "fibby foo"
+    inherited_accessor :a_array, ["atlanta"]
+  end
+
+  class A < SomeParent; end
+  class B < SomeParent; end
+
+  before do
+    A.a_hash[:a] = "a_value"
+    A.a_string = "a_string"
+
+    B.a_hash[:a] = "b_value"
+    B.a_string = "b_string"
+  end
+
+  it "should retrieve default value" do
+    SomeParent.a_hash[:m].should == "my_value"
+    SomeParent.a_string.should == "fibby foo"
+  end
+
+  it "should retrieve A hash value correctly" do
+    A.a_hash[:a].should == "a_value"
+  end
+
+  it "should retrieve A string value correctly" do
+    A.a_string.should == "a_string"
+  end
+
+  it "should retrieve A array value correctly" do
+    original = A.a_array
+
+    A.a_array << "jacksonville"
+    A.a_array.should == ["atlanta", "jacksonville"]
+
+    A.a_array = original
+  end
+
+  it "should retrieve B hash value correctly" do
+    B.a_hash[:a].should == "b_value"
+  end
+
+  it "should retrieve B string value correctly" do
+    B.a_string.should == "b_string"
+  end
+
+  it "should retrieve B array value correctly" do
+    original = B.a_array
+
+    B.a_array << "new york"
+    B.a_array.should == ["atlanta", "new york"]
+
+    B.a_array = original
+  end
+end
+# EOF

data/spec/endeca/benchmarking_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+describe Endeca::Benchmarking do
+  class Helper
+    extend Endeca::Benchmarking
+  end
+
+  describe "#benchmark" do
+    before do
+      @logger = mock('Logger')
+
+      Endeca.stub!(:logger).and_return(@logger)
+      Endeca.stub!(:debug => true, :benchmark => true)
+
+      Benchmark.stub!(:ms => 1)
+    end
+
+    it "should log the title and the time to the Endeca logger" do
+      @logger.should_receive(:debug).with("metric: 1.0ms")
+      Endeca.bm(:metric){ 1 }
+    end
+  end
+
+  describe "#add_bm_detail" do
+    it "should add info to the current thread" do
+      Endeca.stub!(:analyze?).and_return(true)
+
+      Endeca.send(:add_bm_detail, :metric, 1.1, 'query query')
+
+      Thread.current[:endeca]["metric_detail"][0].should == {:detail => "query query", :time => 1.1}
+    end
+  end
+end