supplejack_client 1.0.2 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 950c231c1f7bf0f55b66622babdf1524376b02da
-  data.tar.gz: 497695e5a2d9ba4a8bc4fa690a9291eb328d9625
+  metadata.gz: 0f40b6b28bd0108c37c997ef3fd6c0e346e48341
+  data.tar.gz: 0eb25481a3fdea69d0597739ba2aeb966fc671f8
 SHA512:
-  metadata.gz: 31e663f7fcd4154e2d0bb71cfd4a076dcddc9ed426f61beb68cbf901f6272f3a65c47b06c442ada1805fbf73b5378f8784fcaa87d619484d6bdb622357e2cb70
-  data.tar.gz: fbc71a0fbcbb7c1421c71a19ab0d41a0fb40d73abf476dd288fa659b4026ff29e023fe791d1da6e99cd4ced6775e70120c3d6cbc6111d70b376405b01c3bbcad
+  metadata.gz: f4520818d551545b38294f5d157fe6b52caf1af07379cf329e138ab67b674687944305a3503d807e1f9966834e1e9245a4545228071b12ffed50e32d06d9762e
+  data.tar.gz: 8a72b8a32b0365258c722781db9b52ddcd29705612d7e3a0170f5d1220d6bce9c89b9f5cad4856db6a30de55f4c70f9bd57532aad77cad29634afece752a1d9a

data/lib/supplejack/config.rb

@@ -34,12 +34,13 @@ module Supplejack
     SEARCH_KLASS              = nil
     FIELDS                    = [:default]
     SUPPLEJACK_FIELDS         = []
-    ADMIN_FIELDS              = []
+    SPECIAL_FIELDS            = []
     ENABLE_DEBUGGING          = false
     ENABLE_CACHING            = false
     ATTRIBUTE_TAG             = :p
     LABEL_TAG                 = :strong
     LABEL_CLASS               = nil
+    STICKY_FACETS             = false
 
     VALID_OPTIONS_KEYS = [
       :api_key,
@@ -58,12 +59,13 @@ module Supplejack
       :search_klass,
       :fields,
       :supplejack_fields,
-      :admin_fields,
+      :special_fields,
       :enable_debugging,
       :enable_caching,
       :attribute_tag,
       :label_tag,
-      :label_class
+      :label_class,
+      :sticky_facets
     ]
 
     SINGLE_VALUE_METHODS = [
@@ -96,6 +98,7 @@ module Supplejack
       self.facets                   = FACETS
       self.facets_per_page          = FACETS_PER_PAGE
       self.facets_sort              = FACETS_SORT
+      self.sticky_facets            = STICKY_FACETS
       self.single_value_methods     = SINGLE_VALUE_METHODS
       self.search_attributes        = SEARCH_ATTRIBUTES
       self.url_format               = URL_FORMAT
@@ -107,7 +110,7 @@ module Supplejack
       self.search_klass             = SEARCH_KLASS
       self.fields                   = FIELDS
       self.supplejack_fields        = SUPPLEJACK_FIELDS
-      self.admin_fields             = ADMIN_FIELDS
+      self.special_fields           = SPECIAL_FIELDS
       self.enable_debugging         = ENABLE_DEBUGGING
       self.enable_caching           = ENABLE_CACHING
       self.attribute_tag            = ATTRIBUTE_TAG

data/lib/supplejack/controllers/helpers.rb

@@ -41,10 +41,10 @@ module Supplejack
       # @return [ String ] A HTML snippet with the attribute name and value
       #
       def attribute(record, attributes, options={})
-        options.reverse_merge!(:label => true, :label_inline => true, :limit => nil, :delimiter => ", ",
-                                :link_path => false, :tag => Supplejack.attribute_tag, :label_tag => Supplejack.label_tag,
-                                :label_class => Supplejack.label_class, :trans_key => nil, :link => false,
-                                :extra_html => nil, :tag_class => nil)
+        options.reverse_merge!(label: true, label_inline: true, limit: nil, delimiter: ", ",
+                                link_path: false, tag: Supplejack.attribute_tag, label_tag: Supplejack.label_tag,
+                                label_class: Supplejack.label_class, trans_key: nil, link: false,
+                                extra_html: nil, tag_class: nil)
 
         value = []
         attributes = [attributes] unless attributes.is_a?(Array)
@@ -72,7 +72,7 @@ module Supplejack
           end
 
           if options[:link_path]
-            value = value.map {|v| link_to(v, send(options[:link_path], {:i => {attribute => v}})) }
+            value = value.map {|v| link_to(v, send(options[:link_path], {i: {attribute => v}})) }
           end
 
           if options[:link]
@@ -82,11 +82,11 @@ module Supplejack
           end
 
           value = value.join(options[:delimiter]).html_safe
-          value = truncate(value, :length => options[:limit]) if options[:limit].to_i > 20
+          value = truncate(value, length: options[:limit]) if options[:limit].to_i > 20
           value
         else
           if options[:limit] && options[:limit].to_i > 0
-            value = truncate(value, :length => options[:limit].to_i)
+            value = truncate(value, length: options[:limit].to_i)
           end
 
           if options[:link]
@@ -97,22 +97,66 @@ module Supplejack
         content = ""
         if options[:label]
           if options[:trans_key].present?
-            translation = I18n.t(options[:trans_key], :default => attribute.to_s.capitalize) + ": "
+            translation = I18n.t(options[:trans_key], default: attribute.to_s.capitalize) + ": "
           else
             i18n_class_name = record.class.to_s.tableize.downcase.gsub(/\//, "_")
-            translation = "#{I18n.t("#{i18n_class_name}.#{attribute}", :default => attribute.to_s.capitalize)}: "
+            translation = "#{I18n.t("#{i18n_class_name}.#{attribute}", default: attribute.to_s.capitalize)}: "
           end
-          content = content_tag(options[:label_tag], translation, :class => options[:label_class]).html_safe
+          content = content_tag(options[:label_tag], translation, class: options[:label_class]).html_safe
           content << "<br/>".html_safe unless options[:label_inline]
         end
 
         content << value.to_s
         content << options[:extra_html] if options[:extra_html]
         if value.present? and value != "Not specified"
-          options[:tag] ? content_tag(options[:tag], content.html_safe, :class => options[:tag_class]) : content.html_safe
+          options[:tag] ? content_tag(options[:tag], content.html_safe, class: options[:tag_class]) : content.html_safe
         end
       end
 
+      # Displays the next and/or previous links based on the record and current search
+      #
+      # @params [ Dnz::Record ] The record object which has information about the next/previous record and pages.
+      # @params [ Hash ] options Hash of options to customize the output,
+      #   supported options: :prev_class, :next_class, :prev_label, :next_label
+      #
+      # @option options [ String ] :prev_class The CSS class to use on the previous button
+      # @option options [ String ] :next_class The CSS class to use on the next button
+      # @option options [ String ] :wrapper_class The CSS class to use on the wrapping span
+      # @option options [ String ] :prev_label Any HTML to be put inside the previous button
+      # @option options [ String ] :next_label Any HTML to be put inside the next button
+      #
+      def next_previous_links(record, html_options={})
+        html_options.reverse_merge!({prev_class: "prev", next_class: "next", wrapper_class: 'nav', prev_label: nil, next_label: nil})
+
+        return "" unless params[:search]
+        links = "".html_safe
+
+        options = search.options
+
+        previous_label = html_options[:prev_label] ||= t('supplejack_client.previous', default: "Previous")
+        next_label = html_options[:next_label] ||= t('supplejack_client.next', default: "Next")
+        previous_label = previous_label.html_safe
+        next_label = next_label.html_safe
+
+        options[:path] = params[:search][:path].gsub(/(\W|\d)/, '') if params[:search] && params[:search][:path]
+
+        if record.previous_record
+          options[:page] = record.previous_page if record.previous_page.to_i > 1
+          links += link_to(raw(previous_label), record_path(record.previous_record, search: options), class: html_options[:prev_class]).html_safe
+        else
+          links += content_tag(:span, previous_label, class: html_options[:prev_class])
+        end
+
+        if record.next_record
+          options[:page] = record.next_page if record.next_page.to_i > 1
+          links += link_to(raw(next_label), record_path(record.next_record, search: options), class: html_options[:next_class]).html_safe
+        else
+          links += content_tag(:span, next_label, class: html_options[:next_class])
+        end
+
+        content_tag(:span, links, class: html_options[:wrapper_class])
+      end
+
       def attribute_link_replacement(value, link_pattern)
         if link_pattern.is_a?(String)
           link_pattern = URI.decode(link_pattern)
@@ -123,6 +167,170 @@ module Supplejack
         end
       end
 
+      # Generates hidden fields with all the filters of a search object
+      # It is used in forms, so that when a user enteres another term in the search
+      # box the state of the search is preserved
+      #
+      # @param [ Dnz::Search ] search A instance of the Dnz::Search class
+      # @param [ Hash ] options Hash of options to remove any filter
+      #
+      # @option options [ Array ] except A array of fields which should not generate a hidden field
+      #
+      # @return [ String ] A HTML snippet with hidden fields
+      #
+      def form_fields(search, options={})
+        if search
+          tags = "".html_safe
+
+          fields = [:record_type, :sort, :direction]
+          fields.delete(:record_type) if search.record?
+
+          if options[:except].try(:any?)
+            fields.delete_if {|field| options[:except].include?(field)}
+          end
+
+          fields.each do |field|
+            tags += hidden_field_tag(field.to_s, search.send(field)) unless search.send(field).blank?
+          end
+
+          {i: :i_unlocked, il: :i_locked, h: :h_unlocked, hl: :h_locked}.each_pair do |symbol, instance_name|
+            if Supplejack.sticky_facets || [:il, :hl].include?(symbol) || options[:all_filters]
+              filters = search.url_format.send(instance_name) rescue {}
+              filters.each do |name, value|
+                field_name = value.is_a?(Array) ? "#{symbol.to_s}[#{name.to_s}][]" : "#{symbol.to_s}[#{name.to_s}]"
+                values = *value
+                values.each {|v| tags << hidden_field_tag(field_name, v) }
+              end
+            end
+          end
+
+          tags
+        end
+      end
+
+      # Returns a link with all existing search options except the specified in the params 
+      #
+      # @param [ Symbol ] name The name of the facet. Ex: :category, :subject
+      # @param [ String ] value The value withing the facet. Ex: "Wellington", "Books", etc..
+      # @param [ String ] path_name The name of the path used to generate the url path.
+      #   For example if you have a records_path route in your app, then specify "records" 
+      #   and it will call the records_path method
+      # @param [ Hash ] options Set of options to customize the output
+      # @param [ Hash ] html_options HTML options that are passed directly to the link_to method
+      #
+      # @return [ String ] A link to with the correct search options.
+      #
+      def link_to_remove_filter(name, value, path_name, options={}, html_options={}, &block)
+        path = generate_path(path_name, search.options(except: [{name => value}, :page]))
+        link_text = options[:display_name].present? ? options[:display_name] : I18n.t("facets.values.#{value}", default: value)
+        link_to block_given? ? capture(&block) : link_text, path.html_safe, html_options
+      end
+      
+      # Returns a link with the existing search options and adds the specified facet and value
+      #
+      # @param [ Symbol ] name The name of the facet. Ex: :category, :subject
+      # @param [ String ] value The value withing the facet. Ex: "Wellington", "Books", etc..
+      # @param [ String ] path_name The name of the path used to generate the url path.
+      #   For example if you have a records_path route in your app, then specify "records" 
+      #   and it will call the records_path method
+      # @param [ Hash ] options Set of options to customize the output
+      # @param [ Hash ] html_options HTML options that are passed directly to the link_to method
+      #
+      # @return [ String ] A link to with the correct search options.
+      #
+      def link_to_add_filter(name, value, path_name, options={}, html_options={}, &block)
+        symbol = search.record_type == 0 ? :i : :h
+        options[:except] = Util.array(options[:except]) + [:page]
+        path = generate_path(path_name, search.options(plus: {symbol => {name => value}}, except: options[:except]))
+        link_text =  options[:display_name].present? ? options[:display_name] : I18n.t("facets.values.#{value}", default: value)
+        link_to block_given? ? capture(&block) : link_text, path.html_safe, html_options
+      end
+
+      def link_to_lock_filter(name, value, path_name, options={}, html_options={}, &block)
+        symbol = search.record_type == 0 ? :il : :hl
+        path = generate_path(path_name, search.options(except: [{name => value}], plus: {symbol => {name => value}}))
+        link_text = options[:display_name].present? ? options[:display_name] : I18n.t("facets.values.#{value}", default: value)
+        link_to block_given? ? capture(&block) : link_text, path.html_safe, html_options
+      end
+
+      # Provides a link to record landing page that is augmented with a persisted search object
+      # Used in results listings
+      #
+      # @params [ String ] name A text to display in the link (not required if block is passed)
+      # @params [ String ] url The url for the link
+      # @params [ Hash ] search_options The options to pass in the search options (usually @search.options)
+      # @params [ Hash ] html_options The options to pass to link_to
+      # @params [ Block ] &block A block containing ERB, this replaces the name parameter
+      #
+      def link_to_record(*args, &block)
+        if block_given?
+          name = capture(&block)
+          url = args[0]
+          search_options = args[1] || {}
+          html_options = args[2] || {}
+        else
+          name = args[0]
+          url = args[1]
+          search_options = args[2] || {}
+          html_options = args[3] || {}
+        end
+        url = url + "?" + {search: search_options}.to_query if search_options.try(:any?)
+        link_to(name, url, html_options)
+      end
+
+      # Displays the next and/or previous links based on the record and current search
+      #
+      # @params [ Dnz::Record ] The record object which has information about the next/previous record and pages.
+      # @params [ Hash ] options Hash of options to customize the output,
+      #   supported options: :prev_class, :next_class, :prev_label, :next_label
+      #
+      # @option options [ String ] :prev_class The CSS class to use on the previous button
+      # @option options [ String ] :next_class The CSS class to use on the next button
+      # @option options [ String ] :wrapper_class The CSS class to use on the wrapping span
+      # @option options [ String ] :prev_label Any HTML to be put inside the previous button
+      # @option options [ String ] :next_label Any HTML to be put inside the next button
+      #
+      def next_previous_links(record, html_options={})
+        html_options.reverse_merge!({prev_class: "prev", next_class: "next", wrapper_class: 'nav', prev_label: nil, next_label: nil})
+
+        return "" unless params[:search]
+        links = "".html_safe
+
+        options = search.options
+
+        previous_label = html_options[:prev_label] ||= t('dnz_client.previous', default: "Previous")
+        next_label = html_options[:next_label] ||= t('dnz_client.next', default: "Next")
+        previous_label = previous_label.html_safe
+        next_label = next_label.html_safe
+
+        options[:path] = params[:search][:path].gsub(/(\W|\d)/, '') if params[:search] && params[:search][:path]
+
+        if record.previous_record
+          options[:page] = record.previous_page if record.previous_page.to_i > 1
+          links += link_to(raw(previous_label), record_path(record.previous_record, search: options), class: html_options[:prev_class]).html_safe
+        else
+          links += content_tag(:span, previous_label, class: html_options[:prev_class])
+        end
+
+        if record.next_record
+          options[:page] = record.next_page if record.next_page.to_i > 1
+          links += link_to(raw(next_label), record_path(record.next_record, search: options), class: html_options[:next_class]).html_safe
+        else
+          links += content_tag(:span, next_label, class: html_options[:next_class])
+        end
+
+        content_tag(:span, links, class: html_options[:wrapper_class])
+      end      
+
+      def generate_path(name, options={})
+        segments = name.split(".")
+        if segments.size == 1
+          send("#{segments[0]}_path", options)
+        elsif segments.size == 2
+          send(segments[0]).send("#{segments[1]}_path", options)
+        end
+      end 
+
     end
   end
 end

data/lib/supplejack/item.rb

@@ -23,7 +23,9 @@ module Supplejack
   class Item
     include Supplejack::Request
     
-    ATTRIBUTES = [:record_id, :date]
+    ATTRIBUTES = [:record_id, :title, :description, :large_thumbnail_url, :thumbnail_url, 
+                  :contributing_partner, :display_content_partner, :display_collection, :landing_url, :category, :date, 
+                  :dnz_type, :dc_identifier, :creator]
 
     attr_reader *ATTRIBUTES
     attr_reader :attributes, :user_set_id

data/lib/supplejack/record.rb

@@ -17,6 +17,16 @@ module Supplejack
       extend Supplejack::Request
       extend ActiveModel::Naming
       include ActiveModel::Conversion
+
+      # Some of the records in the API return an array of values, but in practice
+      # most of them have on only one value. What this does is just convert the array
+      # to a string for the methods defined in the configuration.
+      Supplejack.single_value_methods.each do |method|
+        define_method("#{method}") do
+          values = @attributes[method]
+          values.is_a?(Array) ? values.first : values
+        end
+      end
     end
 
     def initialize(attributes={})
@@ -49,18 +59,25 @@ module Supplejack
     def metadata
       metadata = []
 
-      ['supplejack', 'admin'].each do |schema|
-        Supplejack.send("#{schema}_fields").each do |field|
+      Supplejack.send("special_fields").each do |schema, fields|
+        fields[:fields].each do |field|
           if @attributes.has_key?(field)
             values = @attributes[field]
             values ||= [] unless !!values == values #Testing if boolean
             values = [values] unless values.is_a?(Array)
-            field = field.to_s.camelcase(:lower) if schema == "dcterms"
+
+            case fields[:format]
+            when "uppercase" then field = field.to_s.upcase
+            when "lowercase" then field = field.to_s.downcase
+            when "camelcase" then field = field.to_s.camelcase
+            end
+
+            # field = field.to_s.camelcase(:lower) if schema == :dcterms
             field = field.to_s.sub(/#{schema}_/, '')
             values.each do |value|
-              metadata << {:name => field, :schema => schema, :value => value }
+              metadata << {:name => field, :schema => schema.to_s, :value => value }
             end
-          end
+          end          
         end
       end
 
@@ -72,16 +89,6 @@ module Supplejack
       @attributes[:format]
     end
 
-    # Some of the records in the API return an array of values, but in practice
-    # most of them have on only one value. What this does is just convert the array
-    # to a string for the methods defined in the configuration.
-    Supplejack.single_value_methods.each do |method|
-      define_method("#{method}") do
-        values = @attributes[method]
-        values.is_a?(Array) ? values.first : values
-      end
-    end
-
     [:next_page, :previous_page, :next_record, :previous_record].each do |pagination_field|
       define_method(pagination_field) do
         @attributes[pagination_field]
@@ -92,7 +99,25 @@ module Supplejack
       true
     end
 
+    # def build_authorities(name)
+    #   @attributes[:authorities] ||= []
+    #   authorities = @attributes[:authorities].find_all {|authority| authority["name"] == name }
+    #   authorities.map {|attributes| Supplejack::Authority.new(attributes) }
+    # end
+
     def method_missing(symbol, *args, &block)
+      if symbol.to_s.match(/(.+)_authorities/)
+        return build_authorities("#{$1}_authority")
+      end
+
+      if symbol.to_s.match(/(.+)_terms/)
+        return build_authorities("#{$1}_term")
+      end
+
+      if [:series_parent, :child_series, :collection_parent, :collection_root, :collection_mid].include?(symbol)
+        return build_authorities(symbol.to_s)
+      end
+
       raise NoMethodError, "undefined method '#{symbol.to_s}' for Supplejack::Record:Module" unless @attributes.has_key?(symbol)
       @attributes[symbol]
     end

data/lib/supplejack/search.rb

@@ -10,13 +10,13 @@ require 'digest/md5'
 
 module Supplejack
   class Search
-  	include Supplejack::Request
+    include Supplejack::Request
 
-  	attr_accessor :results, :text, :page, :per_page, :pagination_limit, :direction, :sort, :filters, :record_type, :record_klass
-  	attr_accessor :url_format, :without, :and, :or, :params, :api_params
+    attr_accessor :results, :text, :page, :per_page, :pagination_limit, :direction, :sort, :filters, :record_type, :record_klass
+    attr_accessor :url_format, :without, :and, :or, :params, :api_params
 
-  	def initialize(params={})
-  		@params = params.clone rescue {}
+    def initialize(params={})
+      @params = params.clone rescue {}
       @params[:facets] ||= Supplejack.facets.join(',')
       @params[:facets_per_page] ||= Supplejack.facets_per_page
       [:action, :controller].each {|p| @params.delete(p) }
@@ -30,10 +30,10 @@ module Supplejack
       @pagination_limit = @params[:pagination_limit] || Supplejack.pagination_limit
       @sort             = @params[:sort]
       @direction        = @params[:direction]
-      @url_format     	= Supplejack.url_format_klass.new(@params, self)
-      @filters        	= @url_format.filters
-      @api_params     	= @url_format.to_api_hash
-      @record_klass 		= @params[:record_klass] || Supplejack.record_klass
+      @url_format       = Supplejack.url_format_klass.new(@params, self)
+      @filters          = @url_format.filters
+      @api_params       = @url_format.to_api_hash
+      @record_klass     = @params[:record_klass] || Supplejack.record_klass
 
       # Do not execute the actual search right away, it should be lazy loaded
       # when the user needs one of the following values.
@@ -49,7 +49,7 @@ module Supplejack
         self.class.send(:attr_accessor, attribute)
         self.send("#{attribute}=", @filters[attribute]) unless @filters[attribute] == 'all'
       end
-  	end
+    end
 
     # Returns by default a array of two element arrays with all the active filters
     # in the search object and their values
@@ -217,9 +217,9 @@ module Supplejack
     #
     # @return [Hash{String => Integer}] A hash of type names and counts
     #
-    def types(options={})
-      return @types if @types
-      @types = facet_values('type', options)
+    def categories(options={})
+      return @categories if @categories
+      @categories = facet_values('category', options)
     end
 
     # Gets the facet values unrestricted by the current filter
@@ -309,6 +309,15 @@ module Supplejack
       return true
     end
 
+    # Gets the category facet unrestricted by the current category filter
+    #
+    # @return [Hash{String => Integer}] A hash of category names and counts
+    #
+    def categories(options={})
+      return @categories if @categories
+      @categories = facet_values("category", options)
+    end    
+
     # Convienence method to find out if the search object has any specific filter
     # applied to it. It works for both single and multiple value filters.
     # This methods are actually defined on method_missing.
@@ -341,6 +350,6 @@ module Supplejack
 
       Util.deep_merge(existing_filters, extra_filters)
     end
-  	
+    
   end
 end

data/lib/supplejack/user.rb

@@ -40,6 +40,10 @@ module Supplejack
       end
     end
 
+    def sets
+      @sets ||= UserSetRelation.new(self)
+    end
+
     # Initializes a UserSetRelation class which adds behaviour to build, create
     # find and order sets related to this particular User instance
     #

data/lib/supplejack/version.rb

@@ -6,5 +6,5 @@
 # and the Department of Internal Affairs. http://digitalnz.org/supplejack
 
 module Supplejack
-  VERSION = '1.0.2'
+  VERSION = '1.0.4'
 end

data/spec/supplejack/record_spec.rb

@@ -82,10 +82,16 @@ module Supplejack
     end
 
     describe '#metadata' do
-      it 'returns an array of hashes with supplejack fields their values and schemas' do
-        Supplejack.stub(:supplejack_fields) { [:location] }
+      it 'returns an array of hashes with special fields their values and schemas' do
+        Supplejack.stub(:special_fields) { {admin: {fields: [:location]}} }
         record = SupplejackRecord.new({:location => 'Wellington'})
-        record.metadata.should include({:name => 'location', :schema => 'supplejack', :value => 'Wellington'})
+        record.metadata.should include({:name => 'location', :schema => 'admin', :value => 'Wellington'})
+      end
+
+      it 'returns an array of hashes with special fields their values and schemas for multiple special_fields configured' do
+        Supplejack.stub(:special_fields) { {admin: {fields: [:location]}, dnz: {fields: [:description]}} }
+        record = SupplejackRecord.new({:location => 'Wellington', :description => "Some description"})
+        record.metadata.should include({:name => 'location', :schema => 'admin', :value => 'Wellington'}, {:name => 'description', :schema => 'dnz', :value => 'Some description'})
       end
 
       it 'should not return metadata for inexistent attribtues' do
@@ -95,9 +101,9 @@ module Supplejack
       end
 
       it 'returns multiple elements for a multi value field' do
-        Supplejack.stub(:supplejack_fields) { [:location] }
+        Supplejack.stub(:special_fields) { {admin: {fields: [:location]}} }
         record = SupplejackRecord.new({:location => ['Wellington', 'Auckland']})
-        record.metadata.should include({:name => 'location', :schema => 'supplejack', :value => 'Wellington'}, {:name => 'location', :schema => 'supplejack', :value => 'Auckland'})
+        record.metadata.should include({:name => 'location', :schema => 'admin', :value => 'Wellington'}, {:name => 'location', :schema => 'admin', :value => 'Auckland'})
       end
 
       it 'returns a empty array for a empty field' do
@@ -107,27 +113,27 @@ module Supplejack
       end
 
       it 'works for boolean fields too' do
-        Supplejack.stub(:supplejack_fields) { [:is_human] }
+        Supplejack.stub(:special_fields) { {admin: {fields: [:is_human]}} }
         record = SupplejackRecord.new({:is_human => true})
-        record.metadata.should include({:name => 'is_human', :schema => 'supplejack', :value => true})
+        record.metadata.should include({:name => 'is_human', :schema => 'admin', :value => true})
       end
 
-      it 'works for boolean fields when they are true' do
-        Supplejack.stub(:admin_fields) { [:is_animal] }
-        record = SupplejackRecord.new({:is_animal => true})
-        record.metadata.should include({:name => 'is_animal', :schema => 'admin', :value => true})
-      end
+      # it 'works for boolean fields when they are true' do
+      #   Supplejack.stub(:admin_fields) { [:is_animal] }
+      #   record = SupplejackRecord.new({:is_animal => true})
+      #   record.metadata.should include({:name => 'is_animal', :schema => 'admin', :value => true})
+      # end
 
       it 'works for boolean fields when they are false' do
-        Supplejack.stub(:admin_fields) { [:is_animal] }
-        record = SupplejackRecord.new({:is_animal => false})
-        record.metadata.should include({:name => 'is_animal', :schema => 'admin', :value => false})
+        Supplejack.stub(:special_fields) { {admin: {fields: [:is_human]}} }
+        record = SupplejackRecord.new({:is_human => false})
+        record.metadata.should include({:name => 'is_human', :schema => 'admin', :value => false})
       end
 
       it 'returns names with the schema removed' do
-        Supplejack.stub(:supplejack_fields) { [:identifier] }
-        record = SupplejackRecord.new({:identifier => 'sj:IE1174615'})
-        record.metadata.should include({:name => 'identifier', :schema => 'supplejack', :value => 'sj:IE1174615'})
+        Supplejack.stub(:special_fields) { {admin: {fields: [:admin_identifier]}} }
+        record = SupplejackRecord.new({:admin_identifier => 'sj:IE1174615'})
+        record.metadata.should include({:name => 'identifier', :schema => 'admin', :value => 'sj:IE1174615'})
       end
     end
 

data/spec/supplejack/search_spec.rb

@@ -18,9 +18,9 @@ class TestItem
 end
 
 module Supplejack
-	describe Search do
+  describe Search do
 
-		describe '#initalize' do
+    describe '#initalize' do
       it 'doesn\'t break when initalized with nil' do
         Search.new(nil)
       end
@@ -533,7 +533,7 @@ module Supplejack
       end
     end
 
-    describe '#types' do
+    describe '#categories' do
       before(:each) do
         @search = Search.new({:i => {:category => 'Books', :year => 2001}, :text => 'Dogs'})
         @search.stub(:get) { {'search' => {'facets' => {'category' => {'Books' => 123}}, 'result_count' => 123}} }
@@ -541,30 +541,30 @@ module Supplejack
 
       it 'should call the fetch_values method' do
         @search.should_receive(:facet_values).with('category', {})
-        @search.types
+        @search.categories
       end
 
       it 'removes category filter from the search request' do
         @search.should_receive(:get).with('/records', hash_including(:and => {:year => 2001})).and_return({'search' => {'facets' => {'category' => {'Books' => 123}}}})
-        @search.types
+        @search.categories
       end
 
       it 'returns the category facet hash ' do
-        @search.types.should include('Books' => 123)
+        @search.categories.should include('Books' => 123)
       end
 
       it 'asks the API for 0 results' do
         @search.should_receive(:get).with('/records', hash_including({:per_page => 0}))
-        @search.types
+        @search.categories
       end
 
       it 'should return add the All count to the hash' do
-        @search.types['All'].should eq 123
+        @search.categories['All'].should eq 123
       end
 
       it 'orders the category values by :count' do
         @search.should_receive(:facet_values).with('category', {:sort => :count})
-        @search.types({:sort => :count})
+        @search.categories({:sort => :count})
       end
     end
 
@@ -723,5 +723,5 @@ module Supplejack
       end
     end
 
-	end
+  end
 end

data/spec/supplejack/user_spec.rb

@@ -10,6 +10,7 @@ require 'spec_helper'
 module Supplejack
   describe User do
     let(:user) { Supplejack::User.new({'id' => 'abc', 'authentication_token' => '12345'}) }
+    let(:relation) { Supplejack::UserSetRelation.new(user) }
 
     before(:each) do
       Supplejack::User.stub(:get) { {'user' => {'id' => 'abc', 'authentication_token' => '12345'}} }
@@ -37,6 +38,14 @@ module Supplejack
       end
     end
 
+    describe "#sets" do
+      it "initializes a Dnz::UserSetRelation object" do
+        @relation = relation
+        Supplejack::UserSetRelation.should_receive(:new).with(user) { @relation }
+        user.sets.should be_a Supplejack::UserSetRelation
+      end
+    end
+
     describe '#save' do
       it 'should execute a put request with the user attribtues' do
         user.stub(:api_attributes) { {username: 'John', email: 'john@boost.co.nz'} }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: supplejack_client
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.4
 platform: ruby
 authors:
 - Supplejack