helix 0.0.4.3.pre → 0.0.4.4.pre

data/lib/helix/base.rb

@@ -137,8 +137,8 @@ module Helix
       base_url_opts = {content_type: (opts[:content_type] || :json)}
       url           = memo_cfg.build_url(base_url_opts.merge(guid: self.guid, resource_label: plural_resource_label))
       # We allow opts[:sig_type] for internal negative testing only.
-      raw_attrs   = memo_cfg.get_response(url, {sig_type: :view}.merge(opts))
-      @attributes = massage_raw_attrs(raw_attrs)
+      raw_attrs     = memo_cfg.get_response(url, {sig_type: :view}.merge(opts))
+      @attributes   = massage_raw_attrs(raw_attrs)
       self
     end
     alias_method :reload, :load
@@ -166,6 +166,7 @@ module Helix
     private
 
     def massage_raw_attrs(raw_attrs)
+      return raw_attrs['site'] if raw_attrs.respond_to?(:has_key?) && raw_attrs.has_key?('site')
       # FIXME: Albums JSON output is embedded as the only member of an Array.
       proper_hash = raw_attrs.respond_to?(:has_key?) && raw_attrs.has_key?(guid_name)
       proper_hash ? raw_attrs : raw_attrs.first

data/lib/helix/builds_urls.rb

@@ -0,0 +1,67 @@
+module Helix
+
+  module BuildsUrls
+
+    unless defined?(self::SCOPES)
+      SCOPES = [:reseller, :company, :library]
+    end
+
+    # Creates additional URL stubbing that can be used in conjuction
+    # with the base_url to create RESTful URLs
+    #
+    # @param [String] base_url the base part of the URL to be used
+    # @param [Hash] opts a hash of options for building URL additions
+    # @return [String] The full RESTful URL string object
+    def add_sub_urls(base_url, opts)
+      guid, action, format = [:guid, :action, :formats].map { |sub| opts[sub] }
+      url   = sub_url_scoping(base_url, opts)
+      url  += "/#{guid}"            if guid
+      url  += "/formats/#{format}"  if format
+      url  += "/#{action}"          if action
+      return url if opts[:content_type].blank?
+      "#{url}.#{opts[:content_type]}"
+    end
+
+    # Creates a full RESTful URL to be used for HTTP requests.
+    #
+    # @param [Hash] opts a hash of options for building URL
+    # @return [String] The full RESTful URL string object
+    def build_url(opts={})
+      opts[:content_type]   ||= :xml
+      opts[:resource_label] ||= :videos
+      base_url                = get_base_url(opts)
+      url                     = add_sub_urls(base_url, opts)
+    end
+
+    # Creates the base url with information collected from credentials.
+    #
+    # @param [Hash] opts a hash of options for building URL
+    # @return [String] The base RESTful URL string object
+    def get_base_url(opts)
+      creds     = credentials
+      base_url  = creds[:site]
+      return base_url if opts[:guid] || opts[:action] == :create_many
+      reseller, company, library = SCOPES.map { |scope| creds[scope] }
+      base_url += "/resellers/#{reseller}" if reseller
+      if company
+        base_url += "/companies/#{company}"
+        base_url += "/libraries/#{library}" if library
+      end
+      base_url
+    end
+
+    private
+
+    def sub_url_scoping(base_url, opts)
+      resource_label = opts[:resource_label]
+      if resource_label == 'libraries' and base_url !~ /companies/
+        co_id = opts[:company] || credentials[:company]
+        raise "No company to scope to: #{credentials}" if co_id.nil?
+        resource_label = "companies/#{co_id}/libraries"
+      end
+      "#{base_url}/#{resource_label}"
+    end
+
+  end
+
+end

data/lib/helix/config.rb

@@ -2,26 +2,27 @@ require 'helix/video'
 require 'helix/track'
 require 'helix/album'
 require 'helix/image'
+require 'helix/builds_urls'
+require 'helix/has_signatures'
+require 'helix/paginates'
 require 'singleton'
 
 module Helix
 
   class Config
 
+    include BuildsUrls
+    include HasSignatures
+    include Paginates
     include Singleton
 
     unless defined?(self::DEFAULT_FILENAME)
       DEFAULT_FILENAME = './helix.yml'
-      ITEMS_PER_PAGE   = 100
-      SCOPES           = [:reseller, :company, :library]
-      SIG_DURATION     = 1200 # in minutes
-      STARTING_PAGE    = 1
-      TIME_OFFSET      = 1000 * 60 # 1000 minutes, lower to give some margin of error
-      VALID_SIG_TYPES  = [ :ingest, :update, :view ]
     end
 
-    attr_accessor :credentials
-    attr_reader   :response, :signature_for, :signature_expiration_for
+    attr_accessor :credentials                              # local
+    attr_reader   :response                                 # in Paginates
+    attr_reader   :signature_for, :signature_expiration_for # in HasSignatures
 
     # Creates a singleton of itself, setting the config
     # to a specified YAML file. If no file is specified the default
@@ -42,122 +43,6 @@ module Helix
       config
     end
 
-    # Creates additional URL stubbing that can be used in conjuction
-    # with the base_url to create RESTful URLs
-    #
-    # @param [String] base_url the base part of the URL to be used
-    # @param [Hash] opts a hash of options for building URL additions
-    # @return [String] The full RESTful URL string object
-    def add_sub_urls(base_url, opts)
-      guid, action, format = [:guid, :action, :formats].map { |sub| opts[sub] }
-      url   = sub_url_scoping(base_url, opts)
-      url  += "/#{guid}"            if guid
-      url  += "/formats/#{format}"  if format
-      url  += "/#{action}"          if action
-      return url if opts[:content_type].blank?
-      "#{url}.#{opts[:content_type]}"
-    end
-
-    # Creates a full RESTful URL to be used for HTTP requests.
-    #
-    # @param [Hash] opts a hash of options for building URL
-    # @return [String] The full RESTful URL string object
-    def build_url(opts={})
-      opts[:content_type]   ||= :xml
-      opts[:resource_label] ||= :videos
-      base_url                = get_base_url(opts)
-      url                     = add_sub_urls(base_url, opts)
-    end
-
-    def clear_signatures!
-      @signature_for            = {}
-      @signature_expiration_for = {}
-    end
-
-    # Makes aggregated calls to get_response with pagination
-    # folding/injecting/accumulating the results into a single output set.
-    #
-    # @param [String] url the base part of the URL to be used
-    # @param [String] plural_resource_label: "videos", "tracks", etc.
-    # @param [Hash] original_opts a hash of options for building URL additions
-    # @return [Array] The accumulated attribute Hashes for ORM instances
-    def get_aggregated_data_sets(url, plural_resource_label, original_opts={})
-      data_sets, page, per_page = [], STARTING_PAGE
-      begin
-        aggregation_opts = {page: page, per_page: ITEMS_PER_PAGE}.merge(original_opts)
-        raw_response = get_response(url, {sig_type: :view}.merge(aggregation_opts))
-        data_set     = raw_response[plural_resource_label]
-        data_sets   += data_set if data_set
-        page        += 1
-      end until last_page?
-      data_sets
-    end
-
-    # Creates the base url with information collected from credentials.
-    #
-    # @param [Hash] opts a hash of options for building URL
-    # @return [String] The base RESTful URL string object
-    def get_base_url(opts)
-      creds     = credentials
-      base_url  = creds[:site]
-      return base_url if opts[:guid] || opts[:action] == :create_many
-      reseller, company, library = SCOPES.map { |scope| creds[scope] }
-      base_url += "/resellers/#{reseller}" if reseller
-      if company
-        base_url += "/companies/#{company}"
-        base_url += "/libraries/#{library}" if library
-      end
-      base_url
-    end
-
-    # Creates additional URL stubbing that can be used in conjuction
-    # with the base_url to create RESTful URLs
-    #
-    # @param [String] url the base part of the URL to be used
-    # @param [Hash] original_opts a hash of options for building URL additions
-    # @return [String] The full RESTful URL string object
-    def get_response(url, original_opts={})
-      opts        = massage_custom_fields_in(original_opts)
-      sig_type    = opts.delete(:sig_type)
-      params      = opts.merge(signature: signature(sig_type, opts))
-      begin
-        @response = RestClient.get(url, params: params)
-      rescue RestClient::InternalServerError => e
-        raise NetworkError, "Unable to access url #{url} with params #{params}"
-      end
-      parse_response_by_url_format(@response, url)
-    end
-
-    # Reports whether the most recent response's headers have a true :is_last_page value
-    #
-    # @return [Boolean] As above. Returns false if no such header is found,
-    # or if there is an explictly false value.
-    def last_page?
-      return false unless @response
-      return false unless @response.headers
-      return true  unless @response.headers.has_key?(:is_last_page)
-      @response.headers[:is_last_page] == "true"
-    end
-
-    # Fetches the signature for a specific license key.
-    #
-    # @param [Symbol] sig_type The type of signature required for calls.
-    # @param [Hash] opts allows you to overide contributor and license_id
-    # @return [String] The signature needed to pass around for calls.
-    def signature(sig_type, opts={})
-      prepare_signature_memoization
-      memo_sig = existing_sig_for(sig_type)
-      return memo_sig if memo_sig
-      unless VALID_SIG_TYPES.include?(sig_type)
-        raise ArgumentError, error_message_for(sig_type)
-      end
-
-      lk = license_key
-      @signature_expiration_for[lk][sig_type] = Time.now + TIME_OFFSET
-      new_sig_url                  = url_for(sig_type, opts)
-      @signature_for[lk][sig_type] = RestClient.get(new_sig_url)
-    end
-
     def proxy
       if @credentials[:proxy_uri]
         protocol, uri = @credentials[:proxy_uri].split "://"
@@ -172,88 +57,6 @@ module Helix
       end
     end
 
-    private
-
-    def sub_url_scoping(base_url, opts)
-      resource_label = opts[:resource_label]
-      if resource_label == 'libraries' and base_url !~ /companies/
-        co_id = opts[:company] || credentials[:company]
-        raise "No company to scope to: #{credentials}" if co_id.nil?
-        resource_label = "companies/#{co_id}/libraries"
-      end
-      "#{base_url}/#{resource_label}"
-    end
-
-    def error_message_for(sig_type)
-      "I don't understand '#{sig_type}'. Please give me one of :ingest, :update, or :view."
-    end
-
-    def existing_sig_for(sig_type)
-      return if sig_expired_for?(sig_type)
-      @signature_for[license_key][sig_type]
-    end
-
-    def get_contributor_library_company(opts)
-      sig_param_labels = [:contributor, :library, :company]
-      scoping_proc     = lambda { |key| opts[key] || credentials[key] }
-      contributor, library, company = sig_param_labels.map(&scoping_proc)
-      contributor    ||= 'helix_default_contributor'
-      [contributor, library, company]
-    end
-
-    def license_key
-      @credentials[:license_key]
-    end
-
-    def massage_custom_fields_in(opts)
-      return opts.clone unless opts.has_key?(:custom_fields)
-      cf_opts = opts.delete(:custom_fields)
-      cf_opts.inject(opts.clone) do |memo,pair|
-        k,v = pair
-        memo.merge("custom_fields[#{k}]" => v)
-      end
-    end
-
-    def parse_response_by_url_format(response, url)
-      ### FIXME: This is ugly. Clean it up.
-      if url =~ /json/
-        JSON.parse(response)
-      elsif url =~ /xml/
-        #TODO: Cleanup Nori and response gsub.
-        Nori.parser = :nokogiri
-        xml = response.gsub(/<custom-fields type='array'>/, '<custom-fields type=\'hash\'>')
-        Nori.parse(xml)
-      elsif url =~ /csv/
-        response
-      else
-        raise "Could not parse #{url}"
-      end
-    end
-
-    def prepare_signature_memoization
-      lk = license_key
-      @signature_for                ||= {}
-      @signature_expiration_for     ||= {}
-      @signature_for[lk]            ||= {}
-      @signature_expiration_for[lk] ||= {}
-    end
-
-    def sig_expired_for?(sig_type)
-      expires_at = @signature_expiration_for[license_key][sig_type]
-      return true if expires_at.nil?
-      expires_at <= Time.now
-    end
-
-    def url_for(sig_type, opts={})
-      contributor, library, company = get_contributor_library_company(opts)
-      url  = "#{credentials[:site]}/api/#{sig_type}_key?"
-      url += "licenseKey=#{credentials[:license_key]}&duration=#{SIG_DURATION}"
-      url += "&contributor=#{contributor}" if sig_type == :ingest
-      url += "&library_id=#{library}"   if library
-      url += "&company_id=#{company}"   if company
-      url
-    end
-
   end
 
 end

data/lib/helix/has_signatures.rb

@@ -0,0 +1,84 @@
+module Helix
+
+  module HasSignatures
+
+    unless defined?(self::VALID_SIG_TYPES)
+      SIG_DURATION     = 1200 # in minutes
+      TIME_OFFSET      = 1000 * 60 # 1000 minutes, lower to give some margin of error
+      VALID_SIG_TYPES  = [ :ingest, :update, :view ]
+    end
+
+    def clear_signatures!
+      @signature_for            = {}
+      @signature_expiration_for = {}
+    end
+
+    # Fetches the signature for a specific license key.
+    #
+    # @param [Symbol] sig_type The type of signature required for calls.
+    # @param [Hash] opts allows you to overide contributor and license_id
+    # @return [String] The signature needed to pass around for calls.
+    def signature(sig_type, opts={})
+      prepare_signature_memoization
+      memo_sig = existing_sig_for(sig_type)
+      return memo_sig if memo_sig
+      unless VALID_SIG_TYPES.include?(sig_type)
+        raise ArgumentError, error_message_for(sig_type)
+      end
+
+      lk = license_key
+      @signature_expiration_for[lk][sig_type] = Time.now + TIME_OFFSET
+      new_sig_url                  = signature_url_for(sig_type, opts)
+      @signature_for[lk][sig_type] = RestClient.get(new_sig_url)
+    end
+
+    private
+
+    def error_message_for(sig_type)
+      "I don't understand '#{sig_type}'. Please give me one of :ingest, :update, or :view."
+    end
+
+    def existing_sig_for(sig_type)
+      return if sig_expired_for?(sig_type)
+      @signature_for[license_key][sig_type]
+    end
+
+    def get_contributor_library_company(opts)
+      sig_param_labels = [:contributor, :library, :company]
+      scoping_proc     = lambda { |key| opts[key] || credentials[key] }
+      contributor, library, company = sig_param_labels.map(&scoping_proc)
+      contributor    ||= 'helix_default_contributor'
+      [contributor, library, company]
+    end
+
+    def license_key
+      @credentials[:license_key]
+    end
+
+    def prepare_signature_memoization
+      lk = license_key
+      @signature_for                ||= {}
+      @signature_expiration_for     ||= {}
+      @signature_for[lk]            ||= {}
+      @signature_expiration_for[lk] ||= {}
+    end
+
+    def sig_expired_for?(sig_type)
+      expires_at = @signature_expiration_for[license_key][sig_type]
+      return true if expires_at.nil?
+      expires_at <= Time.now
+    end
+
+    def signature_url_for(sig_type, opts={})
+      contributor, library, company = get_contributor_library_company(opts)
+      url  = "#{credentials[:site]}/api/#{sig_type}_key?"
+      url += "licenseKey=#{credentials[:license_key]}&duration=#{SIG_DURATION}"
+      url += "&contributor=#{contributor}" if sig_type == :ingest
+      url += "&library_id=#{library}"   if library
+      url += "&company_id=#{company}"   if company
+      url
+    end
+
+  end
+
+end

data/lib/helix/library.rb

@@ -13,6 +13,16 @@ module Helix
       super(nickname, opts.merge(content_type: :xml))
     end
 
+    # Creates a string that associates to the class id.
+    #
+    # @example
+    #   Helix::Library.guid_name #=> "name"
+    #
+    # @return [String] The guid name for a specific class.
+    def self.guid_name
+      "name"
+    end
+
     # The class name, to be used by supporting classes. Such as Config which uses
     # this method as a way to build URLs.
     #
@@ -33,6 +43,7 @@ module Helix
       "libraries"
     end
 
+    #TODO: Revisit and document.
     def self.known_attributes
       [:player_profile, :ingest_profile, :secure_stream_callback_url, :hooks_attributes]
     end

data/lib/helix/paginates.rb

@@ -0,0 +1,91 @@
+module Helix
+
+  module Paginates
+
+    unless defined?(self::STARTING_PAGE)
+      ITEMS_PER_PAGE = 100
+      STARTING_PAGE  = 1
+    end
+
+    # Makes aggregated calls to get_response with pagination
+    # folding/injecting/accumulating the results into a single output set.
+    #
+    # @param [String] url the base part of the URL to be used
+    # @param [String] plural_resource_label: "videos", "tracks", etc.
+    # @param [Hash] original_opts a hash of options for building URL additions
+    # @return [Array] The accumulated attribute Hashes for ORM instances
+    def get_aggregated_data_sets(url, plural_resource_label, original_opts={})
+      data_sets, page, per_page = [], STARTING_PAGE
+      begin
+        aggregation_opts = {page: page, per_page: ITEMS_PER_PAGE}.merge(original_opts)
+        raw_response = get_response(url, {sig_type: :view}.merge(aggregation_opts))
+        data_set     = raw_response[plural_resource_label]
+        data_sets   += data_set if data_set
+        page        += 1
+      end until last_page? || specific_page_requested?(original_opts)
+      data_sets
+    end
+
+    # Creates additional URL stubbing that can be used in conjuction
+    # with the base_url to create RESTful URLs
+    #
+    # @param [String] url the base part of the URL to be used
+    # @param [Hash] original_opts a hash of options for building URL additions
+    # @return [String] The full RESTful URL string object
+    def get_response(url, original_opts={})
+      opts     = massage_custom_fields_in(original_opts)
+      sig_type = opts.delete(:sig_type)
+      params   = opts.merge(signature: signature(sig_type, opts))
+      begin
+        @response = RestClient.get(url, params: params)
+      rescue RestClient::InternalServerError => e
+        raise NetworkError, "Unable to access url #{url} with params #{params}"
+      end
+      parse_response_by_url_format(@response, url)
+    end
+
+    private
+
+    # Reports whether the most recent response's headers have a true :is_last_page value
+    #
+    # @return [Boolean] As above. Returns false if no such header is found,
+    # or if there is an explictly false value.
+    def last_page?
+      return false unless @response
+      return false unless @response.headers
+      return true  unless @response.headers.has_key?(:is_last_page)
+      @response.headers[:is_last_page] == "true"
+    end
+
+    def massage_custom_fields_in(opts)
+      return opts.clone unless opts.has_key?(:custom_fields)
+      cf_opts = opts.delete(:custom_fields)
+      cf_opts.inject(opts.clone) do |memo,pair|
+        k,v = pair
+        memo.merge("custom_fields[#{k}]" => v)
+      end
+    end
+
+    def specific_page_requested?(original_opts)
+      original_opts.has_key?(:page)
+    end
+
+    def parse_response_by_url_format(response, url)
+      ### FIXME: This is ugly. Clean it up.
+      if url =~ /json/
+        JSON.parse(response)
+      elsif url =~ /xml/
+        #TODO: Cleanup Nori and response gsub.
+        Nori.parser = :nokogiri
+        xml = response.gsub(/<custom-fields type='array'>/, '<custom-fields type=\'hash\'>')
+        Nori.parse(xml)
+      elsif url =~ /csv/
+        response
+      else
+        raise "Could not parse #{url}"
+      end
+    end
+
+  end
+
+end

data/spec/base_spec.rb

@@ -289,6 +289,11 @@ describe Helix::Base do
           subject { obj.send(meth, raw_attrs) }
           it { should eq(nil) }
         end
+        context "when given {'site' => :site_contents}" do
+          let(:raw_attrs) { {'site' => :site_contents} }
+          subject { obj.send(meth, raw_attrs) }
+          it { should eq(:site_contents) }
+        end
         context "when given { guid_name => :the_val }" do
           let(:raw_attrs) { { guid_name => :the_val } }
           subject { obj.send(meth, raw_attrs) }

data/spec/config_spec.rb

@@ -336,34 +336,6 @@ describe Helix::Config do
     end
   end
 
-  describe "#get_aggregated_data_sets" do
-    let(:meth)  { :get_aggregated_data_sets }
-    subject     { obj.method(meth) }
-    its(:arity) { should eq(-3) }
-    context "when called" do
-      let(:opts)  { {opts_key1: :opts_val1, per_page: 99} }
-      let(:label) { :videos }
-      before(:each) do
-        obj.stub(:signature) { :the_sig }
-      end
-      subject { obj.send(meth, :a_url, label, opts) }
-      it "should successively call RestClient.get with the opts arg merged with pagination info and return the parsed results" do
-        base_opts = {opts_key1: :opts_val1, per_page: 99, signature: :the_sig}
-        opts1 = {params: base_opts.merge(page: 1)}
-        opts2 = {params: base_opts.merge(page: 2)}
-        opts3 = {params: base_opts.merge(page: 3)}
-        non_final_response = double(String, headers: {is_last_page: 'false'})
-        final_response     = double(String, headers: {is_last_page: 'true'})
-        RestClient.should_receive(:get).with(:a_url, opts1) { non_final_response }
-        RestClient.should_receive(:get).with(:a_url, opts2) { non_final_response }
-        RestClient.should_receive(:get).with(:a_url, opts3) { final_response }
-        obj.stub(:parse_response_by_url_format).with(non_final_response, :a_url) { {label => [:non_final]} }
-        obj.stub(:parse_response_by_url_format).with(final_response, :a_url)     { {label => [:final]}     }
-        expect(obj.send(meth, :a_url, label, opts)).to eq([:non_final, :non_final, :final])
-      end
-    end
-  end
-
   describe "#get_response" do
     let(:meth)  { :get_response }
     subject     { obj.method(meth) }

data/spec/library_spec.rb

@@ -10,7 +10,7 @@ describe Helix::Library do
   mods.each { |mod| its(:ancestors) { should include(mod) } }
   its(:ancestors) { should_not include(Helix::Media) }
 
-  its(:guid_name)             { should eq('library_id') }
+  its(:guid_name)             { should eq('name')       }
   its(:resource_label_sym)    { should be(:library)     }
   its(:plural_resource_label) { should eq('libraries')  }
   [:find, :create, :all, :find_all, :where].each do |crud_call|

data/spec/paginates_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'helix'
+
+describe Helix::Paginates do
+
+  class DummyClass;end
+
+  before(:each) do
+    @klass = DummyClass.new
+    @klass.extend(Helix::Paginates)
+  end
+
+
+  describe "#get_aggregated_data_sets" do
+    let(:meth)  { :get_aggregated_data_sets }
+    subject     { @klass.method(meth) }
+    its(:arity) { should eq(-3) }
+    context "when called" do
+      let(:opts)      { {opts_key1: :opts_val1, per_page: 99} }
+      let(:label)     { :videos }
+      let(:base_opts) { {opts_key1: :opts_val1, per_page: 99, signature: :the_sig} }
+      let(:opts1)     { {params: base_opts.merge(page: 1)} }
+      let(:opts2)     { {params: base_opts.merge(page: 2)} }
+      let(:opts3)     { {params: base_opts.merge(page: 3)} }
+      before(:each) { @klass.stub(:signature) { :the_sig } }
+      subject { @klass.send(meth, :a_url, label, opts) }
+      it "should successively call RestClient.get with the opts arg merged with pagination info and return the parsed results" do
+        non_final_response = double(String, headers: {is_last_page: 'false'})
+        final_response     = double(String, headers: {is_last_page: 'true'})
+        RestClient.should_receive(:get).with(:a_url, opts1) { non_final_response }
+        RestClient.should_receive(:get).with(:a_url, opts2) { non_final_response }
+        RestClient.should_receive(:get).with(:a_url, opts3) { final_response }
+        @klass.stub(:parse_response_by_url_format).with(non_final_response, :a_url) { {label => [:non_final]} }
+        @klass.stub(:parse_response_by_url_format).with(final_response, :a_url)     { {label => [:final]}     }
+        expect(@klass.send(meth, :a_url, label, opts)).to eq([:non_final, :non_final, :final])
+      end
+
+      context "when a page param is passed in." do
+        let(:opts)  { {opts_key1: :opts_val1, page: 1} }
+        it "should only return one response" do
+          base_opts = {opts_key1: :opts_val1, per_page: 100, signature: :the_sig}
+          opts1 = {params: base_opts.merge(page: 1)}
+          non_final_response = double(String, headers: {is_last_page: 'false'})
+          RestClient.should_receive(:get).once { non_final_response }
+          @klass.stub(:parse_response_by_url_format).with(non_final_response, :a_url) { {label => [:non_final]} }
+          @klass.send(meth, :a_url, label, opts)  
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: helix
 version: !ruby/object:Gem::Version
-  version: 0.0.4.3.pre
+  version: 0.0.4.4.pre
   prerelease: 8
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-11 00:00:00.000000000 Z
+date: 2013-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -69,15 +69,18 @@ files:
 - lib/helix/album.rb
 - lib/helix/audio_playlist.rb
 - lib/helix/base.rb
+- lib/helix/builds_urls.rb
 - lib/helix/config.rb
 - lib/helix/document.rb
 - lib/helix/durationed.rb
 - lib/helix/exceptions.rb
+- lib/helix/has_signatures.rb
 - lib/helix/hash_ext.rb
 - lib/helix/image.rb
 - lib/helix/library.rb
 - lib/helix/media.rb
 - lib/helix/object_ext.rb
+- lib/helix/paginates.rb
 - lib/helix/playlist.rb
 - lib/helix/restful.rb
 - lib/helix/statistics.rb
@@ -98,6 +101,7 @@ files:
 - spec/image_spec.rb
 - spec/library_spec.rb
 - spec/media_spec.rb
+- spec/paginates_spec.rb
 - spec/playlist_spec.rb
 - spec/spec_helper.rb
 - spec/statistics_spec.rb