honkster-encosion 0.3.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+test/random.rb
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Rob Cameron
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,85 @@
+Encosion (en-co-shen) is a Ruby library for working with Brightcove's Media API.
+
+= Installation
+
+To get the gem:
+  gem sources -a http://gems.github.com
+  sudo gem install cannikin-encosion
+  
+= Usage
+
+First thing is first. Tell Encosion what your read and write API tokens are:
+
+  require 'rubygems'
+  require 'encosion'
+  
+  Encosion.options[:read_token] = '123abc'
+  Encosion.options[:write_token] = 'abc123'
+  
+You don't have to set these ahead of time, you can pass in the token with each request
+if you want, but do it here and you won't have to worry about it any more.
+
+Encosion has several class methods that are similar to those found in ActiveRecord
+for finding records. You'll pass a hash of options which correspond to those expected
+by Brightcove (see http://docs.brightcove.com/en/media/). All calls will require you
+to include either your read or write token depending on whether you are using the
+read or write methods.
+
+== Read Methods
+
+  # find all videos, 25 at a time, and return the first page
+  videos = Encosion::Video.find(:all, :page_size => 25, :page_number => 1)
+  
+  # find a single video by Brightcove video id
+  video = Encosion::Video.find(12345)
+  
+  # find several videos by their Brightcove video ids
+  videos = Encosion::Video.find(12345, 67890, 24680)
+  
+  # find videos by your own reference id
+  video = Encosion::Video.find_by_reference_id('our_internal_id')
+  
+  # check the status of a video (technically this uses the write API so it requires your write token)
+  status = Encosion::Video.status(12345) # finds by Brightcove video_id
+  status = Encosion::Video.status('our_internal_id') # finds by reference_id (string instead of integer)
+  
+These examples all assume that you've set your :read_token (and :write_token, in the case of
+Video.status) ahead of time. If not you can simply include the token in your call:
+
+  videos = Encosion::Video.find(:all, :page_size => 25, :page_number => 1, :token => '123abc')
+
+See Encosion::Video for all the available find methods and their variants.
+
+== Write Methods
+
+To write a video to Brightcove you will instantiate Encosion::Video, set a few required fields
+and then save it:
+
+  new_video = Encosion::Video.new(:file => File.new('/path/to/file'), :name => "My Awesome Video", :short_description => "A video of some awesome happenings", :tags => ['awesome','sweet'])
+  brightcove_id = new_video.save
+  
+The save() method returns Brightcove's ID for the video (assuming the save was successful).
+
+Again, the above examples assume that you've pre-set your :write_token. If not, just include it
+in the save() call:
+
+  brightcove_id = new_video.save(:token => 'abc123')
+  
+Brightcove requires a name and short description before it will let you save a video. The fields 
+that you can set are those that Brightcove considers writable:
+              
+* name (string)
+* short_description (string)
+* long_description (string)
+* link_url (string)
+* link_text (string)
+* tags (array of strings)
+* reference_id (string)
+* economics (enumerable, either :free or :ad_supported)
+
+And of course the video file itself. Just give :file a File object.
+
+= To Do
+
+* Implement the remaining Video write methods: update_video, delete_video, share_video, add_image
+* Implement the Playlist API read/write methods

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "honkster-encosion"
+    gem.summary = %q{Ruby library for working with the Brightcove API}
+    gem.email = "cannikinn@gmail.com"
+    gem.homepage = "http://github.com/cannikin/encosion"
+    gem.authors = ["Rob Cameron"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+    gem.add_dependency('httpclient', '>= 2.1.5.2')
+    gem.add_dependency('json', '>= 1.1.7')
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "encosion #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/encosion.gemspec

@@ -0,0 +1,60 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{encosion}
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Rob Cameron"]
+  s.date = %q{2009-08-04}
+  s.email = %q{cannikinn@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "encosion.gemspec",
+     "lib/encosion.rb",
+     "lib/encosion/base.rb",
+     "lib/encosion/cue_point.rb",
+     "lib/encosion/exceptions.rb",
+     "lib/encosion/image.rb",
+     "lib/encosion/playlist.rb",
+     "lib/encosion/rendition.rb",
+     "lib/encosion/video.rb",
+     "test/encosion_test.rb",
+     "test/movie.mov",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/cannikin/encosion}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Ruby library for working with the Brightcove API}
+  s.test_files = [
+    "test/encosion_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<httpclient>, [">= 2.1.5.2"])
+      s.add_runtime_dependency(%q<json>, [">= 1.1.7"])
+    else
+      s.add_dependency(%q<httpclient>, [">= 2.1.5.2"])
+      s.add_dependency(%q<json>, [">= 1.1.7"])
+    end
+  else
+    s.add_dependency(%q<httpclient>, [">= 2.1.5.2"])
+    s.add_dependency(%q<json>, [">= 1.1.7"])
+  end
+end

data/lib/encosion/base.rb

@@ -0,0 +1,152 @@
+require 'net/http'
+require 'rubygems'
+require 'httpclient'
+require 'json'
+
+module Encosion
+
+  # Generic Encosion error class
+  class EncosionError < StandardError
+  end
+
+  # Raised when there is no token (required to use the Brightcove API)
+  class MissingToken < EncosionError
+  end
+
+  # Raised when some parameter is missing that we need in order to do a search
+  class AssetNotFound < EncosionError
+  end
+
+  # Raised when Brightcove doesn't like the call that was made for whatever reason
+  class BrightcoveException < EncosionError
+  end
+
+  # Raised when Brightcove doesn't like the call that was made for whatever reason
+  class NoFile < EncosionError
+  end
+
+
+  # The base for all Encosion objects
+  class Base
+
+    attr_accessor :read_token, :write_token
+
+    #
+    # Class methods
+    #
+    class << self
+
+      # Does a GET to search photos and other good stuff
+      def find(*args)
+        options = extract_options(args)
+        case args.first
+        when :all   then find_all(options)
+        else        find_from_ids(args,options)
+        end
+      end
+
+      # This is an alias for find(:all)
+      def all(*args)
+        find(:all, *args)
+      end
+
+
+      # Performs an HTTP GET
+      def get(server,port,secure,path,command,options)
+        http = HTTPClient.new
+        url = secure ? 'https://' : 'http://'
+        url += "#{server}:#{port}#{path}"
+
+        options.merge!({'command' => command })
+        query_string = options.collect { |key,value| "#{key.to_s}=#{value.to_s}" }.join('&')
+
+        response = http.get(url, query_string)
+
+        body = response.body.content.strip == 'null' ? nil : JSON.parse(response.body.content.strip)   # if the call returns 'null' then there were no valid results
+        header = response.header
+
+        error_check(header,body)
+
+        # puts "url: #{url}\nquery_string:#{query_string}"
+
+        return body
+      end
+
+
+      # Performs an HTTP POST
+      def post(server,port,secure,path,command,options,instance)
+        http = HTTPClient.new
+        url = secure ? 'https://' : 'http://'
+        url += "#{server}:#{port}#{path}"
+
+        content = { 'json' => { 'method' => command, 'params' => options}.to_json }    # package up the variables as a JSON-RPC string
+        content.merge!({ 'file' => instance.file }) if instance.respond_to?('file')             # and add a file if there is one
+
+        response = http.post(url, content)
+        # get the header and body for error checking
+        body = JSON.parse(response.body.content.strip)
+        header = response.header
+
+        error_check(header,body)
+        # if we get here then no exceptions were raised
+        return body
+      end
+
+      # Checks the HTTP response and handles any errors
+      def error_check(header,body)
+        if header.status_code == 200
+          return true if body.nil?
+          puts body['error']
+          if body.has_key? 'error' && !body['error'].nil?
+            message = "Brightcove responded with an error: #{body['error']} (code #{body['code']})"
+            body['errors'].each do |error|
+              message += "\n#{error.values.first} (code #{error.values.last})"
+            end if body.has_key? 'errors'
+            raise BrightcoveException, message
+          end
+        else
+          # should only happen if the Brightcove API is unavailable (even BC errors return a 200)
+          raise BrightcoveException, body + " (status code: #{header.status_code})"
+        end
+      end
+
+      protected
+        # Pulls any Hash off the end of an array of arguments and returns it
+        def extract_options(opts)
+          opts.last.is_a?(::Hash) ? opts.pop : {}
+        end
+
+        # Find an asset from a single or array of ids
+        def find_from_ids(ids, options)
+          expects_array = ids.first.kind_of?(Array)
+          return ids.first if expects_array && ids.first.empty?
+
+          ids = ids.flatten.compact.uniq
+
+          case ids.size
+            when 0
+              raise AssetNotFound, "Couldn't find #{self.class} without an ID"
+            when 1
+              result = find_one(ids.first, options)
+              expects_array ? [ result ] : result
+            else
+              find_some(ids, options)
+          end
+        end
+
+        # Turns a hash into a query string and appends the token
+        def queryize_args(args, type)
+          case type
+          when :read
+            raise MissingToken, 'No read token found' if @read_token.nil?
+            args.merge!({ :token => @read_token })
+          when :write
+            raise MissingToken, 'No write token found' if @write_token.nil?
+            args.merge!({ :token => @write_token })
+          end
+          return args.collect { |key,value| "#{key.to_s}=#{value.to_s}" }.join('&')
+        end
+
+    end
+  end
+end

data/lib/encosion/exceptions.rb

@@ -0,0 +1,4 @@
+module EncosionError
+  class TokenMissing < StandardError; end;
+  class BrightcoveException < StandardError; end;
+end

data/lib/encosion/image.rb

@@ -0,0 +1,90 @@
+module Encosion
+
+  class Image < Base
+    ENUMS = { :image_type => { :thumbnail => "THUMBNAIL", :video_still => "VIDEO_STILL"}}
+
+    attr_accessor(
+      :name,
+      :type,
+      :reference_id,
+      :remote_url,
+      :video_id
+    )
+
+    #
+    # Class methods
+    #
+    class << self
+
+      # the actual method that calls a post (user can use this directly if they want to call a method that's not included here)
+      def write(method, options)
+        # options.merge!(Encosion.options)
+        options.merge!({:token => Encosion.options[:write_token]}) unless options[:token]
+
+        Image.post( Encosion.options[:server],
+                    Encosion.options[:port],
+                    Encosion.options[:secure],
+                    Encosion.options[:write_path],
+                    method,
+                    options,
+                    self)
+      end
+
+    end
+
+    #
+    # Instance methods
+    #
+    def initialize(args={})
+      @video_id = args[:video_id]
+      @name = args[:name]
+      @reference_id = args[:reference_id]
+      @remote_url = args[:remote_url]
+      @type = args[:type]
+    end
+
+
+    # Saves an image to Brightcove. Returns the Brightcove ID for the image that was just uploaded.
+    #   new_image = Encosion::Image.new(:remote_file => "http://example.com/image.jpg", :display_name => "My Awesome Image", :type => "VIDEO_STILL", :video_id = > "brightcove_video_id")
+    #   brightcove_id = new_image.save(:token => '123abc')
+
+    def save(args={})
+      # check to make sure we have everything needed for a create_video call
+#      raise NoFile, "You need to attach a file to this video before you can upload it: Video.file = File.new('/path/to/file')" if @file.nil?
+      options = args.merge({ 'image' => self.to_brightcove, :video_id => self.video_id }) # take the parameters of this video and make them a valid video object for upload
+      options.merge!({:token => Encosion.options[:write_token]}) unless options[:token]
+      response = Image.post(Encosion.options[:server],
+                            Encosion.options[:port],
+                            Encosion.options[:secure],
+                            Encosion.options[:write_path],
+                            'add_image',
+                            options,
+                            self)
+      return response['result'] # returns the Brightcove ID of the video that was just uploaded
+    end
+
+
+    # Output the image as JSON
+    def to_json
+      {
+        :name => @name,
+        :remote_url => @remote_url,
+        :type => ENUMS[:image_type][@type],
+        :reference_id => @reference_id
+      }.to_json
+    end
+
+
+    # Outputs the image object into Brightcove's expected format
+    def to_brightcove
+      {
+        'displayName' => @name,
+        'remoteUrl' => @remote_url,
+        'type' => ENUMS[:image_type][@type],
+        'referenceId' => @reference_id
+      }
+    end
+
+  end
+
+end

data/lib/encosion/playlist.rb

@@ -0,0 +1,24 @@
+module Encosion
+  
+  class Playlist
+    
+    attr_reader :id, :name, :short_description, :reference_id, :videos
+        
+    def initialize(obj)
+      @id = obj['id']
+      @name = obj['name']
+      @short_description = obj['shortDescription']
+      @videos = obj['videos'].collect { |video| Video.new(video) }
+    end
+    
+    def to_json
+      { :id => @id,
+        :name => @name,
+        :short_description => @short_description,
+        :reference_id => @reference_id,
+        :videos => @videos }.to_json
+    end
+    
+  end
+  
+end

data/lib/encosion/video.rb

@@ -0,0 +1,304 @@
+module Encosion
+  # Raised if you try to set an invalid economics value
+  class InvalidEconomicsValue < StandardError;
+  end;
+
+  class Video < Base
+
+    ENUMS = { :economics => { :free => 'FREE', :ad_supported => 'AD_SUPPORTED'}}
+
+    attr_accessor(:name,
+                  :short_description,
+                  :long_description,
+                  :link_url,
+                  :link_text,
+                  :tags,
+                  :reference_id,
+                  :economics,
+                  :file)
+    attr_reader(:id,
+                :account_id,
+                :flv_url,
+                :creation_date,
+                :published_date,
+                :last_modified_date,
+                :video_still_url,
+                :thumbnail_url,
+                :length,
+                :plays_total,
+                :plays_trailing_week)
+
+    #
+    # Class methods
+    #
+    class << self
+
+      # Find a video by reference_id. Invokes Brightcove Media API command 'find_video_by_reference_id' or
+      # 'find_videos_by_reference_ids' depending on whether you call one or multiple ids
+      #   Encosion::Video.find_by_reference_id('mycompany_1')
+      #   Encosion::Video.find_by_reference_id('mycompany_1','mycompany_2','mycompany_3')
+
+      def find_by_reference_id(*args)
+        options = extract_options(args)
+        ids = args.flatten.compact.uniq
+
+        case ids.size
+          when 0
+            raise AssetNotFound, "Couldn't find #{self.class} without a reference ID"
+          when 1
+            options.merge!({:reference_id => ids.first})
+            response = read('find_video_by_reference_id', options)
+            return self.parse(response)
+          else
+            options.merge!({:reference_ids => ids.join(',')})
+            response = read('find_videos_by_reference_ids', options)
+            return response['items'].collect { |item| self.parse(item) }
+        end
+      end
+
+      # Find a video by text search. Invokes Brightcove Media API command 'find_videos_by_text'
+      #   Encosion::Video.find_by_text('funny videos')
+
+      def find_by_text(*args)
+        options = extract_options(args)
+        text = args.flatten.compact.uniq
+        raise AssetNotFound, "Couldn't find #{self.class} without text" if text == ''
+        options.merge!({:text => text.first})
+        if response = read('find_videos_by_text', options)
+          return response['items'].collect { |item| self.parse(item) }
+        else
+          nil
+        end
+      end
+
+
+      # Find videos related to the given video_id. Invokes Brightcove Media API command 'find_related_videos'
+      #   Encosion::Video.find_related(123456)
+
+      def find_related(*args)
+        options = extract_options(args)
+        raise AssetNotFound, "Cannot find related #{self.class}s without a video_id or reference_id" if options[:video_id].nil? && options[:reference_id].nil?
+        if response = read('find_related_videos', options)
+          return response['items'].collect { |item| self.parse(item) }
+        else
+          return nil
+        end
+      end
+
+
+      # Find a video by tag search. Invokes Brightcove Media API command 'find_videos_by_tags'
+      #   Encosion::Video.find_by_tags('bloopers','gagreel','funny')
+
+      def find_by_tags(*args)
+        options = extract_options(args)
+        tags = args.flatten.compact.uniq
+
+        case tags.size
+          when 0
+            raise AssetNotFound, "Couldn't find #{self.class} without tags"
+          else
+            options.merge!({:and_tags => tags.join(',')})
+            if response = read('find_videos_by_tags', options)
+              return response['items'].collect { |item| self.parse(item) }
+            else
+              return nil
+            end
+        end
+      end
+
+
+      # Returns the status of a video upload (returns one of :uploading | :processing | :complete | :error )
+      # Takes either Brightcove's video_id or your own reference_id. If you pass an integer it's assumed to be
+      # a video_id, if you pass a string it's assumed to be a reference_id.
+      #   Encosion::Video.status(12345)
+
+      def status(*args)
+        options = extract_options(args)
+        id = args.flatten.compact.uniq.first
+
+        if id.class == String
+          options.merge!({:reference_id => id})
+        else
+          options.merge!({:video_id => id})
+        end
+
+        if response = write('get_upload_status', options)
+          return response['result'].downcase.to_sym
+        else
+          return nil
+        end
+      end
+
+
+      # the actual method that calls a get (user can use this directly if they want to call a method that's not included here)
+      def read(method, options)
+        # options.merge!(Encosion.options)
+        options.merge!({:token => Encosion.options[:read_token]}) unless options[:token]
+        get( Encosion.options[:server],
+             Encosion.options[:port],
+             Encosion.options[:secure],
+             Encosion.options[:read_path],
+             method,
+             options)
+      end
+
+
+      # the actual method that calls a post (user can use this directly if they want to call a method that's not included here)
+      def write(method, options)
+        # options.merge!(Encosion.options)
+        options.merge!({:token => Encosion.options[:write_token]}) unless options[:token]
+        Video.post( Encosion.options[:server],
+                    Encosion.options[:port],
+                    Encosion.options[:secure],
+                    Encosion.options[:write_path],
+                    method,
+                    options,
+                    self)
+      end
+
+      protected
+      # Find some videos by ids
+      def find_one(id, options)
+        options.merge!({:video_id => id})
+        response = read('find_video_by_id', options)
+        return self.parse(response)
+      end
+
+      # Find mutliple videos by id
+      def find_some(ids, options)
+        options.merge!({:video_ids => ids.join(',')})
+        response = read('find_videos_by_ids', options)
+        return response['items'].collect { |item| self.parse(item) }
+      end
+
+      # Find all videos
+      def find_all(options)
+        response = read('find_all_videos', options)
+
+        return response['items'].collect { |item| self.parse(item) }
+      end
+
+      def destroy(options)
+        response = read('delete_video', options)
+        return response['result']
+      end
+
+      # Creates a new Video object from a Ruby hash (used to create a video from a parsed API call)
+      def parse(obj)
+        if obj
+          args = {:id => obj['id'].to_i,
+                  :name => obj['name'],
+                  :short_description => obj['shortDescription'],
+                  :long_description => obj['longDescription'],
+                  :creation_date => Time.at(obj['creationDate'].to_i/1000),
+                  :published_date => Time.at(obj['publishedDate'].to_i/1000),
+                  :last_modified_date => Time.at(obj['lastModifiedDate'].to_i/1000),
+                  :link_url => obj['linkURL'],
+                  :link_text => obj['linkText'],
+                  :tags => obj['tags'],
+                  :video_still_url => obj['videoStillURL'],
+                  :thumbnail_url => obj['thumbnailURL'],
+                  :reference_id => obj['referenceID'],
+                  :length => obj['length'].to_i,
+                  :economics => obj['economics'] ? ENUMS[:economics].find { |key, value| value == obj['economics'] }.first : nil,
+                  :plays_total => obj['playsTotal'].to_i,
+                  :plays_trailing_week => obj['playsTrailingWeek'].to_i } unless obj.nil?
+          return self.new(args)
+        else
+          return nil
+        end
+      end
+
+    end
+
+    #
+    # Instance methods
+    #
+    def initialize(args={})
+      @id = args[:id]
+      @name = args[:name]
+      @short_description = args[:short_description]
+      @long_description = args[:long_description]
+      @creation_date = args[:creation_date]
+      @published_date = args[:published_date]
+      @last_modified_date = args[:last_modified_date]
+      @link_url = args[:link_url]
+      @link_text = args[:link_text]
+      @tags = args[:tags]
+      @video_still_url = args[:video_still_url]
+      @thumbnail_url = args[:thumbnail_url]
+      @reference_id = args[:reference_id]
+      @length = args[:length]
+      @economics = self.economics = args[:economics]
+      @plays_total = args[:plays_total]
+      @plays_trailing_week = args[:plays_trailing_week]
+      @file = args[:file]
+    end
+
+    # Saves a video to Brightcove. Returns the Brightcove ID for the video that was just uploaded.
+    #   new_video = Encosion::Video.new(:file => File.new('/path/to/file'), :name => "My Awesome Video", :short_description => "A video of some awesome happenings", :tags => ['awesome','sweet'])
+    #   brightcove_id = new_video.save(:token => '123abc')
+    def save(args={})
+      # check to make sure we have everything needed for a create_video call
+      raise NoFile, "You need to attach a file to this video before you can upload it: Video.file = File.new('/path/to/file')" if @file.nil?
+      options = args.merge({ 'video' => self.to_brightcove }) # take the parameters of this video and make them a valid video object for upload
+      options.merge!({:token => Encosion.options[:write_token]}) unless options[:token]
+      response = Video.post(Encosion.options[:server],
+                            Encosion.options[:port],
+                            Encosion.options[:secure],
+                            Encosion.options[:write_path],
+                            'create_video',
+                            options,
+                            self)
+      return response['result'] # returns the Brightcove ID of the video that was just uploaded
+    end
+
+    # Output the video as JSON
+    def to_json
+      {
+        :id => @id,
+        :name => @name,
+        :short_description => @short_description,
+        :long_description => @long_description,
+        :creation_date => @creation_date,
+        :published_date => @published_date,
+        :last_modified_date => @last_modified_date,
+        :link_url => @link_url,
+        :link_text => @link_text,
+        :tags => @tags,
+        :video_still_url => @video_still_url,
+        :thumbnail_url => @thumbnail_url,
+        :reference_id => @reference_id,
+        :length => @length,
+        :economics => @economics,
+        :plays_total => @plays_total,
+        :plays_trailing_week => @plays_trailing_week
+      }.to_json
+    end
+
+    # Outputs the video object into Brightcove's expected format
+    def to_brightcove
+      {
+        'name' => @name,
+        'shortDescription' => @short_description,
+        'longDescription' => @long_description,
+        'linkURL' => @link_url,
+        'linkText' => @link_text,
+        'tags' => @tags,
+        'referenceId' => @reference_id,
+        'economics' => ENUMS[:economics][@economics]
+      }
+    end
+
+    # Makes sure that the economics set on this video is one of a predetermined list
+    def economics=(sym)
+      unless sym.nil?
+        unless ENUMS[:economics].has_key?(sym)
+          raise InvalidEconomicsValue, "A video's economics value must be one of #{ENUMS[:economics].collect { |key, value| key.inspect }.join(', ')}"
+        else
+          @economics = sym
+        end
+      end
+    end
+  end
+end

data/lib/encosion.rb

@@ -0,0 +1,43 @@
+$:.unshift File.dirname(__FILE__) # for use/testing when no gem is installed
+
+# external
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'cgi'
+require 'logger'
+require 'json'
+require 'yaml'
+
+# internal
+require 'encosion/base'
+require 'encosion/video'
+require 'encosion/image'
+require 'encosion/playlist'
+require 'encosion/exceptions'
+
+module Encosion
+
+  VERSION = '0.3.0'
+  LOGGER = Logger.new(STDOUT)
+
+  SERVER = 'api.brightcove.com'
+  PORT = 80
+  SECURE = false
+  READ_PATH = '/services/library'
+  WRITE_PATH = '/services/post'
+  DEFAULT_OPTIONS = { :debug => false }
+
+  @options = {  :read_token => nil,
+                :write_token => nil,
+                :server => SERVER,
+                :port => PORT,
+                :secure => SECURE,
+                :read_path => READ_PATH,
+                :write_path => WRITE_PATH }
+  attr_accessor :options
+
+  # make @options available so it can be set externally when using the library
+  extend self
+
+end

data/test/encosion_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class EncosionTest < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'encosion'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: honkster-encosion
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Rob Cameron
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-06 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httpclient
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.5.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.7
+    version: 
+description: 
+email: cannikinn@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- encosion.gemspec
+- lib/encosion.rb
+- lib/encosion/base.rb
+- lib/encosion/cue_point.rb
+- lib/encosion/exceptions.rb
+- lib/encosion/image.rb
+- lib/encosion/playlist.rb
+- lib/encosion/rendition.rb
+- lib/encosion/video.rb
+- test/encosion_test.rb
+- test/movie.mov
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/cannikin/encosion
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby library for working with the Brightcove API
+test_files: 
+- test/encosion_test.rb
+- test/test_helper.rb