endeca_on_demand 1.2.0 → 1.3.0

data/lib/endeca_on_demand/client.rb

@@ -1,24 +1,26 @@
-class EndecaOnDemand::Client
+module EndecaOnDemand
+  class Client
 
-  include EndecaOnDemand::PP
+    include EndecaOnDemand::PP
 
-  def inspect_attributes; [ :api, :default_options ]; end
+    def inspect_attributes; [ :api, :default_options ]; end
 
-  ## fields ##
+    ## fields ##
 
-  attr_reader :api, :default_options, :query
+    attr_reader :api, :default_options, :query
 
-  def initialize(api, default_options = {})
-    @api, @default_options = api, default_options.dup.recurse(&:symbolize_keys)
-  end
+    def initialize(api, default_options = {})
+      @api, @default_options = api, default_options.dup.recurse(&:symbolize_keys)
+    end
 
-  ## associations ##
+    ## associations ##
 
-  def query(options = {})
-    @query = nil if options.present?
-    @query ||= EndecaOnDemand::Query.new(self, options)
-  end
+    def query(options = {})
+      @query = nil if options.present?
+      @query ||= EndecaOnDemand::Query.new(self, options)
+    end
 
-  ##
+    ##
 
+  end
 end

data/lib/endeca_on_demand/collection.rb

@@ -1,41 +1,43 @@
-class EndecaOnDemand::Collection < EndecaOnDemand::Proxy
+module EndecaOnDemand
+  class Collection < EndecaOnDemand::Proxy
 
-  attr_reader :klass, :target
+    attr_reader :klass, :target
 
-  def initialize(klass, target, mapping = nil)
-    @klass, @target = klass, target
-    @target = target.map { |object| @klass.new(mapping, object) } if mapping.present?
-    extend klass.collection_class if klass.respond_to?(:collection_class)
-  end
+    def initialize(klass, target, mapping = nil)
+      @klass, @target = klass, target
+      @target = target.map { |object| @klass.new(mapping, object) } if mapping.present?
+      extend klass.collection_class if klass.respond_to?(:collection_class)
+    end
 
-  ## override proxy ##
+    ## override proxy ##
 
-  def class
-    EndecaOnDemand::Collection
-  end
+    def class
+      EndecaOnDemand::Collection
+    end
 
-  def inspect
-    target.to_a.inspect
-  end
+    def inspect
+      target.to_a.inspect
+    end
 
-  ##
+    ##
 
-  def where(conditions = {})
-    target.select do |object|
-      conditions.all? do |key,value|
-        value.is_a?(Regexp) ? object.send(key) =~ value : object.send(key) == value
+    def where(conditions = {})
+      target.select do |object|
+        conditions.all? do |key,value|
+          value.is_a?(Regexp) ? object.send(key) =~ value : object.send(key) == value
+        end
       end
     end
-  end
 
-  protected
+    protected
 
-  def wrap_collection(collection)
-    EndecaOnDemand::Collection.new(klass, collection)
-  end
+    def wrap_collection(collection)
+      EndecaOnDemand::Collection.new(klass, collection)
+    end
 
-  def method_missing(name, *args, &block)
-    target.send(name, *args, &block)
-  end
+    def method_missing(name, *args, &block)
+      target.send(name, *args, &block)
+    end
 
+  end
 end

data/lib/endeca_on_demand/core_ext.rb

@@ -0,0 +1 @@
+require 'endeca_on_demand/core_ext/hash'

data/lib/endeca_on_demand/core_ext/hash.rb

@@ -0,0 +1,30 @@
+# source: https://github.com/rubyworks/facets
+class Hash
+
+  # Apply a block to hash, and recursively apply that block
+  # to each sub-hash or +types+.
+  #
+  #   h = {:a=>1, :b=>{:b1=>1, :b2=>2}}
+  #   g = h.recurse{|h| h.inject({}){|h,(k,v)| h[k.to_s] = v; h} }
+  #   g  #=> {"a"=>1, "b"=>{"b1"=>1, "b2"=>2}}
+  #
+  def recurse(*types, &block)
+    types = [self.class] if types.empty?
+    h = inject({}) do |hash, (key, value)|
+      case value
+      when *types
+        hash[key] = value.recurse(*types, &block)
+      else
+        hash[key] = value
+      end
+      hash
+    end
+    yield h
+  end
+
+  # In place form of #recurse.
+  def recurse!(&block)
+    replace(recurse(&block))
+  end
+
+end

data/lib/endeca_on_demand/pp.rb

@@ -1,48 +1,50 @@
-module EndecaOnDemand::PP
+module EndecaOnDemand
+  module PP
 
-  def inspect # :nodoc:
-    return super if not respond_to?(:inspect_attributes) or inspect_attributes.blank?
-    attributes = inspect_attributes.reject { |x|
-      begin
-        attribute = send x
-        attribute.blank?
-      rescue NoMethodError
-        true
-      end
-    }.map { |attribute|
-      "#{attribute.to_s.sub(/_\w+/, 's')}=#{send(attribute).inspect}"
-    }.join ' '
-    "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{attributes}>"
-  end
+    def inspect # :nodoc:
+      return super if not respond_to?(:inspect_attributes) or inspect_attributes.blank?
+      attributes = inspect_attributes.reject { |x|
+        begin
+          attribute = send x
+          attribute.blank?
+        rescue NoMethodError
+          true
+        end
+      }.map { |attribute|
+        "#{attribute.to_s.sub(/_\w+/, 's')}=#{send(attribute).inspect}"
+      }.join ' '
+      "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{attributes}>"
+    end
 
-  def pretty_print pp # :nodoc:
-    return super if not respond_to?(:inspect_attributes) or inspect_attributes.blank?
-    nice_name = self.class.name
-    pp.group(2, "#(#{nice_name}:#{sprintf("0x%x", object_id)} {", '})') do
+    def pretty_print pp # :nodoc:
+      return super if not respond_to?(:inspect_attributes) or inspect_attributes.blank?
+      nice_name = self.class.name
+      pp.group(2, "#(#{nice_name}:#{sprintf("0x%x", object_id)} {", '})') do
 
-      pp.breakable
-      attrs = inspect_attributes.map { |t|
-        [t, send(t)] if respond_to?(t)
-      }.compact.find_all { |x|
-        x.last.present?
-      }
+        pp.breakable
+        attrs = inspect_attributes.map { |t|
+          [t, send(t)] if respond_to?(t)
+        }.compact.find_all { |x|
+          x.last.present?
+        }
 
-      pp.seplist(attrs) do |v|
-        if v.last.class == EndecaOnDemand::Collection
-          pp.group(2, "#{v.first} = [", "]") do
-            pp.breakable
-            pp.seplist(v.last) do |item|
-              pp.pp item
+        pp.seplist(attrs) do |v|
+          if v.last.class == EndecaOnDemand::Collection
+            pp.group(2, "#{v.first} = [", "]") do
+              pp.breakable
+              pp.seplist(v.last) do |item|
+                pp.pp item
+              end
             end
+          else
+            pp.text "#{v.first} = "
+            pp.pp v.last
           end
-        else
-          pp.text "#{v.first} = "
-          pp.pp v.last
         end
-      end
-      pp.breakable
+        pp.breakable
 
+      end
     end
-  end
 
+  end
 end

data/lib/endeca_on_demand/proxy.rb

@@ -1,61 +1,53 @@
-class EndecaOnDemand::Proxy
-
-  # We undefine most methods to get them sent through to the target.
-  instance_methods.each do |method|
-    undef_method(method) unless
-      method =~ /(^__|^send$|^object_id$|^extend$|^respond_to\?$|^tap$|^inspect$|^pretty_)/
-  end
-
-  attr_accessor :xml
-
-  # def inspect
-  #   respond_to?(:inspection) ?
-  #     "#<#{self.class.name} #{inspection.kind_of?(Hash) ? inspection.inspect : (inspection * ', ')}>" :
-  #     super
-  # end
-
-  def inspect # :nodoc:
-    return super if not respond_to?(:inspect_attributes) or inspect_attributes.blank?
-    attributes = inspect_attributes.reject { |x|
-      begin
-        attribute = send x
-        attribute.blank?
-      rescue NoMethodError
-        true
+module EndecaOnDemand
+  class Proxy
+
+    # We undefine most methods to get them sent through to the target.
+    instance_methods.each do |method|
+      undef_method(method) unless
+        method =~ /(^__|^send$|^object_id$|^extend$|^respond_to\?$|^tap$|^inspect$|^pretty_|^class_eval$|^method$|^instance_$)/
+    end
+
+    attr_accessor :xml
+
+    def inspect # :nodoc:
+      return super if not respond_to?(:inspect_attributes) or inspect_attributes.blank?
+      attributes = inspect_attributes.reject { |x|
+        begin
+          attribute = send x
+          attribute.blank?
+        rescue NoMethodError
+          true
+        end
+      }.map { |attribute|
+        "#{attribute.to_s.sub(/_\w+/, 's')}=#{send(attribute).inspect}"
+      }.join ' '
+      "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{attributes}>"
+    end
+
+    protected
+
+    # Default behavior of method missing should be to delegate all calls
+    # to the target of the proxy. This can be overridden in special cases.
+    #
+    # @param [ String, Symbol ] name The name of the method.
+    # @param [ Array ] *args The arguments passed to the method.
+    def method_missing(name, *args, &block)
+      xml.send(name, *args, &block)
+    end
+
+    def define_getters(lookup)
+      mod = Module.new
+      extend mod
+      send(lookup).keys.each do |key|
+        mod.class_eval <<-RUBY, __FILE__, __LINE__+1
+
+          def #{key}
+            send(#{lookup.inspect})[#{key.inspect}]
+          end
+
+        RUBY
       end
-    }.map { |attribute|
-      "#{attribute.to_s.sub(/_\w+/, 's')}=#{send(attribute).inspect}"
-    }.join ' '
-    "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{attributes}>"
-  end
+    end
 
-  # def pretty_inspect
-  #   respond_to?(:inspection) ?
-  #     "#(#{self.class.name} {\n  #{inspection.pretty_inspect}\n})" :
-  #     super
-  # end
-
-  # def inspect
-  #   inspection = []
-  #   inspection.concat(options.dup.delete_if { |k,v| v.blank? }.sort_by(&:first).map { |k,v| "#{k}: #{v.inspect}" })
-  #   "#<#{self.class.name} #{inspection * ', '}>"
-  # end
-
-  protected
-
-  # Default behavior of method missing should be to delegate all calls
-  # to the target of the proxy. This can be overridden in special cases.
-  #
-  # @param [ String, Symbol ] name The name of the method.
-  # @param [ Array ] *args The arguments passed to the method.
-  def method_missing(name, *args, &block)
-    xml.send(name, *args, &block)
   end
-
-  # def method_missing(method, *args, &block)
-  #   unless self.instance_variables.include?(:"@#{method}")
-  #     "#{method} is unavailable."
-  #   end
-  # end
-  
 end

data/lib/endeca_on_demand/query.rb

@@ -1,195 +1,177 @@
-class EndecaOnDemand::Query
+module EndecaOnDemand
+  class Query
 
-  include EndecaOnDemand::PP
+    include EndecaOnDemand::PP
 
-  def inspect_attributes; [ :uri, :xml, :errors, :options ]; end
+    def inspect_attributes; [ :uri, :xml, :errors, :options ]; end
 
-  ## fields ##
+    ## fields ##
 
-  attr_reader :body, :client, :errors, :http, :options, :response, :uri, :xml
+    attr_reader :body, :client, :errors, :http, :options, :response, :uri, :xml
 
-  def initialize(client, options = {})
-    @client, @options = client, options.dup.recurse(&:symbolize_keys)
+    def initialize(client, options = {})
+      @client, @options = client, options.dup.recurse(&:symbolize_keys)
 
-    process_options!
-  end
+      process_options!
+    end
 
-  ## associations ##
+    ## associations ##
 
-  def body
-    @body ||= to_xml
-  end
+    def body
+      @body ||= to_xml
+    end
 
-  def http
-    @http ||= Net::HTTP.new(uri.host, uri.port)
-  end
+    def http
+      @http ||= Net::HTTP.new(uri.host, uri.port)
+    end
 
-  def response
-    @response ||= EndecaOnDemand::Response.new(self, http.post(uri.path, body, 'Content-type' => 'application/xml'))
-  end
+    def response
+      @response ||= EndecaOnDemand::Response.new(self, http.post(uri.path, body, 'Content-type' => 'application/xml'))
+    end
 
-  def uri
-    @uri ||= URI.parse(client.api)
-  end
+    def uri
+      @uri ||= URI.parse(client.api)
+    end
 
-  def xml
-    @xml ||= Nokogiri::XML(body) { |config| config.strict.noblanks }
-  end
+    def xml
+      @xml ||= Nokogiri::XML(body) { |config| config.strict.noblanks }
+    end
 
-  ##
-
-  ## xml builder ##
-
-  def to_xml
-    Builder::XmlMarkup.new(indent: 2).tag!(:Query) do |xml|
-
-      Flags(xml)
-      KeywordSearch(xml)
-      NavigationQuery(xml)
-      CategoryNavigationQuery(xml)
-      Sorting(xml)
-      Paging(xml)
-      AdvancedParameters(xml)
-
-    end
-  #   @query.Query do
-  #     @query << @body.target!
-  #   end
-    
-  #   begin
-  #     # ask Domino what this is?
-  #     # @request, @raw_response = @http.post(@uri.path, @query.target!, 'Content-type' => 'application/xml')
-
-  #     @response = Nokogiri::XML(fetch_response.body)
-
-  #     build_records
-  #     build_breadcrumbs
-  #     build_dimensions
-  #     build_business_rules
-  #     build_search_reports
-  #     build_selected_dimension_value_ids
-  #     build_keyword_redirect
-  #   rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, Errno::ECONNREFUSED, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => error
-  #     @error = error
-  #   end
-  end
+    ##
 
-  ### data ###
+    ## xml builder ##
 
-  def flags
-    @flags ||= options[:flags] = (options[:flags] || {}).inject({}) do |hash,(key,value)|
-        hash.tap do
-          hash[key.to_s.underscore] = value
-        end
-      end.symbolize_keys
-  end
+    def to_xml
+      Builder::XmlMarkup.new(indent: 2).tag!(:Query) do |xml|
 
-  def searches
-    @searches ||= options[:searches]
-  end
+        Flags(xml)
+        KeywordSearch(xml)
+        NavigationQuery(xml)
+        CategoryNavigationQuery(xml)
+        Sorting(xml)
+        Paging(xml)
+        AdvancedParameters(xml)
 
-  def dimensions
-    @dimensions ||= [*options[:dimensions]]
-  end
+      end
+    end
 
-  def category
-    @category ||= options[:category]
-  end
+    ### data ###
 
-  def sorts
-    @sorts ||= options[:sorts]
-  end
+    def flags
+      @flags ||= options[:flags] = (options[:flags] || {}).inject({}) do |hash,(key,value)|
+          hash.tap do
+            hash[key.to_s.underscore] = value
+          end
+        end.symbolize_keys
+    end
 
-  def paging
-    @paging ||= options[:paging] = (options[:paging] || {}).tap do |paging|
-        if paging.has_key?(:page) and paging.has_key?(:per_page)
-          paging[:offset] = (paging[:page].to_i * paging[:per_page].to_i rescue 0)
-        end
-      end
-  end
+    def searches
+      @searches ||= options[:searches]
+    end
 
-  def advanced_parameters
-    @advanced_parameters ||= options[:advanced] = (options[:advanced] || {}).inject({}) do |hash,(key,value)|
-        hash.tap do
-          hash[key.to_s.underscore] = value
+    def dimensions
+      @dimensions ||= [*options[:dimensions]]
+    end
+
+    def category
+      @category ||= options[:category]
+    end
+
+    def sorts
+      @sorts ||= options[:sorts]
+    end
+
+    def paging
+      @paging ||= options[:paging] = (options[:paging] || {}).tap do |paging|
+          if paging.has_key?(:page) and paging.has_key?(:per_page)
+            paging[:offset] = (paging[:page].to_i * paging[:per_page].to_i rescue 0)
+          end
         end
-      end.symbolize_keys
-  end
+    end
+
+    def advanced_parameters
+      @advanced_parameters ||= options[:advanced] = (options[:advanced] || {}).inject({}) do |hash,(key,value)|
+          hash.tap do
+            hash[key.to_s.underscore] = value
+          end
+        end.symbolize_keys
+    end
 
-  ###
+    ###
 
-  protected
+    protected
 
-  def Flags(xml)
-    return if flags.blank?
-    flags.each do |flag,value|
-      xml.tag!(flag.to_s.camelcase, value)
+    def Flags(xml)
+      return if flags.blank?
+      flags.each do |flag,value|
+        xml.tag!(flag.to_s.camelcase, value)
+      end
     end
-  end
 
-  def KeywordSearch(xml)
-    return if searches.blank?
-    xml.tag!(:Searches) do
-      searches.each do |key,term|
-        xml.tag!(:Search) do
-          xml.tag!('search-key',  key.to_s)
-          xml.tag!('search-term', term.to_s)
+    def KeywordSearch(xml)
+      return if searches.blank?
+      xml.tag!(:Searches) do
+        searches.each do |key,term|
+          xml.tag!(:Search) do
+            xml.tag!('search-key',  key.to_s)
+            xml.tag!('search-term', term.to_s)
+          end
         end
       end
     end
-  end
 
-  def NavigationQuery(xml)
-    return if dimensions.blank?
-    xml.tag!(:SelectedDimensionValueIds) do
-      dimensions.each do |dimension|
-        xml.tag!(:DimensionValueId, dimension)
+    def NavigationQuery(xml)
+      return if dimensions.blank?
+      xml.tag!(:SelectedDimensionValueIds) do
+        dimensions.each do |dimension|
+          xml.tag!(:DimensionValueId, dimension)
+        end
       end
     end
-  end
 
-  def CategoryNavigationQuery(xml)
-    return if category.blank?
-    xml.tag!(:Category) do
-      xml.tag!(:CategoryId, category)
+    def CategoryNavigationQuery(xml)
+      return if category.blank?
+      xml.tag!(:Category) do
+        xml.tag!(:CategoryId, category)
+      end
     end
-  end
 
-  def Sorting(xml)
-    return if sorts.blank?
-    xml.tag!(:Sorts) do
-      sorts.each do |key,direction|
-        xml.tag!(:Sort) do
-          xml.tag!('sort-key',       key.to_s)
-          xml.tag!('sort-direction', direction.to_s.capitalize)
+    def Sorting(xml)
+      return if sorts.blank?
+      xml.tag!(:Sorts) do
+        sorts.each do |key,direction|
+          xml.tag!(:Sort) do
+            xml.tag!('sort-key',       key.to_s)
+            xml.tag!('sort-direction', direction.to_s.capitalize)
+          end
         end
       end
     end
-  end
 
-  def Paging(xml)
-    return if paging.blank?
-    xml.tag!(:RecordOffset,   paging[:offset])   if paging.has_key?(:offset)
-    xml.tag!(:RecordsPerPage, paging[:per_page]) if paging.has_key?(:per_page)
-  end
+    def Paging(xml)
+      return if paging.blank?
+      xml.tag!(:RecordOffset,   paging[:offset])   if paging.has_key?(:offset)
+      xml.tag!(:RecordsPerPage, paging[:per_page]) if paging.has_key?(:per_page)
+    end
 
-  def AdvancedParameters(xml)
+    def AdvancedParameters(xml)
 
-  end
+    end
 
-  def process_options!
-    new_options = (client.default_options[:query] || {}).dup
+    def process_options!
+      new_options = (client.default_options[:query] || {}).dup
 
-    (new_options[:flags]      ||= {}).merge!(options[:flags]    || {}).recurse(&:symbolize_keys) if options[:flags].present?
-    (new_options[:paging]     ||= {}).merge!(options[:paging]   || {}).recurse(&:symbolize_keys) if options[:paging].present?
-    (new_options[:searches]   ||= {}).merge!(options[:searches] || {}).recurse(&:symbolize_keys) if options[:searches].present?
-    (new_options[:sorts]      ||= {}).merge!(options[:sorts]    || {}).recurse(&:symbolize_keys) if options[:sorts].present?
-    (new_options[:dimensions] = [*new_options[:dimensions]]).concat [*options[:dimensions]]      if options[:dimensions].present?
-    new_options[:category]    = options[:category] if options[:category].present?
+      (new_options[:flags]      ||= {}).merge!(options[:flags]    || {}).recurse(&:symbolize_keys) if options[:flags].present?
+      (new_options[:paging]     ||= {}).merge!(options[:paging]   || {}).recurse(&:symbolize_keys) if options[:paging].present?
+      (new_options[:searches]   ||= {}).merge!(options[:searches] || {}).recurse(&:symbolize_keys) if options[:searches].present?
+      (new_options[:sorts]      ||= {}).merge!(options[:sorts]    || {}).recurse(&:symbolize_keys) if options[:sorts].present?
+      (new_options[:dimensions] = [*new_options[:dimensions]]).concat [*options[:dimensions]]      if options[:dimensions].present?
+      new_options[:category]    = options[:category] if options[:category].present?
 
-    @options = new_options
-  end
+      @options = new_options
+    end
 
-  ##
+    ##
 
+  end
 end