zencoder 2.2.2 → 2.3.0

data/lib/zencoder/account.rb

@@ -1,5 +1,5 @@
-class Zencoder
-  class Account < Zencoder
+module Zencoder
+  class Account < Base
 
     def self.create(params={}, options={})
       HTTP.post("#{options[:base_url] || base_url}/account", encode(params, options[:format]), options)

data/lib/zencoder/base.rb

@@ -0,0 +1,82 @@
+module Zencoder
+  class Base
+
+    def self.api_key
+      Zencoder.api_key
+    end
+
+    def self.base_url
+      Zencoder.base_url
+    end
+
+    def self.encode(content, format=nil)
+      if content.is_a?(String)
+        content
+      elsif format.to_s == 'xml'
+        if content.is_a?(Hash) && content.keys.size == 1
+          content[content.keys.first].to_xml(:root => content.keys.first)
+        else
+          content.to_xml
+        end
+      else
+        content.to_json
+      end
+    end
+
+    def encode(content, format=nil)
+      self.class.encode(content, format)
+    end
+
+    def self.decode(content, format=nil)
+      if content.is_a?(String)
+        if format.to_s == 'xml'
+          Hash.from_xml(content)
+        else
+          ActiveSupport::JSON.decode(content)
+        end
+      else
+        content
+      end
+    end
+
+    def decode(content, format=nil)
+      self.class.decode(content, format)
+    end
+
+
+  protected
+
+    def self.apply_api_key(params, format=nil)
+      if api_key
+        decoded_params = decode(params, format).with_indifferent_access
+
+        if decoded_params[:api_request]
+          decoded_params[:api_request] = decoded_params[:api_request].with_indifferent_access
+        end
+
+        if format.to_s == 'xml'
+          if !(decoded_params[:api_request] && decoded_params[:api_request][:api_key])
+            decoded_params[:api_request] ||= {}.with_indifferent_access
+            decoded_params[:api_request][:api_key] = api_key
+          end
+        else
+          decoded_params['api_key'] = api_key unless decoded_params['api_key']
+        end
+
+        decoded_params
+      else
+        params
+      end
+    end
+
+    def self.merge_params(options, params)
+      if options[:params]
+        options[:params] = options[:params].merge(params)
+        options
+      else
+        options.merge(:params => params)
+      end
+    end
+
+  end
+end

data/lib/zencoder/errors.rb

@@ -1,5 +1,6 @@
-class Zencoder
+module Zencoder
   class Error < StandardError
+
     def initialize(error_or_message)
       if error_or_message.is_a?(Exception)
         @error = error_or_message
@@ -38,4 +39,5 @@ class Zencoder
   end
 
   class HTTPError < Error; end
+
 end

data/lib/zencoder/http/net_http.rb

@@ -1,8 +1,8 @@
 # Ruby's Net/HTTP Sucks
 # Borrowed root cert checking from http://redcorundum.blogspot.com/2008/03/ssl-certificates-and-nethttps.html
 
-class Zencoder
-  class HTTP < Zencoder
+module Zencoder
+  class HTTP < Base
     class NetHTTP
 
       attr_accessor :method, :url, :uri, :body, :params, :headers, :timeout, :skip_ssl_verify, :options

data/lib/zencoder/http/typhoeus.rb

@@ -1,5 +1,5 @@
-class Zencoder
-  class HTTP < Zencoder
+module Zencoder
+  class HTTP < Base
     class Typhoeus
 
       def self.post(url, options={})

data/lib/zencoder/http.rb

@@ -1,5 +1,5 @@
-class Zencoder
-  class HTTP < Zencoder
+module Zencoder
+  class HTTP < Base
 
     attr_accessor :body, :url, :options, :method, :format
 

data/lib/zencoder/job.rb

@@ -1,5 +1,5 @@
-class Zencoder
-  class Job < Zencoder
+module Zencoder
+  class Job < Base
 
     def self.create(params={}, options={})
       params = apply_api_key(params, options[:format])

data/lib/zencoder/notification.rb

@@ -1,5 +1,5 @@
-class Zencoder
-  class Notification < Zencoder
+module Zencoder
+  class Notification < Base
 
     def self.list(options={})
       params = {:api_key  => options.delete(:api_key) || api_key,

data/lib/zencoder/output.rb

@@ -1,5 +1,5 @@
-class Zencoder
-  class Output < Zencoder
+module Zencoder
+  class Output < Base
 
     def self.progress(output_id, options={})
       params = {:api_key => options.delete(:api_key) || api_key}
@@ -7,4 +7,4 @@ class Zencoder
     end
 
   end
-end
+end

data/lib/zencoder/response.rb

@@ -1,5 +1,5 @@
-class Zencoder
-  class Response < Zencoder
+module Zencoder
+  class Response < Base
 
     attr_accessor :code, :body, :raw_body, :raw_response
 

data/lib/zencoder/version.rb

@@ -1,3 +1,3 @@
-class Zencoder
-  GEM_VERSION = '2.2.2'
+module Zencoder
+  GEM_VERSION = '2.3.0'
 end

data/lib/zencoder/zencoder.rb

@@ -1,85 +1,17 @@
-class Zencoder
+module Zencoder
 
-  cattr_writer :base_url
-  cattr_writer :api_key
+  mattr_writer :api_key
+  mattr_writer :base_url
+
+  self.api_key  = nil
+  self.base_url = 'https://app.zencoder.com/api'
 
   def self.api_key
     @@api_key || ENV['ZENCODER_API_KEY']
   end
 
-  self.base_url = 'https://app.zencoder.com/api'
-
   def self.base_url(env=nil)
     @@base_url
   end
 
-  def self.encode(content, format=nil)
-    if content.is_a?(String)
-      content
-    elsif format.to_s == 'xml'
-      if content.is_a?(Hash) && content.keys.size == 1
-        content[content.keys.first].to_xml(:root => content.keys.first)
-      else
-        content.to_xml
-      end
-    else
-      content.to_json
-    end
-  end
-
-  def encode(content, format=nil)
-    self.class.encode(content, format)
-  end
-
-  def self.decode(content, format=nil)
-    if content.is_a?(String)
-      if format.to_s == 'xml'
-        Hash.from_xml(content)
-      else
-        ActiveSupport::JSON.decode(content)
-      end
-    else
-      content
-    end
-  end
-
-  def decode(content, format=nil)
-    self.class.decode(content, format)
-  end
-
-
-protected
-
-  def self.apply_api_key(params, format=nil)
-    if api_key
-      decoded_params = decode(params, format).with_indifferent_access
-
-      if decoded_params[:api_request]
-        decoded_params[:api_request] = decoded_params[:api_request].with_indifferent_access
-      end
-
-      if format.to_s == 'xml'
-        if !(decoded_params[:api_request] && decoded_params[:api_request][:api_key])
-          decoded_params[:api_request] ||= {}.with_indifferent_access
-          decoded_params[:api_request][:api_key] = api_key
-        end
-      else
-        decoded_params['api_key'] = api_key unless decoded_params['api_key']
-      end
-
-      decoded_params
-    else
-      params
-    end
-  end
-
-  def self.merge_params(options, params)
-    if options[:params]
-      options[:params] = options[:params].merge(params)
-      options
-    else
-      options.merge(:params => params)
-    end
-  end
-
 end

data/lib/zencoder.rb

@@ -13,6 +13,7 @@ end
 # Zencoder
 require 'zencoder/extensions'
 require 'zencoder/zencoder'
+require 'zencoder/base'
 require 'zencoder/http/net_http'
 require 'zencoder/http/typhoeus'
 require 'zencoder/http'

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zencoder
 version: !ruby/object:Gem::Version 
+  hash: 3
   prerelease: false
   segments: 
   - 2
-  - 2
-  - 2
-  version: 2.2.2
+  - 3
+  - 0
+  version: 2.3.0
 platform: ruby
 authors: 
 - Nathan Sutton
@@ -22,9 +23,11 @@ dependencies:
   name: activesupport
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -34,9 +37,11 @@ dependencies:
   name: i18n
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -46,9 +51,11 @@ dependencies:
   name: shoulda
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -58,9 +65,11 @@ dependencies:
   name: mocha
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -70,37 +79,27 @@ dependencies:
   name: webmock
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
   type: :development
   version_requirements: *id005
-description: Zencoder <http://zencoder.com> integration library and CLI client.
+description: Zencoder <http://zencoder.com> integration library.
 email: info@zencoder.com
-executables: 
-- zencoder
+executables: []
+
 extensions: []
 
 extra_rdoc_files: []
 
 files: 
-- bin/zencoder
 - lib/zencoder/account.rb
-- lib/zencoder/cli/auth.rb
-- lib/zencoder/cli/command.rb
-- lib/zencoder/cli/commands/account.rb
-- lib/zencoder/cli/commands/base.rb
-- lib/zencoder/cli/commands/jobs.rb
-- lib/zencoder/cli/commands/outputs.rb
-- lib/zencoder/cli/commands/plugins.rb
-- lib/zencoder/cli/commands/setup.rb
-- lib/zencoder/cli/helpers.rb
-- lib/zencoder/cli/plugin.rb
-- lib/zencoder/cli/response.rb
-- lib/zencoder/cli.rb
+- lib/zencoder/base.rb
 - lib/zencoder/errors.rb
 - lib/zencoder/extensions.rb
 - lib/zencoder/http/net_http.rb
@@ -126,25 +125,29 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: zencoder
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Zencoder <http://zencoder.com> integration library and CLI client.
+summary: Zencoder <http://zencoder.com> integration library.
 test_files: []
 

data/bin/zencoder

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-$: << File.expand_path("#{File.dirname(__FILE__)}/../lib")
-require 'zencoder/cli'

data/lib/zencoder/cli/auth.rb

@@ -1,28 +0,0 @@
-require 'yaml'
-
-module ZencoderCLI
-  module Auth
-    extend ZencoderCLI::Helpers
-    class << self
-
-      def require_authentication(env)
-        Zencoder.api_key ||= retrieve_api_key(env)
-      end
-
-      def retrieve_api_key(env)
-        env = "production" if !env || env.blank?
-        if File.exist?("#{home_directory}/.zencoder/api-key")
-          keys = YAML.load_file("#{home_directory}/.zencoder/api-key")
-          if keys[env].present?
-            keys[env]
-          else
-            error "No API found for the #{env} environment. Either set the environment variable ZENCODER_API_KEY or run `zencoder setup`."
-          end
-        else
-          error "No API keys found. Either set the environment variable ZENCODER_API_KEY or run `zencoder setup`."
-        end
-      end
-
-    end
-  end
-end

data/lib/zencoder/cli/command.rb

@@ -1,41 +0,0 @@
-module ZencoderCLI
-  module Command
-    extend ZencoderCLI::Helpers
-
-    class UnknownCommandName < RuntimeError; end
-
-    mattr_accessor :commands
-    self.commands = {}
-
-    class << self
-
-      def run(command, args, global_options={}, command_options={})
-        ZencoderCLI::Auth.require_authentication(global_options[:environment]) unless command[/^setup/]
-        pieces = command.split(":")
-        if pieces.size == 1
-          method_name = :run
-          klass_name = pieces.first.camelize
-        else
-          method_name = pieces.pop
-          klass_name = pieces.map(&:camelize).join("::")
-        end
-        klass = "ZencoderCLI::Command::#{klass_name}".constantize
-        if klass.respond_to?(method_name)
-          klass.send(method_name, args, global_options, command_options)
-        else
-          raise UnknownCommandName
-        end
-      rescue UnknownCommandName, NameError => e
-        if e.class == UnknownCommandName || e.message[/uninitialized constant ZencoderCLI::Command::/]
-          error "There is no command named #{command}. Use --help for more information."
-        else
-          raise e
-        end
-      end
-
-    end
-  end
-end
-
-require 'zencoder/cli/commands/base'
-Dir["#{File.dirname(__FILE__)}/commands/*.rb"].each { |c| require c }

data/lib/zencoder/cli/commands/account.rb

@@ -1,42 +0,0 @@
-module ZencoderCLI::Command
-  class Account < Base
-
-    provides "account", { "account:show" => "Show account information",
-                          "account:integration" => "Put your account in integration mode",
-                          "account:live" => "Take your account out of integration mode" }
-
-    class << self
-
-      def show(args, global_options, command_options)
-        account = Zencoder::Account.details(:base_url => Zencoder.base_url(global_options[:environment])).body
-        rows = []
-        rows << ["Minutes Used", account["minutes_used"]]
-        rows << ["Minutes Included", account["minutes_included"]]
-        rows << ["Account State", account["account_state"].titleize]
-        rows << ["Billing State", account["billing_state"].titleize]
-        rows << ["Plan", account["plan"]]
-        rows << ["Integration Mode", account["integration_mode"] ? "YES" : "NO"]
-        puts table([{ :value => "Account", :colspan => 2 }], *rows)
-      end
-
-      def integration(args, global_options, command_options)
-        response = Zencoder::Account.integration(:base_url => Zencoder.base_url(global_options[:environment]))
-        if response.success?
-          puts "Your account is now in integration mode."
-        else
-          puts "There was an unexpected problem."
-        end
-      end
-
-      def live(args, global_options, command_options)
-        response = Zencoder::Account.live(:base_url => Zencoder.base_url(global_options[:environment]))
-        if response.success?
-          puts "Your account is now able to process live jobs."
-        else
-          puts "You cannot turn off integration mode for this account."
-        end
-      end
-
-    end
-  end
-end

data/lib/zencoder/cli/commands/base.rb

@@ -1,13 +0,0 @@
-module ZencoderCLI::Command
-  class Base
-    extend ZencoderCLI::Helpers
-
-    class << self
-
-      def provides(name, commands={})
-        ZencoderCLI::Command.commands.merge!({ name => commands })
-      end
-
-    end
-  end
-end

data/lib/zencoder/cli/commands/jobs.rb

@@ -1,133 +0,0 @@
-module ZencoderCLI::Command
-  class Jobs < Base
-
-    provides "jobs", { "jobs:list"     => { :description => "Lists the most recent jobs",
-                                            :options => proc{|t|
-                                              t.opt :number, "Number of jobs returned per page. Default 10.", :type => Integer
-                                              t.opt :page,   "Jobs page number. Default 1.", :type => Integer
-                                              t.opt :long,   "Will not truncate filenames.", :default => false
-                                            }},
-                       "jobs:show"     => "Show job details by ID",
-                       "jobs:resubmit" => "Resubmit a job by ID",
-                       "jobs:cancel"   => "Cancels a job by ID",
-                       "jobs:delete"   => "Deletes a job by ID" }
-
-    class << self
-
-      def list(args, global_options, command_options)
-        jobs = Zencoder::Job.list(:base_url => Zencoder.base_url(global_options[:environment]), :per_page => command_options[:number] || 10, :page => command_options[:page] || 1).process_for_cli.body
-        if jobs.any?
-          jobs_table = table do |t|
-            t.headings = ["ID", "Created", "Filename", "Duration", "Size", "Test", "State"]
-            jobs.each do |job|
-              duration = job["job"]["input_media_file"]["duration_in_ms"] ? (job["job"]["input_media_file"]["duration_in_ms"]/1000).to_s+"s" : "---"
-              filesize = job["job"]["input_media_file"]["file_size_bytes"] ? ("%0.2f" % (job["job"]["input_media_file"]["file_size_bytes"].to_f/1.megabyte))+" MB" : "---"
-              t << [
-                job["job"]["id"],
-                format_date(job["job"]["created_at"]),
-                truncate(File.basename(job["job"]["input_media_file"]["url"]), :length => command_options[:long] ? 256 : 25),
-                { :value => duration, :alignment => :right },
-                { :value => filesize, :alignment => :right },
-                job["job"]["test"] ? "YES" : "NO",
-                job["job"]["state"].titleize
-              ]
-            end
-          end
-          puts jobs_table
-        else
-          puts "No jobs found."
-        end
-      end
-
-      def show(args, global_options, command_options)
-        job = Zencoder::Job.details(args.shift, :base_url => Zencoder.base_url(global_options[:environment])).process_for_cli.body["job"]
-        rows = []
-        rows << ["ID", job["id"]]
-        rows << ["Created", format_date(job["created_at"])]
-        rows << ["Finished", format_date(job["finished_at"])] if job["finished_at"]
-        rows << ["Pass Through", job["pass_through"]] if job["pass_through"]
-        rows << ["Test", job["test"] ? "YES" : "NO"]
-        rows << ["State", job["state"].titleize]
-        puts table([{ :value => "Job", :colspan => 2 }], *rows)
-        puts
-
-        input = job["input_media_file"]
-        rows = []
-        rows << ["ID", input["id"]]
-        rows << ["URL", input["url"]]
-        rows << ["State", input["state"].titleize]
-        rows << ["Duration", (input["duration_in_ms"]/1000).to_s+" seconds"] if input["duration_in_ms"]
-        rows << ["Size", ("%0.2f" % (input["file_size_bytes"].to_f/1.megabyte))+" MB"] if input["file_size_bytes"]
-        rows << ["Format", input["format"]] if input["format"]
-        if input["state"] == "finished"
-          rows << :separator
-          rows << ["Video Codec", input["video_codec"]] if input["video_codec"]
-          rows << ["Resolution", input["width"].to_s+"x"+input["height"].to_s] if input["width"] && input["height"]
-          rows << ["Video Bitrate", input["video_bitrate_in_kbps"].to_s+" Kbps"] if input["video_bitrate_in_kbps"]
-          rows << ["Frame Rate", input["frame_rate"]] if input["frame_rate"]
-          rows << :separator
-          rows << ["Audio Codec", input["audio_codec"]] if input["audio_codec"]
-          rows << ["Audio Bitrate", input["audio_bitrate_in_kbps"].to_s+" Kbps"] if input["audio_codec"]
-          rows << ["Sample Rate", input["audio_sample_rate"]] if input["audio_sample_rate"]
-          rows << ["Channels", input["channels"]] if input["channels"]
-        end
-        if input["error_class"] || input["error_message"]
-          rows << :separator
-          rows << ["Error Class", input["error_class"]] if input["error_class"]
-          rows << ["Error Message", input["error_message"]] if input["error_message"]
-        end
-        puts table([{ :value => "Input", :colspan => 2 }], *rows)
-        puts
-
-        job["output_media_files"].each_with_index do |output, i|
-          rows = []
-          rows << ["ID", output["id"]]
-          rows << ["Label", output["label"]] if output["label"]
-          rows << ["URL", output["url"]]
-          rows << ["State", output["state"].titleize]
-          rows << ["Duration", (output["duration_in_ms"]/1000).to_s+" seconds"] if output["duration_in_ms"]
-          rows << ["Size", ("%0.2f" % (output["file_size_bytes"].to_f/1.megabyte))+" MB"] if output["file_size_bytes"]
-          rows << ["Format", output["format"]] if output["format"]
-          if output["state"] == "finished"
-            rows << :separator
-            rows << ["Video Codec", output["video_codec"]] if output["video_codec"]
-            rows << ["Resolution", output["width"].to_s+"x"+output["height"].to_s] if output["width"] && output["height"]
-            rows << ["Video Bitrate", output["video_bitrate_in_kbps"].to_s+" Kbps"] if output["video_bitrate_in_kbps"]
-            rows << ["Frame Rate", output["frame_rate"]] if output["frame_rate"]
-            rows << :separator
-            rows << ["Audio Codec", output["audio_codec"]] if output["audio_codec"]
-            rows << ["Audio Bitrate", output["audio_bitrate_in_kbps"].to_s+" Kbps"] if output["audio_codec"]
-            rows << ["Sample Rate", output["audio_sample_rate"]] if output["audio_sample_rate"]
-            rows << ["Channels", output["channels"]] if output["channels"]
-          end
-          if output["error_class"] || output["error_message"]
-            rows << :separator
-            rows << ["Error Class", output["error_class"]] if output["error_class"]
-            rows << ["Error Message", output["error_message"]] if output["error_message"]
-          end
-          puts table([{ :value => "Output ##{i+1}", :colspan => 2 }], *rows)
-          puts
-        end
-      end
-
-      def resubmit(args, global_options, command_options)
-        job_id = args.shift
-        response = Zencoder::Job.resubmit(job_id, :base_url => Zencoder.base_url(global_options[:environment])).process_for_cli
-        puts "Job ##{job_id} resubmitted."
-      end
-
-      def cancel(args, global_options, command_options)
-        job_id = args.shift
-        response = Zencoder::Job.cancel(job_id, :base_url => Zencoder.base_url(global_options[:environment])).process_for_cli
-        puts "Job ##{job_id} cancelled."
-      end
-
-      def delete(args, global_options, command_options)
-        job_id = args.shift
-        response = Zencoder::Job.delete(job_id, :base_url => Zencoder.base_url(global_options[:environment])).process_for_cli
-        puts "Job ##{job_id} deleted."
-      end
-
-    end
-  end
-end

data/lib/zencoder/cli/commands/outputs.rb

@@ -1,23 +0,0 @@
-module ZencoderCLI::Command
-  class Outputs < Base
-
-    provides "outputs", { "outputs:progress" => "Show output progress" }
-
-    class << self
-
-      def progress(args, global_options, command_options)
-        output = Zencoder::Output.progress(args.shift, :base_url => Zencoder.base_url(global_options[:environment])).process_for_cli.body
-        rows = []
-        rows << ["State", output["state"].titleize]
-        if output["state"] == "processing"
-          rows << ["Event", output["current_event"].titleize]
-          rows << ["Progress", output["progress"]]
-        elsif output["state"] == "finished"
-          rows << ["Progress", "100%"]
-        end
-        puts table([{ :value => "Output", :colspan => 2 }], *rows)
-      end
-
-    end
-  end
-end

data/lib/zencoder/cli/commands/plugins.rb

@@ -1,43 +0,0 @@
-module ZencoderCLI::Command
-  class Plugins < Base
-
-    provides "plugins", { "plugins:list" => "Lists installed plugins",
-                          "plugins:install" => "Install a plugin via URL",
-                          "plugins:uninstall" => "Uninstall a plugin" }
-
-    class << self
-
-      def list(args, global_options, command_options)
-        if ZencoderCLI::Plugin.list.any?
-          puts "The following plugins are installed:"
-          ZencoderCLI::Plugin.list.each do |plugin|
-            display "* #{plugin}"
-          end
-        else
-          display "There are no plugins installed."
-        end
-      end
-
-      def install(args, global_options, command_options)
-        plugin = ZencoderCLI::Plugin.new(args.shift)
-        if plugin.install
-          begin
-            ZencoderCLI::Plugin.load_plugin(plugin.name)
-          rescue Exception => e
-            installation_failed(plugin, e.message)
-          end
-          display "#{plugin} installed."
-        else
-          error "Could not install #{plugin}. Please check the URL and try again."
-        end
-      end
-
-      def uninstall(args, global_options, command_options)
-        plugin = ZencoderCLI::Plugin.new(args.shift)
-        plugin.uninstall
-        display "#{plugin} uninstalled."
-      end
-
-    end
-  end
-end

data/lib/zencoder/cli/commands/setup.rb

@@ -1,72 +0,0 @@
-require 'fileutils'
-require 'yaml'
-
-module ZencoderCLI::Command
-  class Setup < Base
-
-    provides "setup", { "setup"        => "Caches authentication credentials",
-                        "setup:show"   => "Shows your API keys",
-                        "setup:delete" => "Removes cached credentials and plugins" }
-
-    class << self
-
-      def run(args, global_options, command_options)
-        display("Enter Your Zencoder API Key: ", false)
-        save_api_key(global_options[:environment], ask)
-        display "Your API key has been saved to #{home_directory}/.zencoder/api-key."
-      end
-
-      def show(args, global_options, command_options)
-        if File.exist?("#{home_directory}/.zencoder/api-key")
-          keys = YAML.load_file("#{home_directory}/.zencoder/api-key")
-          if keys.length == 1
-            display("Your API Key: ", false)
-            puts keys.values.first
-          else
-            display("Your API Keys: ")
-            puts table(nil, *keys.to_a)
-          end
-        else
-          display("You have no API keys stored. Run `zencoder setup` to get started.")
-        end
-      end
-
-      def delete(args, global_options, command_options)
-        if confirm
-          delete_setup
-          display "#{home_directory}/.zencoder has been removed."
-        else
-          display "Ok, nothing changed."
-        end
-      end
-
-
-    protected
-
-      def save_api_key(environment, api_key)
-        environment = "production" if !environment || environment.blank?
-        begin
-          FileUtils.mkdir_p("#{home_directory}/.zencoder")
-          if File.exist?("#{home_directory}/.zencoder/api-key")
-            key_envs = YAML.load_file("#{home_directory}/.zencoder/api-key")
-          else
-            key_envs = {}
-          end
-          key_envs[environment] = api_key
-          File.open("#{home_directory}/.zencoder/api-key", 'w') do |out|
-            YAML.dump(key_envs, out)
-          end
-          FileUtils.chmod 0700, "#{home_directory}/.zencoder"
-          FileUtils.chmod 0600, "#{home_directory}/.zencoder/api-key"
-        rescue Exception => e
-          raise e
-        end
-      end
-
-      def delete_setup
-        FileUtils.rm_rf("#{home_directory}/.zencoder") if File.exist?("#{home_directory}/.zencoder")
-      end
-
-    end
-  end
-end

data/lib/zencoder/cli/helpers.rb

@@ -1,61 +0,0 @@
-# Thank you Heroku gem.
-
-module ZencoderCLI
-  module Helpers
-
-    def home_directory
-      running_on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
-    end
-
-    def running_on_windows?
-      RUBY_PLATFORM =~ /mswin32|mingw32/
-    end
-
-    def running_on_a_mac?
-      RUBY_PLATFORM =~ /-darwin\d/
-    end
-
-    def format_date(date)
-      date = Time.parse(date) if date.is_a?(String)
-      date.strftime("%Y-%m-%d %H:%M %Z")
-    end
-
-    def display(msg, newline=true)
-      if newline
-        puts(msg)
-      else
-        print(msg)
-        STDOUT.flush
-      end
-    end
-
-    def error(msg)
-      STDERR.puts(msg)
-      exit 1
-    end
-
-    def confirm(message="Are you sure you wish to continue? (y/N)?")
-      display("#{message} ", false)
-      ask.downcase == 'y'
-    end
-
-    def ask
-      gets.strip
-    rescue Interrupt
-      puts
-      exit
-    end
-
-    def truncate(text, *args)
-      options = args.extract_options!
-      options.reverse_merge!(:length => 30, :omission => "...")
-
-      if text
-        l = options[:length] - options[:omission].mb_chars.length
-        chars = text.mb_chars
-        (chars.length > options[:length] ? chars[0...l] + options[:omission] : text).to_s
-      end
-    end
-
-  end
-end

data/lib/zencoder/cli/plugin.rb

@@ -1,76 +0,0 @@
-# based on the Rails Plugin
-
-module ZencoderCLI
-  class Plugin
-    class << self
-      include ZencoderCLI::Helpers
-    end
-
-    attr_reader :name, :uri
-
-    def self.directory
-      File.expand_path("#{home_directory}/.zencoder/plugins")
-    end
-
-    def self.list
-      Dir["#{directory}/*"].sort.map do |folder|
-        File.basename(folder)
-      end
-    end
-
-    def self.load!
-      list.each do |plugin|
-        begin
-          load_plugin(plugin)
-        rescue Exception => e
-          display "Unable to load plugin: #{plugin}: #{e.message}"
-        end
-      end
-    end
-
-    def self.load_plugin(plugin)
-      folder = "#{self.directory}/#{plugin}"
-      $: << "#{folder}/lib"    if File.directory? "#{folder}/lib"
-      load "#{folder}/init.rb" if File.exists?  "#{folder}/init.rb"
-    end
-
-    def initialize(uri)
-      @uri = uri
-      guess_name(uri)
-    end
-
-    def to_s
-      name
-    end
-
-    def path
-      "#{self.class.directory}/#{name}"
-    end
-
-    def install
-      FileUtils.mkdir_p(path)
-      Dir.chdir(path) do
-        system("git init -q")
-        if !system("git pull #{uri} -q")
-          FileUtils.rm_rf path
-          return false
-        end
-      end
-      true
-    end
-
-    def uninstall
-      FileUtils.rm_r path if File.directory?(path)
-    end
-
-
-  private
-
-    def guess_name(url)
-      @name = File.basename(url)
-      @name = File.basename(File.dirname(url)) if @name.empty?
-      @name.gsub!(/\.git$/, '') if @name =~ /\.git$/
-    end
-
-  end
-end

data/lib/zencoder/cli/response.rb

@@ -1,18 +0,0 @@
-class Zencoder
-  class Response < Zencoder
-
-    def process_for_cli
-      if success?
-        self
-      else
-        if errors.any?
-          puts "Errors:\n#{errors.map{|error| "* "+error }.join("\n")}"
-        else
-          puts "ERROR\n-----\n\n#{body}\n\nHTTP Response Code\n------------------\n#{code}"
-        end
-        exit(1)
-      end
-    end
-
-  end
-end

data/lib/zencoder/cli.rb

@@ -1,71 +0,0 @@
-require 'rubygems'
-begin
-  gem 'trollop', '~> 1.16.2'
-  gem 'terminal-table', '~> 1.4.2'
-  require 'trollop'
-  require 'terminal-table/import'
-rescue LoadError
-  puts "You must install the trollop gem (~> 1.16.2) and the terminal-table gem (~> 1.4.2) to use the Zencoder CLI."
-  exit 1
-end
-
-require 'zencoder'
-require 'zencoder/cli/helpers'
-require 'zencoder/cli/auth'
-require 'zencoder/cli/plugin'
-require 'zencoder/cli/command'
-require 'zencoder/cli/response'
-ZencoderCLI::Plugin.load!
-
-global_options = Trollop::options do
-  version "Zencoder #{Zencoder::GEM_VERSION}"
-  banner <<-EOS
-#{"-" * (14 + Zencoder::GEM_VERSION.length)}
-Zencoder CLI v#{Zencoder::GEM_VERSION}
-#{"-" * (14 + Zencoder::GEM_VERSION.length)}
-
-== Usage
-
-zencoder [global-options] command [command-options]
-
-== Available Commands
-
-#{
-  ZencoderCLI::Command.commands.sort.map{|group, commands|
-    commands.map{|command, description|
-      command.ljust(22)+" # "+(description.is_a?(String) ? description : description[:description])
-    }.join("\n")
-  }.join("\n\n")
-}
-
-== Global Options
-EOS
-  opt :environment, "Sets the environment to use (optional: defaults to production)", :type => String
-  stop_on ZencoderCLI::Command.commands.map{|k, v| v.keys }.flatten
-end
-
-if ARGV.empty?
-  puts "You must specify a command. Use --help for more information."
-  exit(1)
-end
-
-command = ARGV.shift.strip
-args = ARGV
-
-
-flat_commands = ZencoderCLI::Command.commands.values.inject({}){|memo,group| memo.merge!(group) }
-command_options = Trollop::options do
-  banner <<-EOS
-== Usage
-
-zencoder [global-options] #{command} [options]
-
-== Command Options
-EOS
-  if flat_commands[command] && flat_commands[command][:options]
-    flat_commands[command][:options].call(self)
-  end
-end
-
-
-ZencoderCLI::Command.run(command, args, global_options, command_options)