helix 0.0.2.5.pre → 0.0.2.6.pre

data/lib/helix/album.rb

@@ -9,10 +9,10 @@ module Helix
     #
     #
     # @example
-    #   Helix::Album.media_type_sym #=> :album
+    #   Helix::Album.resource_label_sym #=> :album
     #
     # @return [Symbol] Name of the class.
-    def self.media_type_sym; :album; end
+    def self.resource_label_sym; super; end
 
     # Currently update is unsupported for album.
     #

data/lib/helix/base.rb

@@ -8,7 +8,7 @@ module Helix
   class Base
 
     unless defined?(self::METHODS_DELEGATED_TO_CLASS)
-      METHODS_DELEGATED_TO_CLASS = [ :guid_name, :media_type_sym, :plural_media_type ]
+      METHODS_DELEGATED_TO_CLASS = [ :guid_name, :resource_label_sym, :plural_resource_label ]
     end
 
     attr_accessor :attributes
@@ -48,11 +48,11 @@ module Helix
     # @param [Hash] opts a hash of options for parameters passed into the HTTP GET
     # @return [Array] The array of attributes (for a model) in hash form.
     def self.get_data_sets(opts)
-      url          = config.build_url(content_type: opts[:content_type] || :xml,
-                                      media_type:   self.plural_media_type)
+      url          = config.build_url(content_type:   opts[:content_type] || :xml,
+                                      resource_label: self.plural_resource_label)
       # We allow opts[:sig_type] for internal negative testing only.
       raw_response = config.get_response(url, {sig_type: :view}.merge(opts))
-      data_sets    = raw_response[plural_media_type]
+      data_sets    = raw_response[plural_resource_label]
     end
 
     # Creates a string that associates to the class id.
@@ -62,17 +62,17 @@ module Helix
     #
     # @return [String] The guid name for a specific class.
     def self.guid_name
-      "#{self.media_type_sym}_id"
+      "#{self.resource_label_sym}_id"
     end
 
     # Creates a string associated with a class name pluralized
     #
     # @example
-    #   Helix::Video.plural_media_type #=> "videos"
+    #   Helix::Video.plural_resource_label #=> "videos"
     #
     # @return [String] The class name pluralized
-    def self.plural_media_type
-      "#{self.media_type_sym}s"
+    def self.plural_resource_label
+      "#{self.resource_label_sym}s"
     end
 
     METHODS_DELEGATED_TO_CLASS.each do |meth|
@@ -111,7 +111,7 @@ module Helix
     # @return [Base] Returns an instance of the class.
     def load(opts={})
       memo_cfg    = config
-      url         = memo_cfg.build_url(content_type: :json, guid: self.guid, media_type: plural_media_type)
+      url         = memo_cfg.build_url(content_type: :json, 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)
@@ -170,5 +170,9 @@ module Helix
       attrs.merge({'custom_fields' => cfs})
     end
 
+    def self.resource_label_sym
+      to_s.split('::').last.singularize.downcase.to_sym
+    end
+
   end
 end

data/lib/helix/config.rb

@@ -48,7 +48,7 @@ module Helix
     # @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   = "#{base_url}/#{opts[:media_type]}"
+      url   = "#{base_url}/#{opts[:resource_label]}"
       url  += "/#{guid}"            if guid
       url  += "/formats/#{format}"  if format
       url  += "/#{action}"          if action
@@ -61,10 +61,10 @@ module Helix
     # @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[:media_type]   ||= :videos
-      base_url              = get_base_url(opts)
-      url                   = add_sub_urls(base_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!

data/lib/helix/durationed_media.rb

@@ -75,13 +75,13 @@ module Helix
       #
       # @return [Hash]
       def url_opts_for(format=nil)
-        { slice:       {  action:       :slice,
-                          media_type:   plural_media_type,
-                          content_type: :xml,
-                          formats:      format },
-          create_many: {  action:       :create_many,
-                          media_type:   plural_media_type,
-                          content_type: :xml }
+        { slice:       {  action:         :slice,
+                          resource_label: plural_resource_label,
+                          content_type:   :xml,
+                          formats:        format },
+          create_many: {  action:         :create_many,
+                          resource_label: plural_resource_label,
+                          content_type:   :xml }
         }
       end
     end

data/lib/helix/image.rb

@@ -9,10 +9,10 @@ module Helix
     #
     #
     # @example
-    #   Helix::Image.media_type_sym #=> :image
+    #   Helix::Image.resource_label_sym #=> :image
     #
     # @return [Symbol] Name of the class.
-    def self.media_type_sym; :image; end
+    def self.resource_label_sym; super; end
 
   end
 

data/lib/helix/library.rb

@@ -9,19 +9,19 @@ module Helix
     #
     #
     # @example
-    #   Helix::Library.media_type_sym #=> :library
+    #   Helix::Library.resource_label_sym #=> :library
     #
     # @return [Symbol] Name of the class.
-    def self.media_type_sym; :library; end
+    def self.resource_label_sym; super; end
 
     # Creates a string associated with a class name pluralized
     #
     # @example
-    #   Helix::Library.plural_media_type #=> "libraries"
+    #   Helix::Library.plural_resource_label #=> "libraries"
     #
     # @return [String] The class name pluralized
-    def self.plural_media_type
-      "#{self.media_type_sym.to_s.gsub(/y/, '')}ies"
+    def self.plural_resource_label
+      "libraries"
     end
 
     def self.known_attributes
@@ -30,4 +30,4 @@ module Helix
 
   end
 
-end
+end

data/lib/helix/media.rb

@@ -13,11 +13,11 @@ module Helix
     # @param [Hash] attributes a hash containing the attributes used in the create
     # @return [Base] An instance of Helix::Base
     def self.create(attributes={})
-      url       = config.build_url(media_type:    plural_media_type,
-                                   content_type:  :xml)
+      url       = config.build_url(resource_label: plural_resource_label,
+                                   content_type:   :xml)
       response  = RestClient.post(url, attributes.merge(signature: config.signature(:update)))
       attrs     = Hash.from_xml(response)
-      self.new(attributes: attrs[media_type_sym.to_s], config: config)
+      self.new(attributes: attrs[resource_label_sym.to_s], config: config)
     end
 
     # Finds and returns a record in instance form for a class, through
@@ -43,7 +43,7 @@ module Helix
     #
     # @return [String] The response from the HTTP DELETE call.
     def destroy
-      url      = config.build_url(content_type: :xml, guid: guid, media_type: plural_media_type)
+      url      = config.build_url(content_type: :xml, guid: guid, resource_label: plural_resource_label)
       RestClient.delete(url, params: {signature: config.signature(:update)})
     end
 
@@ -58,10 +58,10 @@ module Helix
     def update(opts={})
       RestClient.log = 'helix.log' if opts.delete(:log)
       memo_cfg = config
-      url      = memo_cfg.build_url(content_type: :xml,
-                                    guid:         guid,
-                                    media_type:   plural_media_type)
-      params   = {signature: memo_cfg.signature(:update)}.merge(media_type_sym => opts)
+      url      = memo_cfg.build_url(content_type:   :xml,
+                                    guid:           guid,
+                                    resource_label: plural_resource_label)
+      params   = {signature: memo_cfg.signature(:update)}.merge(resource_label_sym => opts)
       RestClient.put(url, params)
       self
     end

data/lib/helix/statistics.rb

@@ -124,42 +124,42 @@ module Helix
 
     private
 
-    def self.delivery(media_type, opts)
+    def self.delivery(resource_label, opts)
       memo_cfg      = Helix::Config.instance
       content_type  = opts.delete(:content_type)
-      guid          = opts.delete("#{media_type}_id".to_sym)
+      guid          = opts.delete("#{resource_label}_id".to_sym)
       url_opts      = guid ?
-        {guid: guid, media_type: "#{media_type}s".to_sym, action: :statistics} :
-        {media_type: :statistics, action: "#{media_type}_delivery".to_sym}
+        {guid: guid, resource_label: "#{resource_label}s".to_sym, action: :statistics} :
+        {resource_label: :statistics, action: "#{resource_label}_delivery".to_sym}
       url_opts.merge!(content_type: content_type) if content_type
       url = memo_cfg.build_url(url_opts)
       # We allow opts[:sig_type] for internal negative testing only.
       memo_cfg.get_response(url, {sig_type: :view}.merge(opts))
     end
 
-    def self.ingest(media_type, opts)
+    def self.ingest(resource_label, opts)
       opts[:action] ||= :breakdown
-      action_prefix   = ingest_action_prefix_for(media_type)
-      storage(media_type, opts.merge(action: :"#{action_prefix}/#{opts[:action]}"))
+      action_prefix   = ingest_action_prefix_for(resource_label)
+      storage(resource_label, opts.merge(action: :"#{action_prefix}/#{opts[:action]}"))
     end
 
-    def self.storage(media_type, opts)
+    def self.storage(resource_label, opts)
       memo_cfg      = Helix::Config.instance
       content_type  = opts.delete(:content_type)
-      action        = opts.delete(:action) || storage_action_for(media_type)
-      url_opts      = {media_type: :statistics, action: action}
+      action        = opts.delete(:action) || storage_action_for(resource_label)
+      url_opts      = {resource_label: :statistics, action: action}
       url_opts.merge!(content_type: content_type) if content_type
       url = memo_cfg.build_url(url_opts)
       # We allow opts[:sig_type] for internal negative testing only.
       memo_cfg.get_response(url, {sig_type: :view}.merge(opts))
     end
 
-    def self.ingest_action_prefix_for(media_type)
-      STORAGE_ACTION_FOR[media_type].split('/').first
+    def self.ingest_action_prefix_for(resource_label)
+      STORAGE_ACTION_FOR[resource_label].split('/').first
     end
 
-    def self.storage_action_for(media_type)
-      STORAGE_ACTION_FOR[media_type].to_sym
+    def self.storage_action_for(resource_label)
+      STORAGE_ACTION_FOR[resource_label].to_sym
     end
 
   end

data/lib/helix/tag.rb

@@ -10,9 +10,9 @@ module Helix
     #
     #
     # @example
-    #   Helix::Tag.media_type_sym #=> :tag
+    #   Helix::Tag.resource_label_sym #=> :tag
     #
     # @return [Symbol] Name of the class.
-    def self.media_type_sym; :tag; end
+    def self.resource_label_sym; super; end
   end
-end
+end

data/lib/helix/track.rb

@@ -11,9 +11,9 @@ module Helix
     #
     #
     # @example
-    #   Helix::Track.media_type_sym #=> :track
+    #   Helix::Track.resource_label_sym #=> :track
     #
     # @return [Symbol] Name of the class.
-    def self.media_type_sym; :track; end
+    def self.resource_label_sym; super; end
   end
 end

data/lib/helix/video.rb

@@ -12,10 +12,10 @@ module Helix
     #
     #
     # @example
-    #   Helix::Video.media_type_sym #=> :video
+    #   Helix::Video.resource_label_sym #=> :video
     #
     # @return [Symbol] Name of the class.
-    def self.media_type_sym; :video; end
+    def self.resource_label_sym; super; end
 
     def self.slice(attrs={})
       rest_post(:slice, attrs)
@@ -68,7 +68,7 @@ module Helix
 
     def generic_download(opts)
       content_type = opts[:content_type] || ''
-      url = config.build_url(action: opts[:action], content_type: content_type, guid: guid, media_type: plural_media_type)
+      url = config.build_url(action: opts[:action], content_type: content_type, guid: guid, resource_label: plural_resource_label)
       RestClient.get(url, params: {signature: config.signature(:view)})
     end
 

data/spec/album_spec.rb

@@ -7,8 +7,8 @@ describe Helix::Album do
   subject { klass }
   its(:ancestors) { should include(Helix::Base) }
   its(:guid_name) { should eq('album_id') }
-  its(:media_type_sym)    { should be(:album)   }
-  its(:plural_media_type) { should eq('albums') }
+  its(:resource_label_sym)    { should be(:album)   }
+  its(:plural_resource_label) { should eq('albums') }
   [:find, :create, :all, :find_all, :where].each do |crud_call|
     it { should respond_to(crud_call) }
   end
@@ -26,7 +26,7 @@ describe Helix::Album do
   describe "an instance" do
     let(:obj) { klass.new({'album_id' => 'some_album_guid'}) }
     subject { obj }
-    its(:media_type_sym) { should be(:album) }
+    its(:resource_label_sym) { should be(:album) }
     describe "#update" do
       let(:meth) { :update }
       it "should raise an error" do

data/spec/base_spec.rb

@@ -5,10 +5,10 @@ describe Helix::Base do
 
   def set_stubs(obj, even_sig=false)
     obj.instance_variable_set(:@attributes, {})
-    obj.stub(:media_type_sym)    { :video      }
-    obj.stub(:plural_media_type) { 'videos'    }
-    obj.stub(:guid)              { 'some_guid' }
-    obj.stub(:signature)         { 'some_sig'  } if even_sig
+    obj.stub(:resource_label_sym)    { :video      }
+    obj.stub(:plural_resource_label) { 'videos'    }
+    obj.stub(:guid)                  { 'some_guid' }
+    obj.stub(:signature)             { 'some_sig'  } if even_sig
   end
 
   let(:klass) { Helix::Base }
@@ -18,7 +18,7 @@ describe Helix::Base do
   describe "Constants" do
     describe "METHODS_DELEGATED_TO_CLASS" do
       subject { klass::METHODS_DELEGATED_TO_CLASS }
-      it { should eq([:guid_name, :media_type_sym, :plural_media_type]) }
+      it { should eq([:guid_name, :resource_label_sym, :plural_resource_label]) }
     end
   end
 
@@ -41,21 +41,21 @@ describe Helix::Base do
     before(:each) do Helix::Config.stub(:instance) { mock_config } end
     context "when given a config instances and an opts Hash" do
       let(:opts) { {opts_key1: :opts_val1} }
-      let(:plural_media_type) { :videos }
-      before(:each) do klass.stub(:plural_media_type) { plural_media_type } end
+      let(:plural_resource_label) { :videos }
+      before(:each) do klass.stub(:plural_resource_label) { plural_resource_label } end
       it "should build a XML URL -> the_url" do
-        mock_config.should_receive(:build_url).with(content_type: :xml,
-                                                    media_type:   plural_media_type)
+        mock_config.should_receive(:build_url).with(content_type:   :xml,
+                                                    resource_label: plural_resource_label)
         klass.send(meth, opts)
       end
       it "should get_response(the_url, {sig_type: :view}.merge(opts) -> raw_response" do
         mock_config.should_receive(:get_response).with(:built_url, {sig_type: :view}.merge(opts))
         klass.send(meth, opts)
       end
-      it "should read raw_response[plural_media_type] -> data_sets" do
+      it "should read raw_response[plural_resource_label] -> data_sets" do
         mock_raw_response = mock(Object)
         mock_config.stub(:get_response) { mock_raw_response }
-        mock_raw_response.should_receive(:[]).with(plural_media_type)
+        mock_raw_response.should_receive(:[]).with(plural_resource_label)
         klass.send(meth, opts)
       end
       context "when data_sets is nil" do
@@ -63,7 +63,7 @@ describe Helix::Base do
       end
       context "when data_sets is NOT nil" do
         let(:data_set) { (0..2).to_a }
-        before(:each) do mock_config.stub(:get_response) { {plural_media_type => data_set } } end
+        before(:each) do mock_config.stub(:get_response) { {plural_resource_label => data_set } } end
         it "should map instantiation with attributes: each data set element" do
           klass.should_receive(:new).with(attributes: data_set[0], config: mock_config) { :a }
           klass.should_receive(:new).with(attributes: data_set[1], config: mock_config) { :b }
@@ -79,21 +79,21 @@ describe Helix::Base do
     subject           { klass.method(meth) }
     before(:each) do Helix::Config.stub(:instance) { mock_config } end
     context "when given a config instances and NO opts Hash" do
-      let(:plural_media_type) { :videos }
-      before(:each) do klass.stub(:plural_media_type) { plural_media_type } end
+      let(:plural_resource_label) { :videos }
+      before(:each) do klass.stub(:plural_resource_label) { plural_resource_label } end
       it "should build a XML URL -> the_url" do
-        mock_config.should_receive(:build_url).with(content_type: :xml,
-                                                    media_type:   plural_media_type)
+        mock_config.should_receive(:build_url).with(content_type:   :xml,
+                                                    resource_label: plural_resource_label)
         klass.send(meth)
       end
       it "should get_response(the_url, {sig_type: :view} -> raw_response" do
         mock_config.should_receive(:get_response).with(:built_url, {sig_type: :view})
         klass.send(meth)
       end
-      it "should read raw_response[plural_media_type] -> data_sets" do
+      it "should read raw_response[plural_resource_label] -> data_sets" do
         mock_raw_response = mock(Object)
         mock_config.stub(:get_response) { mock_raw_response }
-        mock_raw_response.should_receive(:[]).with(plural_media_type)
+        mock_raw_response.should_receive(:[]).with(plural_resource_label)
         klass.send(meth)
       end
       context "when data_sets is nil" do
@@ -101,7 +101,7 @@ describe Helix::Base do
       end
       context "when data_sets is NOT nil" do
         let(:data_set) { (0..2).to_a }
-        before(:each) do mock_config.stub(:get_response) { {plural_media_type => data_set } } end
+        before(:each) do mock_config.stub(:get_response) { {plural_resource_label => data_set } } end
         it "should map instantiation with attributes: each data set element" do
           klass.should_receive(:new).with(attributes: data_set[0], config: mock_config) { :a }
           klass.should_receive(:new).with(attributes: data_set[1], config: mock_config) { :b }
@@ -227,15 +227,15 @@ describe Helix::Base do
         obj.stub(:massage_raw_attrs)    { :massaged_attrs }
         mock_config.stub(:build_url)    { :expected_url   }
         mock_config.stub(:get_response) { :raw_attrs      }
-        klass.stub(:media_type_sym)     { :video          }
+        klass.stub(:resource_label_sym) { :video          }
       end
       shared_examples_for "builds URL for load" do
         it "should call #guid" do
           obj.should_receive(:guid) { 'some_guid' }
           obj.send(meth)
         end
-        it "should build_url(content_type: :json, guid: the_guid, media_type: 'videos')" do
-          mock_config.should_receive(:build_url).with(content_type: :json, guid: 'some_guid', media_type: 'videos')
+        it "should build_url(content_type: :json, guid: the_guid, resource_label: 'videos')" do
+          mock_config.should_receive(:build_url).with(content_type: :json, guid: 'some_guid', resource_label: 'videos')
           RestClient.stub(:put)
           obj.send(meth)
         end

data/spec/config_spec.rb

@@ -5,10 +5,10 @@ describe Helix::Config do
 
   def set_stubs(obj, even_sig=false)
     obj.instance_variable_set(:@attributes, {})
-    obj.stub(:media_type_sym)    { :video      }
-    obj.stub(:plural_media_type) { 'videos'    }
-    obj.stub(:guid)              { 'some_guid' }
-    obj.stub(:signature)         { 'some_sig'  } if even_sig
+    obj.stub(:resource_label_sym)    { :video      }
+    obj.stub(:plural_resource_label) { 'videos'    }
+    obj.stub(:guid)                  { 'some_guid' }
+    obj.stub(:signature)             { 'some_sig'  } if even_sig
   end
 
   let(:klass) { Helix::Config  }
@@ -107,10 +107,10 @@ describe Helix::Config do
     end
   end
 
-  def build_test_url(site, sub_url, guid, action, media_type, content_type)
+  def build_test_url(site, sub_url, guid, action, resource_label, content_type)
     expected_url  = site
     expected_url += sub_url unless guid || action == :create_many
-    expected_url += "/#{media_type}"
+    expected_url += "/#{resource_label}"
     expected_url += "/the_guid" if guid
     expected_url += "/#{action}" if action
     expected_url += ".#{content_type}"
@@ -122,11 +122,11 @@ describe Helix::Config do
     subject     { obj.method(meth) }
     its(:arity) { should be(-1) }
     before(:each) do obj.credentials = { site: site } end
-    shared_examples_for "reads scope from credentials for build_url" do |media_type,content_type,more_opts|
+    shared_examples_for "reads scope from credentials for build_url" do |resource_label,content_type,more_opts|
       let(:opts)          { more_opts || {} }
       let(:action)        { opts[:action] }
       let(:guid)          { opts[:guid] }
-      let(:url_pieces)    { [site, sub_url, guid, action, media_type, content_type] }
+      let(:url_pieces)    { [site, sub_url, guid, action, resource_label, content_type] }
       let(:expected_url)  { build_test_url(*url_pieces) }
       before(:each) do obj.credentials = {site: 'http://example.com'} end
       context "and credentials has a key for :reseller" do
@@ -187,22 +187,22 @@ describe Helix::Config do
       subject { obj.send(meth, {guid: :the_guid, action: :the_action}) }
       it_behaves_like "reads scope from credentials for build_url", :videos, :xml, {guid: :the_guid, action: :the_action}
     end
-    [ :videos, :tracks ].each do |media_type|
-      context "when given opts[:media_type] of :#{media_type}" do
-        subject { obj.send(meth, media_type: media_type) }
-        it_behaves_like "reads scope from credentials for build_url", media_type, :xml
+    [ :videos, :tracks ].each do |resource_label|
+      context "when given opts[:resource_label] of :#{resource_label}" do
+        subject { obj.send(meth, resource_label: resource_label) }
+        it_behaves_like "reads scope from credentials for build_url", resource_label, :xml
       end
-      context "when given opts[:media_type] of :#{media_type} and opts[:guid] of :the_guid" do
-        subject { obj.send(meth, media_type: media_type, guid: :the_guid) }
-        it_behaves_like "reads scope from credentials for build_url", media_type, :xml, {guid: :the_guid}
+      context "when given opts[:resource_label] of :#{resource_label} and opts[:guid] of :the_guid" do
+        subject { obj.send(meth, resource_label: resource_label, guid: :the_guid) }
+        it_behaves_like "reads scope from credentials for build_url", resource_label, :xml, {guid: :the_guid}
       end
-      context "when given opts[:media_type] of :#{media_type} and opts[:action] of :the_action" do
-        subject { obj.send(meth, media_type: media_type, action: :the_action) }
-        it_behaves_like "reads scope from credentials for build_url", media_type, :xml, {action: :the_action}
+      context "when given opts[:resource_label] of :#{resource_label} and opts[:action] of :the_action" do
+        subject { obj.send(meth, resource_label: resource_label, action: :the_action) }
+        it_behaves_like "reads scope from credentials for build_url", resource_label, :xml, {action: :the_action}
       end
-      context "when given opts[:media_type] of :#{media_type}, opts[:guid] of :the_guid, opts[:action] of :the_action" do
-        subject { obj.send(meth, media_type: media_type, guid: :the_guid, action: :the_action) }
-        it_behaves_like "reads scope from credentials for build_url", media_type, :xml, {guid: :the_guid, action: :the_action}
+      context "when given opts[:resource_label] of :#{resource_label}, opts[:guid] of :the_guid, opts[:action] of :the_action" do
+        subject { obj.send(meth, resource_label: resource_label, guid: :the_guid, action: :the_action) }
+        it_behaves_like "reads scope from credentials for build_url", resource_label, :xml, {guid: :the_guid, action: :the_action}
       end
     end
     [ :json, :xml ].each do |content_type|
@@ -222,31 +222,31 @@ describe Helix::Config do
         subject { obj.send(meth, content_type: content_type, guid: :the_guid, action: :the_action) }
         it_behaves_like "reads scope from credentials for build_url", :videos, content_type, {guid: :the_guid, action: :the_action}
       end
-      [ :videos, :tracks ].each do |media_type|
-        context "when given opts[:content_type] of :#{content_type} and opts[:media_type] of :#{media_type}" do
-          subject { obj.send(meth, content_type: content_type, media_type: media_type) }
-          it_behaves_like "reads scope from credentials for build_url", media_type, content_type
+      [ :videos, :tracks ].each do |resource_label|
+        context "when given opts[:content_type] of :#{content_type} and opts[:resource_label] of :#{resource_label}" do
+          subject { obj.send(meth, content_type: content_type, resource_label: resource_label) }
+          it_behaves_like "reads scope from credentials for build_url", resource_label, content_type
         end
-        context "when given opts[:content_type] of :#{content_type}, opts[:guid] of :the_guid, and opts[:media_type] of :#{media_type}" do
-          subject { obj.send(meth, content_type: content_type, guid: :the_guid, media_type: media_type) }
-          it_behaves_like "reads scope from credentials for build_url", media_type, content_type, {guid: :the_guid}
+        context "when given opts[:content_type] of :#{content_type}, opts[:guid] of :the_guid, and opts[:resource_label] of :#{resource_label}" do
+          subject { obj.send(meth, content_type: content_type, guid: :the_guid, resource_label: resource_label) }
+          it_behaves_like "reads scope from credentials for build_url", resource_label, content_type, {guid: :the_guid}
         end
-        context "when given opts[:content_type] of :#{content_type}, opts[:action] of :the_action, and opts[:media_type] of :#{media_type}" do
-          subject { obj.send(meth, content_type: content_type, action: :the_action, media_type: media_type) }
-          it_behaves_like "reads scope from credentials for build_url", media_type, content_type, {action: :the_action}
+        context "when given opts[:content_type] of :#{content_type}, opts[:action] of :the_action, and opts[:resource_label] of :#{resource_label}" do
+          subject { obj.send(meth, content_type: content_type, action: :the_action, resource_label: resource_label) }
+          it_behaves_like "reads scope from credentials for build_url", resource_label, content_type, {action: :the_action}
         end
-        context "when given opts[:content_type] of :#{content_type}, opts[:guid] of :the_guid, opts[:action] of :the_action, and opts[:media_type] of :#{media_type}" do
-          subject { obj.send(meth, content_type: content_type, guid: :the_guid, action: :the_action, media_type: media_type) }
-          it_behaves_like "reads scope from credentials for build_url", media_type, content_type, {guid: :the_guid, action: :the_action}
+        context "when given opts[:content_type] of :#{content_type}, opts[:guid] of :the_guid, opts[:action] of :the_action, and opts[:resource_label] of :#{resource_label}" do
+          subject { obj.send(meth, content_type: content_type, guid: :the_guid, action: :the_action, resource_label: resource_label) }
+          it_behaves_like "reads scope from credentials for build_url", resource_label, content_type, {guid: :the_guid, action: :the_action}
         end
       end
     end
-    dl_opts = {action: :file, content_type: '', guid: :the_guid, media_type: :videos}
+    dl_opts = {action: :file, content_type: '', guid: :the_guid, resource_label: :videos}
     context "when given opts of #{dl_opts}" do
       subject { obj.send(meth, dl_opts) }
       it { should eq("http://example.com/videos/the_guid/file") }
     end
-    dp_opts = {action: :play, content_type: '', guid: :the_guid, media_type: :videos}
+    dp_opts = {action: :play, content_type: '', guid: :the_guid, resource_label: :videos}
     context "when given opts of #{dp_opts}" do
       subject { obj.send(meth, dp_opts) }
       it { should eq("http://example.com/videos/the_guid/play") }

data/spec/durationed_media_spec.rb

@@ -16,9 +16,10 @@ describe Helix::DurationedMedia do
 
     let(:sig_opts)  { { contributor:  :helix,
                         library_id:   :development } }
-    url_opts      =   { action:       :create_many,
-                        media_type:   klass.send(:plural_media_type),
-                        content_type: :xml }
+
+    url_opts      =   { action:         :create_many,
+                        resource_label: klass.send(:plural_resource_label),
+                        content_type:   :xml }
 
     describe ".import" do
       let(:meth)        { :import }
@@ -89,4 +90,4 @@ describe Helix::DurationedMedia do
       end
     end
   end
-end
+end

data/spec/image_spec.rb

@@ -7,8 +7,8 @@ describe Helix::Image do
   subject { klass }
   its(:ancestors) { should include(Helix::Base) }
   its(:guid_name) { should eq('image_id') }
-  its(:media_type_sym)    { should be(:image)   }
-  its(:plural_media_type) { should eq('images') }
+  its(:resource_label_sym)    { should be(:image)   }
+  its(:plural_resource_label) { should eq('images') }
   [:find, :create, :all, :find_all, :where].each do |crud_call|
     it { should respond_to(crud_call) }
   end
@@ -18,7 +18,7 @@ describe Helix::Image do
   describe "an instance" do
     let(:obj) { klass.new({'image_id' => 'some_image_guid'}) }
     subject { obj }
-    its(:media_type_sym) { should be(:image) }
+    its(:resource_label_sym) { should be(:image) }
     [:destroy, :update].each do |crud_call|
       it { should respond_to(crud_call) }
     end

data/spec/library_spec.rb

@@ -6,8 +6,8 @@ describe Helix::Library do
   let(:klass)             { Helix::Library }
   subject                 { klass }
   its(:guid_name)         { should eq('library_id') }
-  its(:media_type_sym)    { should be(:library)   }
-  its(:plural_media_type) { should eq('libraries') }
+  its(:resource_label_sym)    { should be(:library)   }
+  its(:plural_resource_label) { should eq('libraries') }
   [:find, :create, :all, :find_all, :where].each do |crud_call|
     it { should respond_to(crud_call) }
   end
@@ -28,7 +28,7 @@ describe Helix::Library do
   describe "an instance" do
     let(:obj)            { klass.new({'library_id' => 'some_library_id'}) }
     subject              { obj }
-    its(:media_type_sym) { should be(:library) }
+    its(:resource_label_sym) { should be(:library) }
     [:destroy, :update].each do |crud_call|
       it { should respond_to(crud_call) }
     end

data/spec/media_spec.rb

@@ -18,15 +18,15 @@ describe Helix::Media do
     let(:params)      { { signature: "some_sig" } }
     let(:expected)    { { attributes: { attribute: :value }, config: mock_config } }
     before(:each) do
-      klass.stub(:plural_media_type) { :klasses }
-      klass.stub(:media_type_sym)    { klass_sym }
-      mock_config.stub(:build_url).with(action: :create_many, media_type: :klasses) { :url }
+      klass.stub(:plural_resource_label) { :klasses }
+      klass.stub(:resource_label_sym)    { klass_sym }
+      mock_config.stub(:build_url).with(action: :create_many, resource_label: :klasses) { :url }
       mock_config.stub(:signature).with(:update) { "some_sig" }
       Helix::Config.stub(:instance) { mock_config }
     end
     it "should get an ingest signature" do
-      mock_config.should_receive(:build_url).with(media_type:   :klasses,
-                                                  content_type: :xml)
+      mock_config.should_receive(:build_url).with(resource_label: :klasses,
+                                                  content_type:   :xml)
       RestClient.stub(:post).with(:url, params) { resp_json }
       Hash.should_receive(:from_xml).with(resp_json) { resp_value }
       klass.stub(:new).with(expected)
@@ -34,8 +34,8 @@ describe Helix::Media do
       klass.send(meth)
     end
     it "should do an HTTP post call, parse response and call new" do
-      mock_config.should_receive(:build_url).with(media_type:   :klasses,
-                                                  content_type: :xml)
+      mock_config.should_receive(:build_url).with(resource_label: :klasses,
+                                                  content_type:   :xml)
       RestClient.should_receive(:post).with(:url, params) { resp_json }
       Hash.should_receive(:from_xml).with(resp_json)      { resp_value }
       klass.should_receive(:new).with(expected)
@@ -89,20 +89,20 @@ describe Helix::Media do
       before do
         obj.stub(:config)            { mock_config }
         obj.stub(:guid)              { :some_guid  }
-        obj.stub(:plural_media_type) { :media_type }
+        obj.stub(:plural_resource_label) { :resource_label }
       end
       it "should get an update signature" do
-        url = mock_config.build_url(media_type: :media_type,
-                                    guid:       :some_guid,
-                                    content_type:     :xml)
+        url = mock_config.build_url(resource_label: :resource_label,
+                                    guid:           :some_guid,
+                                    content_type:   :xml)
         RestClient.stub(:delete).with(url, params)
         mock_config.should_receive(:signature).with(:update) { :some_sig }
         obj.send(meth)
       end
       it "should call for an HTTP delete and return nil" do
-        url = mock_config.build_url(media_type: :media_type,
-                                    guid:       :some_guid,
-                                    content_type:     :xml)
+        url = mock_config.build_url(resource_label: :resource_label,
+                                    guid:           :some_guid,
+                                    content_type:   :xml)
         RestClient.should_receive(:delete).with(url, params)
         expect(obj.send(meth)).to be_nil
       end
@@ -115,14 +115,14 @@ describe Helix::Media do
       before(:each) do
         obj.stub(:config) { mock_config }
         obj.stub(:guid)   { :the_guid }
-        obj.stub(:media_type_sym) { :video }
-        obj.stub(:plural_media_type) { :the_media_type }
+        obj.stub(:resource_label_sym) { :video }
+        obj.stub(:plural_resource_label) { :the_resource_label }
         mock_config.stub(:signature).with(:update) { 'some_sig' }
         mock_config.stub(:build_url) { :expected_url }
       end
       shared_examples_for "builds URL for update" do
-        it "should build_url(content_type: :xml, guid: guid, media_type: plural_media_type)" do
-          mock_config.should_receive(:build_url).with(content_type: :xml, guid: :the_guid, media_type: :the_media_type)
+        it "should build_url(content_type: :xml, guid: guid, resource_label: plural_resource_label)" do
+          mock_config.should_receive(:build_url).with(content_type: :xml, guid: :the_guid, resource_label: :the_resource_label)
           RestClient.stub(:put)
           obj.send(meth)
         end

data/spec/statistics_spec.rb

@@ -18,12 +18,12 @@ describe Helix::Statistics do
   describe "Constants"
 
   STATS_TYPES.each do |stats_type|
-    STATS_MEDIA_TYPES.each do |media_type|
+    STATS_MEDIA_TYPES.each do |resource_label|
 
-      next if STATS_IMAGE_TYPES.include?(media_type) and stats_type == 'ingest'
+      next if STATS_IMAGE_TYPES.include?(resource_label) and stats_type == 'ingest'
 
-      describe ".#{media_type}_#{stats_type}" do
-        let(:meth)  { "#{media_type}_#{stats_type}" }
+      describe ".#{resource_label}_#{stats_type}" do
+        let(:meth)  { "#{resource_label}_#{stats_type}" }
         let(:mock_config) { mock(Helix::Config, build_url: :built_url, get_response: :response) }
         before(:each) do Helix::Config.stub(:instance) { mock_config } end
 
@@ -32,7 +32,7 @@ describe Helix::Statistics do
 
         case stats_type
           when 'delivery'
-            media_name = MEDIA_NAME_OF[media_type] || media_type
+            media_name = MEDIA_NAME_OF[resource_label] || resource_label
             context "when given opts containing a :#{media_name}_id" do
               let(:opts) { {group: :daily, "#{media_name}_id".to_sym => "the_#{media_name}_id".to_sym} }
               it "should refer to the Helix::Config instance" do
@@ -51,10 +51,10 @@ describe Helix::Statistics do
               end
               context "when opts contains a :content_type" do
                 before(:each) do opts.merge!(content_type: :the_format) end
-                it "should call config.build_url(guid: the_#{media_name}_id, media_type: :#{media_name}s, action: :statistics, content_type: :the_format)" do
+                it "should call config.build_url(guid: the_#{media_name}_id, resource_label: :#{media_name}s, action: :statistics, content_type: :the_format)" do
                   build_opts_url = {
                     guid: "the_#{media_name}_id".to_sym,
-                    media_type: "#{media_name}s".to_sym,
+                    resource_label: "#{media_name}s".to_sym,
                     action: :statistics,
                     content_type: :the_format
                   }
@@ -63,8 +63,8 @@ describe Helix::Statistics do
                 end
               end
               context "when opts did NOT contain a :content_type" do
-                it "should call config.build_url(guid: the_#{media_name}_id, media_type: :#{media_name}s, action: :statistics)" do
-                  mock_config.should_receive(:build_url).with({guid: "the_#{media_name}_id".to_sym, media_type: "#{media_name}s".to_sym, action: :statistics}) { :built_url }
+                it "should call config.build_url(guid: the_#{media_name}_id, resource_label: :#{media_name}s, action: :statistics)" do
+                  mock_config.should_receive(:build_url).with({guid: "the_#{media_name}_id".to_sym, resource_label: "#{media_name}s".to_sym, action: :statistics}) { :built_url }
                   mod.send(meth, opts)
                 end
               end
@@ -91,15 +91,15 @@ describe Helix::Statistics do
               end
               context "when opts contains a :content_type" do
                 before(:each) do opts.merge!(content_type: :the_format) end
-                it "should call config.build_url(media_type: :statistics, action: :#{media_name}_delivery, content_type: :the_format)" do
-                  build_url_opts = {media_type: :statistics, action: "#{media_name}_delivery".to_sym, content_type: :the_format}
+                it "should call config.build_url(resource_label: :statistics, action: :#{media_name}_delivery, content_type: :the_format)" do
+                  build_url_opts = {resource_label: :statistics, action: "#{media_name}_delivery".to_sym, content_type: :the_format}
                   mock_config.should_receive(:build_url).with(build_url_opts) { :built_url }
                   mod.send(meth, opts)
                 end
               end
               context "when opts did NOT contain a :content_type" do
-                it "should call config.build_url(media_type: :statistics, action: :#{media_name}_delivery)" do
-                  mock_config.should_receive(:build_url).with({media_type: :statistics, action: "#{media_name}_delivery".to_sym}) { :built_url }
+                it "should call config.build_url(resource_label: :statistics, action: :#{media_name}_delivery)" do
+                  mock_config.should_receive(:build_url).with({resource_label: :statistics, action: "#{media_name}_delivery".to_sym}) { :built_url }
                   mod.send(meth, opts)
                 end
               end
@@ -109,8 +109,8 @@ describe Helix::Statistics do
               end
             end
           when 'ingest'
-            media_name   = MEDIA_NAME_OF[media_type]  || media_type
-            publish_name = INGEST_NAME_OF[media_type] || 'ingest'
+            media_name   = MEDIA_NAME_OF[resource_label]  || resource_label
+            publish_name = INGEST_NAME_OF[resource_label] || 'ingest'
             context "when given opts" do
               context "and opts has no :action key" do
                 let(:opts) { {group: :daily} }
@@ -118,8 +118,8 @@ describe Helix::Statistics do
                   Helix::Config.should_receive(:instance) { mock_config }
                   mod.send(meth, opts)
                 end
-                it "should call config.build_url(media_type: :statistics, action: :#{media_name}_#{publish_name}/brakdown)" do
-                  mock_config.should_receive(:build_url).with({media_type: :statistics, action: "#{media_name}_#{publish_name}/breakdown".to_sym}) { :built_url }
+                it "should call config.build_url(resource_label: :statistics, action: :#{media_name}_#{publish_name}/brakdown)" do
+                  mock_config.should_receive(:build_url).with({resource_label: :statistics, action: "#{media_name}_#{publish_name}/breakdown".to_sym}) { :built_url }
                   mod.send(meth, opts)
                 end
                 it "should return config.get_response(built_url, opts.merge(sig_type: :view)" do
@@ -134,8 +134,8 @@ describe Helix::Statistics do
                     Helix::Config.should_receive(:instance) { mock_config }
                     mod.send(meth, opts)
                   end
-                  it "should call config.build_url(media_type: :statistics, action: :#{media_name}_#{publish_name}/#{act})" do
-                    mock_config.should_receive(:build_url).with({media_type: :statistics, action: "#{media_name}_#{publish_name}/#{act}".to_sym}) { :built_url }
+                  it "should call config.build_url(resource_label: :statistics, action: :#{media_name}_#{publish_name}/#{act})" do
+                    mock_config.should_receive(:build_url).with({resource_label: :statistics, action: "#{media_name}_#{publish_name}/#{act}".to_sym}) { :built_url }
                     mod.send(meth, opts)
                   end
                   it "should return config.get_response(built_url, opts.merge(sig_type: :view)" do
@@ -146,16 +146,16 @@ describe Helix::Statistics do
               end
             end
           when 'storage'
-            media_name   = MEDIA_NAME_OF[media_type]  || media_type
-            publish_name = INGEST_NAME_OF[media_type] || 'ingest'
+            media_name   = MEDIA_NAME_OF[resource_label]  || resource_label
+            publish_name = INGEST_NAME_OF[resource_label] || 'ingest'
             context "when given opts" do
               let(:opts) { {group: :daily} }
               it "should refer to the Helix::Config instance" do
                 Helix::Config.should_receive(:instance) { mock_config }
                 mod.send(meth, opts)
               end
-              it "should call config.build_url(media_type: :statistics, action: :#{media_name}_#{publish_name}/disk_usage)" do
-                mock_config.should_receive(:build_url).with({media_type: :statistics, action: "#{media_name}_#{publish_name}/disk_usage".to_sym}) { :built_url }
+              it "should call config.build_url(resource_label: :statistics, action: :#{media_name}_#{publish_name}/disk_usage)" do
+                mock_config.should_receive(:build_url).with({resource_label: :statistics, action: "#{media_name}_#{publish_name}/disk_usage".to_sym}) { :built_url }
                 mod.send(meth, opts)
               end
               it "should return config.get_response(built_url, opts.merge(sig_type: :view)" do

data/spec/tag_spec.rb

@@ -3,10 +3,10 @@ require 'helix'
 
 describe Helix::Tag do
 
-  let(:klass)             { Helix::Tag }
-  subject                 { klass }
-  its(:media_type_sym)    { should be(:tag)   }
-  its(:plural_media_type) { should eq('tags') }
+  let(:klass) { Helix::Tag }
+  subject     { klass }
+  its(:resource_label_sym)    { should be(:tag)   }
+  its(:plural_resource_label) { should eq('tags') }
   it { should_not respond_to(:find) }
   it { should_not respond_to(:create) }
   it { should respond_to(:all)}
@@ -15,10 +15,10 @@ describe Helix::Tag do
   describe "Constants"
 
   describe "an instance" do
-    let(:obj)             { klass.new({}) }
-    subject               { obj }
-    its(:media_type_sym)  { should be(:tag) }
+    let(:obj) { klass.new({}) }
+    subject   { obj }
+    its(:resource_label_sym)  { should be(:tag) }
     it { should_not respond_to(:destroy) }
     it { should_not respond_to(:update) }
   end  
-end
+end

data/spec/track_spec.rb

@@ -6,8 +6,8 @@ describe Helix::Track do
   let(:klass)             { Helix::Track }
   subject                 { klass }
   its(:guid_name)         { should eq('track_id') }
-  its(:media_type_sym)    { should be(:track)   }
-  its(:plural_media_type) { should eq('tracks') }
+  its(:resource_label_sym)    { should be(:track)   }
+  its(:plural_resource_label) { should eq('tracks') }
   [:find, :create, :all, :find_all, :where].each do |crud_call|
     it { should respond_to(crud_call) }
   end
@@ -17,7 +17,7 @@ describe Helix::Track do
   describe "an instance" do
     let(:obj)            { klass.new({'track_id' => 'some_track_guid'}) }
     subject              { obj }
-    its(:media_type_sym) { should be(:track) }
+    its(:resource_label_sym) { should be(:track) }
     [:destroy, :update].each do |crud_call|
       it { should respond_to(crud_call) }
     end

data/spec/video_spec.rb

@@ -10,8 +10,8 @@ describe Helix::Video do
   let(:klass)             { Helix::Video }
   subject                 { klass }
   its(:guid_name)         { should eq('video_id') }
-  its(:media_type_sym)    { should be(:video)   }
-  its(:plural_media_type) { should eq('videos') }
+  its(:resource_label_sym)    { should be(:video)   }
+  its(:plural_resource_label) { should eq('videos') }
   [:find, :create, :all, :find_all, :where].each do |crud_call|
     it { should respond_to(crud_call) }
   end
@@ -23,7 +23,7 @@ describe Helix::Video do
   describe "an instance" do
     let(:obj)            { klass.new({video_id: 'some_video_guid'}) }
     subject              { obj }
-    its(:media_type_sym) { should be(:video) }
+    its(:resource_label_sym) { should be(:video) }
 
     describe "#download" do
       let(:meth)        { :download }
@@ -33,11 +33,11 @@ describe Helix::Video do
       before do
         obj.stub(:config)            { mock_config }
         obj.stub(:guid)              { :some_guid  }
-        obj.stub(:plural_media_type) { :media_type }
+        obj.stub(:plural_resource_label) { :resource_label }
         RestClient.stub(:get) { '' }
       end
       { '' => '', mp3: :mp3, nil => '' }.each do |arg,actual|
-        build_url_h = {action: :file, content_type: actual, guid: :some_guid, media_type: :media_type}
+        build_url_h = {action: :file, content_type: actual, guid: :some_guid, resource_label: :resource_label}
         context "when given {content_type: #{arg}" do
           it "should build_url(#{build_url_h})" do
             mock_config.should_receive(:build_url).with(build_url_h)
@@ -64,11 +64,11 @@ describe Helix::Video do
       before do
         obj.stub(:config)            { mock_config }
         obj.stub(:guid)              { :some_guid  }
-        obj.stub(:plural_media_type) { :media_type }
+        obj.stub(:plural_resource_label) { :resource_label }
         RestClient.stub(:get) { '' }
       end
       { '' => '', mp3: :mp3, nil => '' }.each do |arg,actual|
-        build_url_h = {action: :play, content_type: actual, guid: :some_guid, media_type: :media_type}
+        build_url_h = {action: :play, content_type: actual, guid: :some_guid, resource_label: :resource_label}
         context "when given {content_type: #{arg}" do
           it "should build_url(#{build_url_h})" do
             mock_config.should_receive(:build_url).with(build_url_h)
@@ -114,10 +114,10 @@ describe Helix::Video do
     its(:arity)       { should eq(-1) }
     let(:params)      { { params:       { signature: :some_sig },
                           content_type: "text/xml" } }
-    let(:url_opts)    { { action:       :slice,
-                          media_type:   "videos",
-                          content_type: :xml,
-                          formats:      :some_format } }
+    let(:url_opts)    { { action:         :slice,
+                          resource_label: "videos",
+                          content_type:   :xml,
+                          formats:        :some_format } }
     let(:sig_opts)    { { contributor:  :helix,
                           library_id:   :development,
                           formats:      :some_format } }

metadata

@@ -2,7 +2,7 @@
 name: helix
 version: !ruby/object:Gem::Version 
   prerelease: 8
-  version: 0.0.2.5.pre
+  version: 0.0.2.6.pre
 platform: ruby
 authors: 
 - Twistage, Inc