helix 0.0.5.1.pre → 0.0.5.2.pre

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OGY1MjZkYTY0OWRhYjc1MTY1ZjlmZjgwMjZiODE3NDQ2NzJhYmE1NQ==
+    YjhmM2QxN2UxMzlmZDM5MzkzYmMzODYwYzNmZDExOWQ1ZDBiZTg3ZQ==
   data.tar.gz: !binary |-
-    NDc1YzVlZmNhYmFkNTJmMTJjMzc1MmJmMDUyNDEyOWMyY2IyZTkzMw==
+    ZjdhNzBjN2UzOGY3NDM2ZWRiNjU3NTcxNWNlOTAxZGFmZTNiNTUyMg==
 SHA512:
   metadata.gz: !binary |-
-    NmJmY2NjOGFiZTAyM2U1MmIyZGVjNDRiZThmOTUyMDEzZWU3YzZiZTk2NmZk
-    NWY5YTg4ZWRhYjMwNWRjZGRmMWFlMDcyMTkxMmZkZjhlODBmODQ5OTNhMTA1
-    OTY5NDdjNTc2Njk5NGE2ZjJlYTIzYzk4NjA5OWQwNzBjYmJmZDE=
+    ZjE3ZGNjMGU3MDY4YTQ2N2Q1YWRlZTNmNzE4YWJlYWQwMTg3NzlkMjc2ZjQw
+    YTEwMzM1ZDBkMzUxODdhMGEwODU1OTA2MzA1MDUwZmM2YzczYmFjNWU2OWQ1
+    ODY2ZDg5YWMzYzA5NjljNDQwMjQ3Y2E1N2M4ODQ0Y2UxNDA4YWE=
   data.tar.gz: !binary |-
-    YjQ3Y2MwZmZjNDBhYjU0NzcxYWY5ZjRhN2Y0MmMzYjZhMTAzZjEyZWU2MTM1
-    MjM2YTllZDFiODU2ZTQyMTRlOTQ1OTJmZjlhOTE4YzlhMDQ3NzJjNjgwNTRh
-    ZjdjYzU2YTBhODUyODVhMTUxNDcyNWI5OGJhMzE1NTA3ZDAwODM=
+    ODljZjhkNGM5ZmIxMWMwNjYxZjVhMmI2ZWIzOTZlZGRhNDQwMTI1ZDc3ZTk3
+    NTU3NzI2OTFhYTUwNDY0OWJjYjg3OTk1YWQ5MTc1ZjM3YjFhMmYyYzEyMTQ1
+    MjUxMDA2Yzg1Y2I5MzYzZDRlZmZhNTg0ZGNlOGUzMTNlYzU3OGU=

data/README.md

@@ -1,6 +1,6 @@
-# Helix [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/Twistage/helix)
+# Helix [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/Perceptive-Cloud/helix)
 
-The Helix gem allows developers to easily connect to and manipulate the Twistage API.
+The Helix gem allows developers to easily connect to and manipulate the Perceptive Media API.
 
 Documentation
 -------------
@@ -24,14 +24,14 @@ Install From Repo
 -----------------
 Using sudo:
 ```shell
-git clone git@github.com:Twistage/helix.git 
+git clone git@github.com:Perceptive-Cloud/helix.git 
 gem build helix.gemspec  
 sudo gem i helix-*.gem
 ```
 
 RVM or root support:
 ```shell
-git clone git@github.com:Twistage/helix.git
+git clone git@github.com:Perceptive-Cloud/helix.git
 gem build helix.gemspec
 gem i helix-*.gem
 ```
@@ -44,7 +44,7 @@ rake reinstall_helix_rvm
 
 Using gem in a Gemfile  
 ```shell
-gem 'helix', :git => 'git@github.com:Twistage/helix.git'
+gem 'helix', :git => 'git@github.com:Perceptive-Cloud/helix.git'
 ```
 
 
@@ -61,7 +61,7 @@ How To
 site: 'http://service.twistage.com'
 company: 'my_company'
 license_key: '141a86b5c4091'
-library_id: 'development'
+library: 'development'
 ```
 Boot up IRB in your console
 ```shell
@@ -93,11 +93,11 @@ Credits
 
 Helix was written by Kevin Baird and Michael Wood.
 
-Helix is maintained and funded by [Twistage, Inc](http://twistage.com)
+Helix is maintained and funded by [Perceptive Software](http://www.perceptivesoftware.com)
 
-The names and logos for twistage are trademarks of Twistage, Inc.
+The names and logos for Perceptive Media are trademarks of Perceptive Software.
 
 License
 -------
 
-Helix is Copyright © 2008-2012 Twistage, Inc.
+Helix is Copyright © 2008-2014 Perceptive Software.

data/lib/helix/paginates.rb

@@ -80,9 +80,9 @@ module Helix
 
     def parse_xml_response(response, url)
       #TODO: Cleanup Nori and response gsub.
-      Nori.parser = :nokogiri
+      parser = Nori.new(parser: :nokogiri)
       xml = response.gsub(/<custom-fields type='array'>/, "<custom-fields type='hash'>")
-      Nori.parse(xml)
+      parser.parse(xml)
     end
 
   end

data/lib/helix/restful.rb

@@ -1,3 +1,5 @@
+require 'rexml/document'
+
 module Helix
 
   # Mixed-in to ORM classes to provide basic RESTful CRUD operations.

data/lib/helix/tag.rb

@@ -1,8 +1,3 @@
-require 'rest-client'
-require 'json'
-require 'yaml'
-require 'nori'
-
 module Helix
   class Tag < Base
     # The class name, to be used by supporting classes. Such as Config which uses

data/spec/album_spec.rb

@@ -2,9 +2,8 @@ require File.expand_path('../spec_helper', __FILE__)
 require 'helix'
 
 describe Helix::Album do
-  let(:klass) { Helix::Album }
 
-  subject { klass }
+  subject { described_class }
   mods = [ Helix::Base, Helix::Media ]
   mods.each { |mod| its(:ancestors) { should include(mod) } }
   its(:guid_name) { should eq('album_id') }
@@ -17,7 +16,7 @@ describe Helix::Album do
   describe "Constants"
 
   describe "an instance" do
-    let(:obj) { klass.new({'album_id' => 'some_album_guid'}) }
+    let(:obj) { described_class.new({'album_id' => 'some_album_guid'}) }
     subject { obj }
     its(:resource_label_sym) { should be(:album) }
     describe "#update" do

data/spec/base_spec.rb

@@ -3,13 +3,11 @@ require 'helix'
 
 describe Helix::Base do
 
-  let(:klass) { Helix::Base }
-
-  subject { klass }
+  subject { described_class }
 
   describe "Constants" do
     describe "METHODS_DELEGATED_TO_CLASS" do
-      subject { klass::METHODS_DELEGATED_TO_CLASS }
+      subject { described_class::METHODS_DELEGATED_TO_CLASS }
       it { should eq([:guid_name, :resource_label_sym, :plural_resource_label]) }
     end
   end
@@ -18,21 +16,21 @@ describe Helix::Base do
 
   describe ".config" do
     let(:meth)  { :config }
-    subject     { klass.method(meth) }
+    subject     { described_class.method(meth) }
     its(:arity) { should eq(0) }
     describe "when called" do
-      subject     { klass.send(meth) }
+      subject     { described_class.send(meth) }
       it { should eq(Helix::Config.instance) }
     end
   end
 
   shared_examples_for "a search all with opts" do
-    subject           { klass.method(meth) }
+    subject           { described_class.method(meth) }
     its(:arity)       { should eq(-1) }
     context "when there is NOT a config instance" do
       before(:each) do Helix::Config.stub(:instance) { nil } end
       it "should raise a NoConfigurationLoaded exception" do
-        lambda { klass.send(meth) }.should raise_error(Helix::NoConfigurationLoaded)
+        lambda { described_class.send(meth) }.should raise_error(Helix::NoConfigurationLoaded)
       end
     end
     context "when there is a config instance" do
@@ -43,11 +41,11 @@ describe Helix::Base do
       before(:each) do Helix::Config.stub(:instance) { mock_config } end
       context "and NOT given an opts Hash" do
         let(:plural_resource_label) { :videos }
-        before(:each) do klass.stub(:plural_resource_label) { plural_resource_label } end
+        before(:each) do described_class.stub(:plural_resource_label) { plural_resource_label } end
         it "should get_aggregated_data_sets(the_url, plural_resource_label, {sig_type: :view}" do
           opts = {sig_type: :view}
           mock_config.should_receive(:get_aggregated_data_sets).with(:built_url, plural_resource_label, opts) { [:expected] }
-          klass.send(meth, opts)
+          described_class.send(meth, opts)
         end
         [ Helix::Video ].each do |child|
           it "should should instantiate #{child.to_s} from each data_set" do
@@ -64,7 +62,7 @@ describe Helix::Base do
   end
 
   shared_examples_for "a search all without opts" do
-    subject { klass.method(meth) }
+    subject { described_class.method(meth) }
     context "when there is a config instance" do
       let(:mock_config) do
         dss = (0..2).map { |x| :"attrs_#{x}" }
@@ -73,11 +71,11 @@ describe Helix::Base do
       before(:each) do Helix::Config.stub(:instance) { mock_config } end
       context "and NOT given an opts Hash" do
         let(:plural_resource_label) { :videos }
-        before(:each) do klass.stub(:plural_resource_label) { plural_resource_label } end
+        before(:each) do described_class.stub(:plural_resource_label) { plural_resource_label } end
         it "should get_aggregated_data_sets(the_url, plural_resource_label, {sig_type: :view}" do
           opts = {sig_type: :view}
           mock_config.should_receive(:get_aggregated_data_sets).with(:built_url, plural_resource_label, opts) { [:expected] }
-          klass.send(meth)
+          described_class.send(meth)
         end
         [ Helix::Video ].each do |child|
           it "should should instantiate #{child.to_s} from each data_set" do
@@ -101,7 +99,7 @@ describe Helix::Base do
 
   describe ".all" do
     let(:meth)  { :all }
-    subject     { klass.method(meth) }
+    subject     { described_class.method(meth) }
     its(:arity) { should eq(0) }
     it_behaves_like "a search all without opts"
   end
@@ -114,44 +112,44 @@ describe Helix::Base do
 
   describe ".massage_attrs" do
     let(:meth)  { :massage_attrs }
-    subject     { klass.method(meth) }
+    subject     { described_class.method(meth) }
     its(:arity) { should eq(1) }
     let(:attrs) { Hash.new }
     it "should call massage_custom_field_attrs and massage_time_attrs" do
-      klass.should_receive(:massage_time_attrs) { attrs }
-      klass.should_receive(:massage_custom_field_attrs) { attrs }
-      klass.send(meth, attrs)
+      described_class.should_receive(:massage_time_attrs) { attrs }
+      described_class.should_receive(:massage_custom_field_attrs) { attrs }
+      described_class.send(meth, attrs)
     end
   end
 
   describe ".massage_time_attrs" do
     let(:meth)      { :massage_time_attrs }
-    subject         { klass.method(meth) }
+    subject         { described_class.method(meth) }
     its(:arity)     { should eq(1) }
     let(:time)      { Time.new(2013) }
     let(:attrs)     { { key_one: time.to_s, key_two: { key_three: time, key_four: { key_five: time.to_s } } } }
     let(:expected)  { { key_one: time, key_two: { key_three: time, key_four: { key_five: time } } } }
     it "should turn stringified time values into time objects" do
-      expect(klass.send(meth, attrs)).to eq(expected)
+      expect(described_class.send(meth, attrs)).to eq(expected)
     end
   end
 
   describe ".massage_custom_field_attrs" do
     let(:meth)        { :massage_custom_field_attrs }
-    subject           { klass.method(meth) }
+    subject           { described_class.method(meth) }
     its(:arity)       { should eq(1) }
     let(:custom_hash) { { "custom_fields" => {"boole"=>[nil, nil], "@type"=>"hash"} } }
     let(:expected)    { { "custom_fields" => [{"name"=>"boole", "value"=>""}, {"name"=>"boole", "value"=>""}] } }
     it "should turn custom_hash into expected" do
-      expect(klass.send(meth, custom_hash)).to eq(expected)
+      expect(described_class.send(meth, custom_hash)).to eq(expected)
     end
     it "should return the custom_hash in its form" do
-      expect(klass.send(meth, expected)).to eq(expected)
+      expect(described_class.send(meth, expected)).to eq(expected)
     end
     let(:custom_hash_with_false)  { { "custom_fields" => {"boole"=>false, "@type"=>"hash"} } }
     let(:expected_with_false)     { { "custom_fields" => [{"name"=>"boole", "value"=>"false"}] } }
     it "should turn custom_hash into expected" do
-      expect(klass.send(meth, custom_hash_with_false)).to eq(expected_with_false)
+      expect(described_class.send(meth, custom_hash_with_false)).to eq(expected_with_false)
     end
   end
 
@@ -167,11 +165,11 @@ describe Helix::Base do
     end
   end
 
-  klasses = [ Helix::Album, Helix::Image, Helix::Playlist, Helix::Track, Helix::Video ]
-  klasses.each do |klass|
+  described_classes = [ Helix::Album, Helix::Image, Helix::Playlist, Helix::Track, Helix::Video ]
+  described_classes.each do |described_class|
 
-    describe "an instance of class #{klass.to_s}" do
-      let(:obj) { klass.new({}) }
+    describe "an instance of class #{described_class.to_s}" do
+      let(:obj) { described_class.new({}) }
 
     ### INSTANCE METHODS
 
@@ -232,7 +230,7 @@ describe Helix::Base do
       describe "#guid_name" do
         let(:meth) { :guid_name }
         it "should delegate to the class" do
-          klass.should_receive(meth) { :expected }
+          described_class.should_receive(meth) { :expected }
           expect(obj.send(meth)).to be(:expected)
         end
       end
@@ -249,13 +247,13 @@ 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(:resource_label_sym) { :video          }
+          described_class.stub(:resource_label_sym) { :video          }
         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
+          it "should call described_class.get_response(output_of_build_url, {sig_type: :view}) and return instance of described_class" do
             mock_config.should_receive(:get_response).with(:expected_url, {sig_type: :view})
-            expect(obj.send(meth)).to be_an_instance_of(klass)
+            expect(obj.send(meth)).to be_an_instance_of(described_class)
           end
           it "should massage the raw_attrs" do
             obj.should_receive(:massage_raw_attrs).with(:raw_attrs)
@@ -265,9 +263,9 @@ describe Helix::Base do
         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
+          it "should call described_class.get_response(output_of_build_url, opts.merge(sig_type: :view)) and return instance of described_class" 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)
+            expect(obj.send(meth, opts)).to be_an_instance_of(described_class)
           end
           it "should massage the raw_attrs" do
             obj.should_receive(:massage_raw_attrs).with(:raw_attrs)
@@ -322,7 +320,7 @@ describe Helix::Base do
           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"
+              msg = "#{method_sym} is not recognized within #{described_class}'s methods or @attributes"
               expect(lambda { obj.send(meth, method_sym) }).to raise_error(msg)
             end
           end
@@ -429,7 +427,7 @@ describe Helix::Base do
         subject     { obj.method(meth) }
         its(:arity) { should eq(0) }
         it "should return the response from config" do
-          obj.config.stub!(:response).and_return :some_response
+          allow(obj.config).to receive(:response).and_return(:some_response)
           expect(obj.send(meth)).to eq(obj.config.response)
         end
       end

data/spec/config_spec.rb

@@ -11,56 +11,55 @@ describe Helix::Config do
     obj.stub(:signature)             { 'some_sig'  } if even_sig
   end
 
-  let(:klass) { Helix::Config  }
-  let(:obj)   { klass.instance }
+  let(:obj) { described_class.instance }
 
-  subject { klass }
+  subject { described_class }
 
   its(:ancestors) { should include(Singleton) }
 
   describe "Constants" do
     describe "DEFAULT_FILENAME" do
-      subject { klass::DEFAULT_FILENAME }
+      subject { described_class::DEFAULT_FILENAME }
       it { should eq('./helix.yml') }
     end
     describe "ITEMS_PER_PAGE" do
-      subject { klass::ITEMS_PER_PAGE }
+      subject { described_class::ITEMS_PER_PAGE }
       it { should eq(100) }
     end
     describe "REQUIRES_CONTRIBUTOR" do
-      subject { klass::REQUIRES_CONTRIBUTOR }
+      subject { described_class::REQUIRES_CONTRIBUTOR }
       it { should eq(Set.new([:ingest, :upload])) }
     end
     describe "SCOPES" do
-      subject { klass::SCOPES }
+      subject { described_class::SCOPES }
       it { should eq([:reseller, :company, :library]) }
     end
     describe "SIG_DURATION" do
-      subject { klass::SIG_DURATION }
+      subject { described_class::SIG_DURATION }
       it { should eq(1200) } # in minutes
     end
     describe "STARTING_PAGE" do
-      subject { klass::STARTING_PAGE }
+      subject { described_class::STARTING_PAGE }
       it { should eq(1) }
     end
     describe "TIME_OFFSET" do
-      subject { klass::TIME_OFFSET }
+      subject { described_class::TIME_OFFSET }
       it { should eq(1000 * 60) } # 1000 minutes
     end
     describe "VALID_SIG_TYPES" do
-      subject { klass::VALID_SIG_TYPES }
+      subject { described_class::VALID_SIG_TYPES }
       it { should eq(Set.new([:ingest, :update, :upload, :view])) }
     end
   end
 
   describe ".load_from_hash & from_hash alias" do
     meths = [ :load_from_hash, :from_hash ]
-    let(:mock_obj)  { double(klass, proxy: :stubbed_proxy) }
+    let(:mock_obj)  { double(described_class, proxy: :stubbed_proxy) }
     let(:mock_file) { double(File)  }
     let(:mock_cred) { {key1: 'value1', 'key2' => 'value2'} }
     let(:symbolized_cred) { {key1: 'value1', key2: 'value2'} }
     before(:each) do
-      klass.stub(:instance) { mock_obj  }
+      described_class.stub(:instance) { mock_obj  }
       File.stub(:open)      { mock_file }
       YAML.stub(:load)      { mock_cred }
     end
@@ -70,7 +69,7 @@ describe Helix::Config do
         it "should set the instance's credentials to the key-symbolized version of that Hash arg" do
           the_hash_arg.should_receive(:symbolize_keys) { :symbolized }
           mock_obj.should_receive(:instance_variable_set).with(:@credentials, :symbolized)
-          klass.send(meth, the_hash_arg)
+          described_class.send(meth, the_hash_arg)
         end
       end
     end
@@ -78,76 +77,76 @@ describe Helix::Config do
 
   describe ".load_yaml_file & load alias" do
     meths = [ :load_yaml_file, :load ]
-    let(:mock_obj)  { double(klass, proxy: :stubbed_proxy) }
+    let(:mock_obj)  { double(described_class, proxy: :stubbed_proxy) }
     let(:mock_file) { double(File)  }
     let(:mock_cred) { {key1: 'value1', 'key2' => 'value2'} }
     let(:symbolized_cred) { {key1: 'value1', key2: 'value2'} }
     before(:each) do
-      klass.stub(:instance) { mock_obj  }
+      described_class.stub(:instance) { mock_obj  }
       File.stub(:open)      { mock_file }
       YAML.stub(:load)      { mock_cred }
       mock_obj.stub(:instance_variable_set).with(:@credentials, anything)
     end
     meths.each do |meth|
       context "when given no arg" do
-        before(:each) do mock_obj.stub(:instance_variable_set).with(:@filename, klass::DEFAULT_FILENAME) end
+        before(:each) do mock_obj.stub(:instance_variable_set).with(:@filename, described_class::DEFAULT_FILENAME) end
         it "should get the instance" do
-          klass.should_receive(:instance) { mock_obj }
-          klass.send(meth)
+          described_class.should_receive(:instance) { mock_obj }
+          described_class.send(meth)
         end
         it "should set @filename to DEFAULT_FILENAME" do
-          mock_obj.should_receive(:instance_variable_set).with(:@filename, klass::DEFAULT_FILENAME)
-          klass.send(meth)
+          mock_obj.should_receive(:instance_variable_set).with(:@filename, described_class::DEFAULT_FILENAME)
+          described_class.send(meth)
         end
         it "should File.open(@filename) -> f" do
-          File.should_receive(:open).with(klass::DEFAULT_FILENAME) { mock_file }
-          klass.send(meth)
+          File.should_receive(:open).with(described_class::DEFAULT_FILENAME) { mock_file }
+          described_class.send(meth)
         end
         it "should YAML.load(f) -> cred" do
           YAML.should_receive(:load).with(mock_file) { mock_cred }
-          klass.send(meth)
+          described_class.send(meth)
         end
         it "should set @credentials to cred with symbol keys" do
-          File.stub(:open).with(klass::DEFAULT_FILENAME) { mock_file }
+          File.stub(:open).with(described_class::DEFAULT_FILENAME) { mock_file }
           YAML.stub(:load).with(mock_file) { mock_cred }
           mock_obj.should_receive(:instance_variable_set).with(:@credentials, symbolized_cred)
-          klass.send(meth)
+          described_class.send(meth)
         end
         it "should set the proxy" do
           mock_obj.should_receive(:proxy) { :mock_proxy }
-          klass.send(meth)
+          described_class.send(meth)
         end
         it "should return the instance" do
-          expect(klass.send(meth)).to be(mock_obj)
+          expect(described_class.send(meth)).to be(mock_obj)
         end
       end
       context "when given the arg 'some_file.yml'" do
         let(:yaml_arg) { 'some_file.yml' }
         before(:each) do mock_obj.stub(:instance_variable_set).with(:@filename, yaml_arg) end
         it "should get the instance" do
-          klass.should_receive(:instance) { mock_obj }
-          klass.send(meth, yaml_arg)
+          described_class.should_receive(:instance) { mock_obj }
+          described_class.send(meth, yaml_arg)
         end
         it "should set @filename to DEFAULT_FILENAME" do
           mock_obj.should_receive(:instance_variable_set).with(:@filename, yaml_arg)
-          klass.send(meth, yaml_arg)
+          described_class.send(meth, yaml_arg)
         end
         it "should File.open(@filename) -> f" do
           File.should_receive(:open).with(yaml_arg) { mock_file }
-          klass.send(meth, yaml_arg)
+          described_class.send(meth, yaml_arg)
         end
         it "should YAML.load(f) -> cred" do
           YAML.should_receive(:load).with(mock_file) { mock_cred }
-          klass.send(meth, yaml_arg)
+          described_class.send(meth, yaml_arg)
         end
         it "should set @credentials to cred with symbol keys" do
-          File.stub(:open).with(klass::DEFAULT_FILENAME) { mock_file }
+          File.stub(:open).with(described_class::DEFAULT_FILENAME) { mock_file }
           YAML.stub(:load).with(mock_file) { mock_cred }
           mock_obj.should_receive(:instance_variable_set).with(:@credentials, symbolized_cred)
-          klass.send(meth, yaml_arg)
+          described_class.send(meth, yaml_arg)
         end
         it "should return the instance" do
-          expect(klass.send(meth, yaml_arg)).to be(mock_obj)
+          expect(described_class.send(meth, yaml_arg)).to be(mock_obj)
         end
       end
     end
@@ -583,7 +582,7 @@ describe Helix::Config do
       it "sets a new sig expiration time" do
         mock_time = double(Time)
         Time.should_receive(:now) { mock_time }
-        mock_time.should_receive(:+).with(klass::TIME_OFFSET) { :new_time }
+        mock_time.should_receive(:+).with(described_class::TIME_OFFSET) { :new_time }
         obj.send(meth, sig_type)
         expect(obj.instance_variable_get(:@signature_expiration_for)[license_key][sig_type]).to eq(:new_time)
       end
@@ -646,7 +645,7 @@ describe Helix::Config do
         let(:not_expired_time) { Time.now + 10 }
         before do obj.instance_variable_set(:@signature_expiration_for, {license_key => {:ingest => not_expired_time}}) end
         it "should return true" do
-          expect(obj.send(meth, :ingest)).to be_true
+          expect(obj.send(meth, :ingest)).to eq(true)
         end
       end
     end

data/spec/document_spec.rb

@@ -3,8 +3,7 @@ require 'helix'
 
 describe Helix::Document do
 
-  klass = Helix::Document
-  subject { klass }
+  subject { described_class }
   mods = [ Helix::Base, Helix::Media ]
   mods.each { |mod| its(:ancestors) { should include(mod) } }
   its(:guid_name)             { should eq('document_id') }
@@ -19,7 +18,7 @@ describe Helix::Document do
   ### INSTANCE METHODS
 
   describe "an instance" do
-    obj = klass.new({'document_id' => 'some_document_guid'})
+    obj = described_class.new({'document_id' => 'some_document_guid'})
     subject { obj }
     its(:resource_label_sym) { should be(:document) }
     [:destroy, :update].each do |crud_call|
@@ -34,30 +33,30 @@ describe Helix::Document do
   describe ".upload_sig_opts" do
     let(:meth)        { :upload_sig_opts }
     let(:mock_config) { double(Helix::Config, credentials: {}) }
-    subject           { klass.method(meth) }
+    subject           { described_class.method(meth) }
     its(:arity)       { should eq(0) }
-    it "should be private" do expect(klass.private_methods).to include(meth) end
+    it "should be private" do expect(described_class.private_methods).to include(meth) end
     context "when called" do
-      subject { klass.send(meth) }
-      before(:each) do klass.stub(:config) { mock_config } end
-      it "should be a Hash" do expect(klass.send(meth)).to be_a(Hash) end
+      subject { described_class.send(meth) }
+      before(:each) do described_class.stub(:config) { mock_config } end
+      it "should be a Hash" do expect(described_class.send(meth)).to be_a(Hash) end
       its(:keys) { should match_array([:contributor, :company_id, :library_id]) }
       context "the value for :contributor" do
         it "should be config.credentials[:contributor]" do
           mock_config.should_receive(:credentials) { {contributor: :expected_contributor} }
-          expect(klass.send(meth)[:contributor]).to be(:expected_contributor)
+          expect(described_class.send(meth)[:contributor]).to be(:expected_contributor)
         end
       end
       context "the value for :company_id" do
         it "should be config.credentials[:company]" do
           mock_config.should_receive(:credentials) { {company: :expected_company} }
-          expect(klass.send(meth)[:company_id]).to be(:expected_company)
+          expect(described_class.send(meth)[:company_id]).to be(:expected_company)
         end
       end
       context "the value for :library_id" do
         it "should be config.credentials[:library]" do
           mock_config.should_receive(:credentials) { {library: :expected_library} }
-          expect(klass.send(meth)[:library_id]).to be(:expected_library)
+          expect(described_class.send(meth)[:library_id]).to be(:expected_library)
         end
       end
     end

data/spec/durationed_spec.rb

@@ -9,7 +9,7 @@ describe Helix::Durationed do
 
   klasses = [ Helix::Video, Helix::Track ]
   klasses.each do |klass|
-    subject         { klass }
+    subject { klass }
     mods = [ Helix::Base, Helix::Durationed, Helix::Media ]
     mods.each { |mod| its(:ancestors) { should include(mod) } }
 

data/spec/helix_spec.rb

@@ -2,7 +2,6 @@ require File.expand_path('../spec_helper', __FILE__)
 require 'helix'
 
 describe Helix do
-  let(:klass) { Helix }
 
   describe "Constants"
 
@@ -10,17 +9,17 @@ describe Helix do
     let(:meth) { :scope_to_company }
     let(:the_co_id) { :the_co_id }
     describe "arity" do
-      subject { klass.method(meth) }
+      subject { described_class.method(meth) }
       its(:arity) { should eq(1) }
     end
     it "should add the company arg to credentials" do
-      klass.send(meth, the_co_id)
+      described_class.send(meth, the_co_id)
       expect(Helix::Config.instance.credentials).to include(company: the_co_id)
     end
     it "should clear any pre-exisiting library from credentials" do
-      klass.send(:scope_to_library, :the_lib_name)
+      described_class.send(:scope_to_library, :the_lib_name)
       expect(Helix::Config.instance.credentials).to include(library: :the_lib_name)
-      klass.send(meth, the_co_id)
+      described_class.send(meth, the_co_id)
       expect(Helix::Config.instance.credentials.keys).not_to include(:library)
     end
   end
@@ -29,11 +28,11 @@ describe Helix do
     let(:meth) { :scope_to_library }
     let(:the_lib_name) { :the_lib_name }
     describe "arity" do
-      subject { klass.method(meth) }
+      subject { described_class.method(meth) }
       its(:arity) { should eq(1) }
     end
     it "should add the library arg to credentials" do
-      klass.send(meth, the_lib_name)
+      described_class.send(meth, the_lib_name)
       expect(Helix::Config.instance.credentials).to include(library: the_lib_name)
     end
   end
@@ -42,11 +41,11 @@ describe Helix do
     let(:meth) { :set_license_key }
     let(:the_key) { :alicense_key }
     describe "arity" do
-      subject { klass.method(meth) }
+      subject { described_class.method(meth) }
       its(:arity) { should eq(1) }
     end
     it "should add the license_key arg to credentials" do
-      klass.send(meth, the_key)
+      described_class.send(meth, the_key)
       Helix::Config.instance.credentials.should include(license_key: the_key)
     end
   end

data/spec/image_spec.rb

@@ -2,9 +2,8 @@ require File.expand_path('../spec_helper', __FILE__)
 require 'helix'
 
 describe Helix::Image do
-  let(:klass) { Helix::Image }
 
-  subject { klass }
+  subject { described_class }
   mods = [ Helix::Base, Helix::Media ]
   mods.each { |mod| its(:ancestors) { should include(mod) } }
   its(:guid_name) { should eq('image_id') }
@@ -17,7 +16,7 @@ describe Helix::Image do
   describe "Constants"
 
   describe "an instance" do
-    let(:obj) { klass.new({'image_id' => 'some_image_guid'}) }
+    let(:obj) { described_class.new({'image_id' => 'some_image_guid'}) }
     subject { obj }
     its(:resource_label_sym) { should be(:image) }
     [:destroy, :update].each do |crud_call|

data/spec/library_spec.rb

@@ -3,8 +3,7 @@ require 'helix'
 
 describe Helix::Library do
 
-  let(:klass) { Helix::Library }
-  subject     { klass }
+  subject { described_class }
 
   mods = [ Helix::Base, Helix::RESTful ]
   mods.each { |mod| its(:ancestors) { should include(mod) } }
@@ -21,19 +20,19 @@ describe Helix::Library do
 
   describe ".process_opts" do
     context "opts is {content_type: :json}" do
-      it { klass.process_opts({content_type: :json}).should eq({ content_type: :json }) }
+      it { described_class.process_opts({content_type: :json}).should eq({ content_type: :json }) }
     end
     context "opts is {content_type: :xml}" do
-      it { klass.process_opts({content_type: :xml}).should eq({ content_type: :xml }) }
+      it { described_class.process_opts({content_type: :xml}).should eq({ content_type: :xml }) }
     end
     context "when opts is {k: :v}" do
-      it { klass.process_opts({k: :v}).should eq({ k: :v, content_type: :xml }) }
+      it { described_class.process_opts({k: :v}).should eq({ k: :v, content_type: :xml }) }
     end
   end
 
   describe "an instance" do
-    let(:obj)            { klass.new({'library_id' => 'some_library_id'}) }
-    subject              { obj }
+    let(:obj) { described_class.new({'library_id' => 'some_library_id'}) }
+    subject   { obj }
     its(:resource_label_sym) { should be(:library) }
     [:destroy, :update].each do |crud_call|
       it { should respond_to(crud_call) }

data/spec/playlist_spec.rb

@@ -3,8 +3,7 @@ require 'helix'
 
 describe Helix::Playlist do
 
-  let(:klass) { Helix::Playlist }
-  subject     { klass }
+  subject { described_class }
   mods = [ Helix::Base, Helix::RESTful ]
   mods.each { |mod| its(:ancestors) { should include(mod) } }
   its(:guid_name)             { should eq('id') }
@@ -19,7 +18,7 @@ describe Helix::Playlist do
   ### INSTANCE METHODS
 
   describe "an instance" do
-    let(:obj) { klass.new({playlist_id: 'some_playlist_guid'}) }
+    let(:obj) { described_class.new({playlist_id: 'some_playlist_guid'}) }
     subject   { obj }
     its(:resource_label_sym) { should be(:playlist) }
 

data/spec/spec_helper.rb

@@ -10,4 +10,4 @@ require 'support/downloads'
 require 'support/upload_sig_opts'
 require 'support/plays'
 require 'support/uploads'
-
+require 'rspec/its'

data/spec/tag_spec.rb

@@ -3,8 +3,7 @@ require 'helix'
 
 describe Helix::Tag do
 
-  let(:klass) { Helix::Tag }
-  subject     { klass }
+  subject { described_class }
   its(:resource_label_sym)    { should be(:tag)   }
   its(:plural_resource_label) { should eq('tags') }
   it { should_not respond_to(:find) }
@@ -18,25 +17,25 @@ describe Helix::Tag do
     let(:raw_response) { {"tags" => :expected} }
     let(:mock_config)  { double(Helix::Config, build_url: :the_url, get_response: raw_response) }
     let(:opts)         { {} }
-    before(:each)      { klass.stub(:config) { mock_config }}
+    before(:each)      { described_class.stub(:config) { mock_config }}
     bu_opts          = {content_type: :xml, resource_label: "tags"}
     it "should receive build_url(#{bu_opts})" do
       mock_config.should_receive(:build_url).with(bu_opts) { :the_url }
-      klass.send(meth, opts)
+      described_class.send(meth, opts)
     end
     it "should call mock_config.get_response()" do
       mock_config.should_receive(:get_response).with(:the_url, {sig_type: :view}.merge(opts)) { raw_response }
-      klass.send(meth, opts)
+      described_class.send(meth, opts)
     end
     it "should return raw_response[:tags]" do
-      expect(klass.send(meth, opts)).to eq(:expected)
+      expect(described_class.send(meth, opts)).to eq(:expected)
     end
   end
 
   describe "Constants"
 
   describe "an instance" do
-    let(:obj) { klass.new({}) }
+    let(:obj) { described_class.new({}) }
     subject   { obj }
     its(:resource_label_sym)  { should be(:tag) }
     it { should_not respond_to(:destroy) }

data/spec/track_spec.rb

@@ -3,8 +3,7 @@ require 'helix'
 
 describe Helix::Track do
 
-  klass = Helix::Track
-  subject { klass }
+  subject { described_class }
   mods = [ Helix::Base, Helix::Durationed, Helix::Media ]
   mods.each { |mod| its(:ancestors) { should include(mod) } }
   its(:guid_name)             { should eq('track_id') }
@@ -19,7 +18,7 @@ describe Helix::Track do
   ### INSTANCE METHODS
 
   describe "an instance" do
-    obj = klass.new({'track_id' => 'some_track_guid'})
+    obj = described_class.new({'track_id' => 'some_track_guid'})
     subject { obj }
     its(:resource_label_sym) { should be(:track) }
     [:destroy, :update].each do |crud_call|

data/spec/user_spec.rb

@@ -3,8 +3,7 @@ require 'helix'
 
 describe Helix::User do
 
-  let(:klass) { Helix::User }
-  subject     { klass }
+  subject { described_class }
 
   mods = [ Helix::Base, Helix::RESTful ]
   mods.each { |mod| its(:ancestors) { should include(mod) } }
@@ -20,8 +19,8 @@ describe Helix::User do
   describe "Constants"
 
   describe "an instance" do
-    let(:obj)            { klass.new({}) }
-    subject              { obj }
+    let(:obj) { described_class.new({}) }
+    subject   { obj }
     its(:resource_label_sym) { should be(:user) }
     [:destroy, :update].each do |crud_call|
       it { should respond_to(crud_call) }

data/spec/video_spec.rb

@@ -7,8 +7,7 @@ describe Helix::Video do
     { list: { entry: values[:url_params] || {} } }.to_xml(root: :add)
   end
 
-  klass = Helix::Video
-  subject { klass }
+  subject { described_class }
   mods = [ Helix::Base, Helix::Durationed, Helix::Media ]
   mods.each { |mod| its(:ancestors) { should include(mod) } }
   its(:guid_name)             { should eq('video_id') }
@@ -23,7 +22,7 @@ describe Helix::Video do
   ### INSTANCE METHODS
 
   describe "an instance" do
-    obj = klass.new({video_id: 'some_video_guid'})
+    obj = described_class.new({video_id: 'some_video_guid'})
     subject   { obj }
     its(:resource_label_sym) { should be(:video) }
 
@@ -37,7 +36,7 @@ describe Helix::Video do
       its(:arity)       { should eq(-1) }
       it "should call self.class.get_stillframe" do
         obj.stub(:guid) { :some_guid }
-        klass.should_receive(:stillframe_for)
+        described_class.should_receive(:stillframe_for)
         obj.send(meth)
       end
     end
@@ -129,7 +128,7 @@ describe Helix::Video do
   describe ".slice" do
     let(:meth)        { :slice }
     let(:mock_config) { double(Helix::Config) }
-    subject           { klass.method(meth) }
+    subject           { described_class.method(meth) }
     its(:arity)       { should eq(-1) }
     let(:params)      { { params:       { signature: :some_sig },
                           content_type: "text/xml" } }
@@ -146,14 +145,14 @@ describe Helix::Video do
       mock_config.should_receive(:build_url).with(url_opts)
       mock_config.should_receive(:signature).with(:ingest, sig_opts) { :some_sig }
       RestClient.should_receive(:post).with(nil, import_xml, params)
-      klass.send(meth, {formats: :some_format})
+      described_class.send(meth, {formats: :some_format})
     end
   end
 
   describe ".stillframe_for" do
     let(:meth)        { :stillframe_for }
     let(:mock_config) { double(Helix::Config) }
-    subject           { klass.method(meth) }
+    subject           { described_class.method(meth) }
     its(:arity)       { should eq(-2) }
     let(:image_data)  { :some_image_data }
     let(:guid)        { :some_guid }
@@ -163,7 +162,7 @@ describe Helix::Video do
       let(:full_url) { "#{base_url}original.jpg" }
       it "should build the correct url and return data" do
         RestClient.should_receive(:get).with(full_url) { image_data }
-        expect(klass.send(meth, guid)).to eq(image_data)
+        expect(described_class.send(meth, guid)).to eq(image_data)
       end
     end
     [:height, :width].each do |dimension|
@@ -175,11 +174,11 @@ describe Helix::Video do
         it "should clone the opts arg" do
           RestClient.stub(:get).with(full_url) { image_data }
           opts.should_receive(:clone) { opts }
-          klass.send(meth, guid, opts)
+          described_class.send(meth, guid, opts)
         end
         it "should build the correct url and return data" do
           RestClient.should_receive(:get).with(full_url) { image_data }
-          expect(klass.send(meth, guid, opts)).to eq(image_data)
+          expect(described_class.send(meth, guid, opts)).to eq(image_data)
         end
       end
     end
@@ -190,11 +189,11 @@ describe Helix::Video do
       it "should clone the opts arg" do
         RestClient.stub(:get).with(full_url) { image_data }
         opts.should_receive(:clone) { opts }
-        klass.send(meth, guid, opts)
+        described_class.send(meth, guid, opts)
       end
       it "should build the correct url and return data" do
         RestClient.should_receive(:get).with(full_url) { image_data }
-        expect(klass.send(meth, guid, opts)).to eq(image_data)
+        expect(described_class.send(meth, guid, opts)).to eq(image_data)
       end
     end
   end

metadata

@@ -1,63 +1,107 @@
 --- !ruby/object:Gem::Specification
 name: helix
 version: !ruby/object:Gem::Version
-  version: 0.0.5.1.pre
+  version: 0.0.5.2.pre
 platform: ruby
 authors:
 - Twistage, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-03 00:00:00.000000000 Z
+date: 2015-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.5.4
+        version: 1.8.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.5.4
+        version: 1.8.2
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.6.7
+        version: 1.7.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.6.7
+        version: 1.7.3
 - !ruby/object:Gem::Dependency
   name: nori
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.3
+        version: 2.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.3
+        version: 2.4.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
 description: Provides helper libraries for Ruby access to the Twistage API
 email: kevin.baird@perceptivesoftware.com, michael.wood@perceptivesoftware.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- README.md
 - lib/helix.rb
 - lib/helix/album.rb
 - lib/helix/audio_playlist.rb
@@ -102,8 +146,6 @@ files:
 - spec/track_spec.rb
 - spec/user_spec.rb
 - spec/video_spec.rb
-- LICENSE
-- README.md
 homepage: https://github.com/Twistage/helix/
 licenses:
 - 3-Clause BSD
@@ -124,7 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.4
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Wrapper library for the video API