helix 0.0.2.8.pre → 0.0.2.9.pre

data/lib/helix.rb

@@ -9,6 +9,7 @@ require 'helix/image'
 require 'helix/config'
 require 'helix/statistics'
 require 'helix/library'
+require 'to_xml'
 
 module Helix
 end

data/lib/helix/album.rb

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

data/lib/helix/base.rb

@@ -65,7 +65,7 @@ module Helix
     #
     # @return [String] The guid name for a specific class.
     def self.guid_name
-      "#{self.resource_label_sym}_id"
+      "#{resource_label_sym}_id"
     end
 
     # Creates a string associated with a class name pluralized
@@ -75,7 +75,7 @@ module Helix
     #
     # @return [String] The class name pluralized
     def self.plural_resource_label
-      "#{self.resource_label_sym}s"
+      "#{resource_label_sym}s"
     end
 
     METHODS_DELEGATED_TO_CLASS.each do |meth|
@@ -97,6 +97,26 @@ module Helix
       @config ||= Helix::Config.instance
     end
 
+    # Looks up the custom field value for a given name.
+    #
+    # @example
+    #   video.custom_field('stars_kevin_bacon') #=> "true"
+    #
+    # @return [String] The value whose key is the given custom field name.
+    def custom_field(k)
+      custom_fields[k]
+    end
+
+    # Returns all custom fields.
+    #
+    # @example
+    #   video.custom_fields #=> { "stars_kevin_bacon" => "true" }
+    #
+    # @return [Hash] The custom fields in the form { name1 => value1, name2 => value2, ... }
+    def custom_fields
+      modified_attributes['custom_fields']
+    end
+
     # Creates a string that associates to the class id.
     #
     # @example
@@ -182,8 +202,11 @@ module Helix
     end
 
     def modified_attributes
+      return if @attributes.nil?
       custom_fields = @attributes['custom_fields']
       return @attributes if custom_fields.nil?
+      return @attributes unless custom_fields.respond_to?(:first)
+      return @attributes unless custom_fields.first.respond_to?(:[])
       return @attributes if custom_fields.first['name'].nil?
       new_cfs = custom_fields.inject({}) do |memo,cf|
         memo.merge(cf['name'] => cf['value'])
@@ -191,9 +214,5 @@ module Helix
       @attributes.merge('custom_fields' => new_cfs)
     end
 
-    def self.resource_label_sym
-      to_s.split('::').last.singularize.downcase.to_sym
-    end
-
   end
 end

data/lib/helix/config.rb

@@ -36,7 +36,10 @@ module Helix
     def self.load(yaml_file_location = DEFAULT_FILENAME)
       config = self.instance
       config.instance_variable_set(:@filename, yaml_file_location)
-      creds = YAML.load(File.open(yaml_file_location)).symbolize_keys
+      creds = YAML.load(File.open(yaml_file_location)).inject({}) do |memo,pair|
+        k, v = *pair
+        memo.merge(k.to_sym => v)
+      end
       config.instance_variable_set(:@credentials, creds)
       RestClient.proxy = config.proxy
       config
@@ -83,13 +86,13 @@ module Helix
     # @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
-      until last_page?
+      begin
         aggregation_opts = original_opts.merge(page: page, per_page: ITEMS_PER_PAGE)
         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
+      end until last_page?
       data_sets
     end
 

data/lib/helix/durationed_media.rb

@@ -56,7 +56,7 @@ module Helix
       # @param [Hash] attrs The attributes for creating xml.
       # @return [String] Returns xml either from a raw entry or generated from attributes.
       def get_xml(attrs={})
-        return attrs[:use_raw_xml] if attrs[:use_raw_xml].present?
+        return attrs[:use_raw_xml] if attrs[:use_raw_xml] && attrs[:use_raw_xml] != ''
         xml_opts = {root: :add }
         { list: { entry: attrs[:url_params] || {} } }.to_xml(xml_opts)
       end

data/lib/helix/image.rb

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

data/lib/helix/library.rb

@@ -14,7 +14,7 @@ module Helix
     #   Helix::Library.resource_label_sym #=> :library
     #
     # @return [Symbol] Name of the class.
-    def self.resource_label_sym; super; end
+    def self.resource_label_sym; :library; end
 
     # Creates a string associated with a class name pluralized
     #

data/lib/helix/statistics.rb

@@ -135,7 +135,8 @@ module Helix
       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))
+      raw = memo_cfg.get_response(url, {sig_type: :view}.merge(opts))
+      standardize_raw_stats(raw)
     end
 
     def self.ingest(resource_label, original_opts)
@@ -154,7 +155,8 @@ module Helix
       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))
+      raw = memo_cfg.get_response(url, {sig_type: :view}.merge(opts))
+      standardize_raw_stats(raw)
     end
 
     def self.ingest_action_prefix_for(resource_label)
@@ -165,6 +167,14 @@ module Helix
       STORAGE_ACTION_FOR[resource_label].to_sym
     end
 
+    private
+
+    def self.standardize_raw_stats(raw)
+      return raw unless raw.respond_to?(:has_key?)
+      return raw unless raw.has_key?('statistics_reports')
+      raw['statistics_reports']
+    end
+
   end
 
 end

data/lib/helix/tag.rb

@@ -13,6 +13,25 @@ module Helix
     #   Helix::Tag.resource_label_sym #=> :tag
     #
     # @return [Symbol] Name of the class.
-    def self.resource_label_sym; super; end
+    def self.resource_label_sym; :tag; end
+
+    # This is being used to override the current way of calling to our system
+    # since the current way uses pagination. This method does not add in
+    # pagination. Adding paginaton to Tags currently breaks the call. This
+    # method should be a temporary fix.
+    #
+    # Does a GET call to the api and defaults to content_type xml and
+    # signature_type view.
+    #
+    #
+    # @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,
+                                      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_resource_label]
+    end
   end
 end

data/lib/helix/track.rb

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

data/lib/helix/video.rb

@@ -1,5 +1,4 @@
 require 'helix/media'
-require 'active_support/core_ext'
 
 module Helix
 
@@ -15,7 +14,7 @@ module Helix
     #   Helix::Video.resource_label_sym #=> :video
     #
     # @return [Symbol] Name of the class.
-    def self.resource_label_sym; super; end
+    def self.resource_label_sym; :video; end
 
     # Used to create a slice video from an existing video.
     # API doc reference: /doc/api/video/slice

data/spec/base_spec.rb

@@ -155,144 +155,265 @@ describe Helix::Base do
     end
   end
 
-  describe "an instance" do
-    let(:obj) { klass.new({}) }
+  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, 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
+  end
+
+  klasses = [ Helix::Album, Helix::Image, Helix::Track, Helix::Video ]
+  klasses.each do |klass|
+
+    describe "an instance of class #{klass.to_s}" do
+      let(:obj) { klass.new({}) }
 
     ### INSTANCE METHODS
 
-    describe ".config" do
-      let(:meth)  { :config }
-      subject     { obj.method(meth) }
-      its(:arity) { should eq(0) }
-      describe "when called" do
-        subject     { obj.send(meth) }
-        context "and @config is already set" do
-          before(:each) do obj.instance_variable_set(:@config, :cached_val) end
-          it { should be(:cached_val) }
+      describe ".config" do
+        let(:meth)  { :config }
+        subject     { obj.method(meth) }
+        its(:arity) { should eq(0) }
+        describe "when called" do
+          subject     { obj.send(meth) }
+          context "and @config is already set" do
+            before(:each) do obj.instance_variable_set(:@config, :cached_val) end
+            it { should be(:cached_val) }
+          end
+          context "and @config is NOT already set" do
+            before(:each) do obj.instance_variable_set(:@config, nil) end
+            it { should eq(Helix::Config.instance) }
+          end
         end
-        context "and @config is NOT already set" do
-          before(:each) do obj.instance_variable_set(:@config, nil) end
-          it { should eq(Helix::Config.instance) }
+      end
+
+      describe "#custom_field" do
+        let(:meth) { :custom_field }
+        describe "arity" do
+          subject { obj.method(meth) }
+          its(:arity) { should eq(1) }
+        end
+        it "should be modified_attributes['custom_fields'][arg]" do
+          obj.stub(:modified_attributes) { {'custom_fields' => {key1: :value1}} }
+          expect(obj.send(meth, :key1)).to be(:value1)
+          expect(obj.send(meth, :key2)).to be(nil)
         end
       end
-    end
 
-    describe "#guid" do
-      let(:meth) { :guid }
-      it "should return @attributes[guid_name]" do
-        mock_attributes = mock(Object)
-        obj.instance_variable_set(:@attributes, mock_attributes)
-        obj.should_receive(:guid_name) { :the_guid_name }
-        mock_attributes.should_receive(:[]).with(:the_guid_name) { :expected }
-        expect(obj.send(meth)).to eq(:expected)
+      describe "#custom_fields" do
+        let(:meth) { :custom_fields }
+        describe "arity" do
+          subject { obj.method(meth) }
+          its(:arity) { should eq(0) }
+        end
+        it "should delegate to modified_attributes['custom_fields']" do
+          cfs = {key1: :value1}
+          obj.stub(:modified_attributes) { {'custom_fields' => cfs} }
+          expect(obj.send(meth)).to be(cfs)
+        end
       end
-    end
 
-    describe "#guid_name" do
-      let(:meth) { :guid_name }
-      it "should delegate to the class" do
-        klass.should_receive(meth) { :expected }
-        expect(obj.send(meth)).to be(:expected)
+      describe "#guid" do
+        let(:meth) { :guid }
+        it "should return @attributes[guid_name]" do
+          mock_attributes = mock(Object)
+          obj.instance_variable_set(:@attributes, mock_attributes)
+          obj.should_receive(:guid_name) { :the_guid_name }
+          mock_attributes.should_receive(:[]).with(:the_guid_name) { :expected }
+          expect(obj.send(meth)).to eq(:expected)
+        end
       end
-    end
 
-    describe "#load" do
-      let(:meth)  { :load }
-      let(:mock_config) { mock(Helix::Config) }
-      subject     { obj.method(meth) }
-      its(:arity) { should eq(-1) }
-      before(:each) do
-        obj.stub(:config)               { mock_config     }
-        obj.stub(:guid)                 { 'some_guid'     }
-        obj.stub(:signature)            { 'some_sig'      }
-        obj.stub(:massage_raw_attrs)    { :massaged_attrs }
-        mock_config.stub(:build_url)    { :expected_url   }
-        mock_config.stub(:get_response) { :raw_attrs      }
-        klass.stub(:resource_label_sym) { :video          }
+      describe "#guid_name" do
+        let(:meth) { :guid_name }
+        it "should delegate to the class" do
+          klass.should_receive(meth) { :expected }
+          expect(obj.send(meth)).to be(:expected)
+        end
       end
-      shared_examples_for "builds URL for load" do
-        it "should call #guid" do
-          obj.should_receive(:guid) { 'some_guid' }
-          obj.send(meth)
+
+      describe "#load" do
+        let(:meth)  { :load }
+        let(:mock_config) { mock(Helix::Config) }
+        subject     { obj.method(meth) }
+        its(:arity) { should eq(-1) }
+        before(:each) do
+          obj.stub(:config)               { mock_config     }
+          obj.stub(:guid)                 { 'some_guid'     }
+          obj.stub(:signature)            { 'some_sig'      }
+          obj.stub(:massage_raw_attrs)    { :massaged_attrs }
+          mock_config.stub(:build_url)    { :expected_url   }
+          mock_config.stub(:get_response) { :raw_attrs      }
+          klass.stub(:resource_label_sym) { :video          }
         end
-        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)
+        context "when given no argument" do
+          it_behaves_like "builds URL for load"
+          it "should call klass.get_response(output_of_build_url, {sig_type: :view}) and return instance of klass" do
+            mock_config.should_receive(:get_response).with(:expected_url, {sig_type: :view})
+            expect(obj.send(meth)).to be_an_instance_of(klass)
+          end
+          it "should massage the raw_attrs" do
+            obj.should_receive(:massage_raw_attrs).with(:raw_attrs)
+            obj.send(meth)
+          end
+        end
+        context "when given an opts argument of {key1: :value1}" do
+          let(:opts)  { {key1: :value1} }
+          it_behaves_like "builds URL for load"
+          it "should call klass.get_response(output_of_build_url, opts.merge(sig_type: :view)) and return instance of klass" do
+            mock_config.should_receive(:get_response).with(:expected_url, opts.merge(sig_type: :view))
+            expect(obj.send(meth, opts)).to be_an_instance_of(klass)
+          end
+          it "should massage the raw_attrs" do
+            obj.should_receive(:massage_raw_attrs).with(:raw_attrs)
+            obj.send(meth, opts)
+          end
         end
       end
-      context "when given no argument" do
-        it_behaves_like "builds URL for load"
-        it "should call klass.get_response(output_of_build_url, {sig_type: :view}) and return instance of klass" do
-          mock_config.should_receive(:get_response).with(:expected_url, {sig_type: :view})
-          expect(obj.send(meth)).to be_an_instance_of(klass)
+
+      describe "#massage_raw_attrs" do
+        let(:meth)      { :massage_raw_attrs }
+        let(:guid_name) { :the_guid_name }
+
+        subject     { obj.method(meth) }
+        its(:arity) { should eq(1) }
+
+        before(:each) { obj.stub(:guid_name) { guid_name } }
+        context "when given {}" do
+          let(:raw_attrs) { {} }
+          subject { obj.send(meth, raw_attrs) }
+          it { should eq(nil) }
         end
-        it "should massage the raw_attrs" do
-          obj.should_receive(:massage_raw_attrs).with(:raw_attrs)
-          obj.send(meth)
+        context "when given { guid_name => :the_val }" do
+          let(:raw_attrs) { { guid_name => :the_val } }
+          subject { obj.send(meth, raw_attrs) }
+          it { should eq(raw_attrs) }
         end
-      end
-      context "when given an opts argument of {key1: :value1}" do
-        let(:opts)  { {key1: :value1} }
-        it_behaves_like "builds URL for load"
-        it "should call klass.get_response(output_of_build_url, opts.merge(sig_type: :view)) and return instance of klass" do
-          mock_config.should_receive(:get_response).with(:expected_url, opts.merge(sig_type: :view))
-          expect(obj.send(meth, opts)).to be_an_instance_of(klass)
+        context "when given [{ guid_name => :the_val }]" do
+          let(:raw_attrs) { [{ guid_name => :the_val }] }
+          subject { obj.send(meth, raw_attrs) }
+          it { should eq(raw_attrs.first) }
         end
-        it "should massage the raw_attrs" do
-          obj.should_receive(:massage_raw_attrs).with(:raw_attrs)
-          obj.send(meth, opts)
+      end
+
+      describe "#method_missing" do
+        let(:meth)  { :method_missing }
+        subject     { obj.method(meth) }
+        its(:arity) { should eq(1) }
+        context "when given method_sym" do
+          let(:method_sym) { :method_sym }
+          let(:mock_attributes) { mock(Object) }
+          before(:each) do obj.instance_variable_set(:@attributes, mock_attributes) end
+          context "and @attributes[method_sym.to_s] raises an exception" do
+            before(:each) do mock_attributes.should_receive(:[]).with(method_sym.to_s).and_raise("some exception") end
+            it "should raise a NoMethodError" do
+              msg = "#{method_sym} is not recognized within #{klass}'s methods or @attributes"
+              expect(lambda { obj.send(meth, method_sym) }).to raise_error(msg)
+            end
+          end
+          context "and @attributes[method_sym.to_s] does NOT raise an exception" do
+            before(:each) do mock_attributes.should_receive(:[]).with(method_sym.to_s) { :expected } end
+            it "should return @attributes[method_sym.to_s]" do
+              expect(obj.send(meth, method_sym)).to eq(:expected)
+            end
+          end
         end
       end
-    end
 
-    describe "#massage_raw_attrs" do
-      let(:meth)      { :massage_raw_attrs }
-      let(:guid_name) { :the_guid_name }
+      describe "modified_attributes" do
+        let(:meth) { :modified_attributes }
 
-      subject     { obj.method(meth) }
-      its(:arity) { should eq(1) }
+        describe "arity" do
+          subject { obj.method(meth) }
+          its(:arity) { should eq(0) }
+        end
 
-      before(:each) { obj.stub(:guid_name) { guid_name } }
-      context "when given {}" do
-        let(:raw_attrs) { {} }
-        subject { obj.send(meth, raw_attrs) }
-        it { should eq(nil) }
-      end
-      context "when given { guid_name => :the_val }" do
-        let(:raw_attrs) { { guid_name => :the_val } }
-        subject { obj.send(meth, raw_attrs) }
-        it { should eq(raw_attrs) }
-      end
-      context "when given [{ guid_name => :the_val }]" do
-        let(:raw_attrs) { [{ guid_name => :the_val }] }
-        subject { obj.send(meth, raw_attrs) }
-        it { should eq(raw_attrs.first) }
-      end
-    end
+        describe "access" do
+          subject { obj }
+          its(:private_methods) { should include(meth) }
+        end
 
-    describe "#method_missing" do
-      let(:meth)  { :method_missing }
-      subject     { obj.method(meth) }
-      its(:arity) { should eq(1) }
-      context "when given method_sym" do
-        let(:method_sym) { :method_sym }
-        let(:mock_attributes) { mock(Object) }
-        before(:each) do obj.instance_variable_set(:@attributes, mock_attributes) end
-        context "and @attributes[method_sym.to_s] raises an exception" do
-          before(:each) do mock_attributes.should_receive(:[]).with(method_sym.to_s).and_raise("some exception") end
-          it "should raise a NoMethodError" do
-            msg = "#{method_sym} is not recognized within #{klass}'s methods or @attributes"
-            expect(lambda { obj.send(meth, method_sym) }).to raise_error(msg)
-          end
+        subject { obj.send(meth) }
+        context "when @attributes is nil" do
+          before(:each) do obj.instance_variable_set(:@attributes, nil) end
+          it { should be(nil) }
         end
-        context "and @attributes[method_sym.to_s] does NOT raise an exception" do
-          before(:each) do mock_attributes.should_receive(:[]).with(method_sym.to_s) { :expected } end
-          it "should return @attributes[method_sym.to_s]" do
-            expect(obj.send(meth, method_sym)).to eq(:expected)
+        context "when @attributes is {}" do
+          before(:each) do obj.instance_variable_set(:@attributes, {}) end
+          it { should eq({}) }
+        end
+        bases = [ {}, {'k1' => 'v1', 'k2' => 'v2'} ]
+        potential_additions = [
+          {'custom_fields' => nil},
+          {'custom_fields' => [{}]},
+          {'custom_fields' => [{'name' => nil}]},
+          {'custom_fields' => [{'name' => nil}, {'name' => nil}]}
+        ]
+        bases.each do |base|
+          potential_additions.each do |additions|
+            attrs = base.merge(additions)
+            context "when @attributes is #{attrs}" do
+              before(:each) do obj.instance_variable_set(:@attributes, attrs) end
+              it { should eq(attrs) }
+            end
+          end
+          context "when @attributes is #{base.merge({'custom_fields' => [{'name' => 'some name'}]})}" do
+            before(:each) do
+              attrs = base.merge({'custom_fields' => [{'name' => 'some name'}]})
+              obj.instance_variable_set(:@attributes, attrs)
+            end
+            it { should eq(base.merge("custom_fields" => {"some name"=>nil})) }
+          end
+          context "when @attributes is #{base.merge({'custom_fields' => [{'name' => 'some name'}, {'name' => 'other name'}]})}" do
+            before(:each) do
+              attrs = base.merge({'custom_fields' => [{'name' => 'some name'}, {'name' => 'other name'}]})
+              obj.instance_variable_set(:@attributes, attrs)
+            end
+            it { should eq(base.merge("custom_fields" => {"some name"=>nil, "other name"=>nil})) }
+          end
+          context "when @attributes is #{base.merge({'custom_fields' => [{'name' => 'some name'}, {'name' => 'other name'}]})}" do
+            before(:each) do
+              attrs = base.merge({'custom_fields' => [{'name' => 'some name'}, {'name' => 'other name'}]})
+              obj.instance_variable_set(:@attributes, attrs)
+            end
+            it { should eq(base.merge("custom_fields" => {"some name"=>nil, "other name"=>nil})) }
+          end
+          context "when @attributes is #{base.merge({'custom_fields' => [{'name' => 'some name', 'value' => nil}]})}" do
+            before(:each) do
+              attrs = base.merge({'custom_fields' => [{'name' => 'some name', 'value' => nil}]})
+              obj.instance_variable_set(:@attributes, attrs)
+            end
+            it { should eq(base.merge("custom_fields" => {"some name"=>nil})) }
+          end
+          context "when @attributes is #{base.merge({'custom_fields' => [{'name' => 'some name', 'value' => nil}, {'name' => 'other name', 'value' => nil}]})}" do
+            before(:each) do
+              attrs = base.merge({'custom_fields' => [{'name' => 'some name', 'value' => nil}, {'name' => 'other name', 'value' => nil}]})
+              obj.instance_variable_set(:@attributes, attrs)
+            end
+            it { should eq(base.merge("custom_fields" => {"some name"=>nil, "other name"=>nil})) }
+          end
+          context "when @attributes is #{base.merge({'custom_fields' => [{'name' => 'some name', 'value' => 'some value'}]})}" do
+            before(:each) do
+              attrs = base.merge({'custom_fields' => [{'name' => 'some name', 'value' => 'some value'}]})
+              obj.instance_variable_set(:@attributes, attrs)
+            end
+            it { should eq(base.merge("custom_fields" => {"some name"=>"some value"})) }
+          end
+          context "when @attributes is #{base.merge({'custom_fields' => [{'name' => 'some name', 'value' => 'some value'}, {'name' => 'other name', 'value' => 'other value'}]})}" do
+            before(:each) do
+              attrs = base.merge({'custom_fields' => [{'name' => 'some name', 'value' => 'some value'}, {'name' => 'other name', 'value' => 'other value'}]})
+              obj.instance_variable_set(:@attributes, attrs)
+            end
+            it { should eq(base.merge("custom_fields" => {"some name"=>"some value", "other name"=>"other value"})) }
           end
         end
       end
+
     end
 
   end