telestream_cloud 1.1.0 → 2.0.0.1

data/lib/telestream_cloud/proxies/scope.rb

@@ -1,94 +0,0 @@
-require 'forwardable'
-
-module TelestreamCloud
-  class Scope < Proxy
-    extend Forwardable
-
-    def respond_to?(method)
-      scoped_methods = [].methods.map{|i| i.to_sym} - non_delegate_methods + [:reload, :non_delegate_methods]
-      !(scoped_methods).include?(method.to_sym)
-    end
-
-    def non_delegate_methods
-       [:nil?, :send, :object_id, :respond_to?, :class, :find, :find_by, :create, :create!, :all, :factory, :connection]
-    end
-
-    def initialize(parent, klass)
-      super
-
-      initialize_scope_attributes
-      initialize_scopes
-    end
-
-    # Overide the function to set the factory_id as the same as the scope
-    def find_by_path(url, map={})
-      object = find_object_by_path(url, map)
-
-      if object.is_a?(Array)
-        object.map{|o| klass.new(o.merge('factory_id' => factory.id))}
-      elsif object['id']
-        klass.new(object.merge('factory_id' => factory.id))
-      else
-        raise APIError.new(object)
-      end
-    end
-
-    def create(attributes)
-      scoped_attrs = attributes.merge(@scoped_attributes)
-      super(scoped_attrs)
-    end
-
-    def create!(attributes)
-      scoped_attrs = attributes.merge(@scoped_attributes)
-      super(scoped_attrs)
-    end
-
-    def all(attributes={})
-      @scoped_attributes.merge!(attributes)
-      trigger_request
-    end
-
-    def reload
-      @found = trigger_request
-    end
-    
-    private
-
-    def initialize_scope_attributes
-      @scoped_attributes={}
-      if @parent.is_a?(TelestreamCloud::Resource)
-        @scoped_attributes[parent_relation_name.to_sym] = @parent.id
-      end
-    end
-
-    def proxy_found
-      @found ||= trigger_request
-    end
-
-    def initialize_scopes
-      ([].methods + [:to_json]).each do |m|
-        unless m.to_s =~ /^__/ || non_delegate_methods.include?(m.to_sym)
-          self.class.class_eval do
-            def_delegators :proxy_found, m.to_sym
-          end
-        end
-      end
-    end
-
-    def trigger_request
-      if @parent.is_a?(Resource)
-        path = build_hash_many_path(many_path, parent_relation_name)
-      else
-        path = many_path
-      end
-
-      find_by_path(path, @scoped_attributes)
-    end
-
-    def parent_relation_name
-      "#{@parent.class.sti_name.downcase}_id"
-    end
-    
-  end
-end
-

data/lib/telestream_cloud/proxies/video_scope.rb

@@ -1,28 +0,0 @@
-module TelestreamCloud
-  class VideoScope < Scope
-
-    def initialize(parent)
-      super(parent, Video)
-    end
-
-    def non_delegate_methods
-      super + [:status, :page, :per_page]
-    end
-
-    def page(this_page)
-      @scoped_attributes[:page] = this_page
-      self
-    end
-
-    def per_page(this_per_page)
-      @scoped_attributes[:per_page] = this_per_page
-      self
-    end
-
-    def status(this_status)
-      @scoped_attributes[:status] = this_status
-      self
-    end
-
-  end
-end

data/lib/telestream_cloud/resources/encoding.rb

@@ -1,47 +0,0 @@
-module TelestreamCloud
-  class Encoding < Resource
-    include VideoState
-
-    belongs_to :video
-    has_one :profile
-
-    class << self
-      def first
-        EncodingScope.new(self).per_page(1).first
-      end
-    end
-
-    def url(options={})
-      default_options = {:https => false}
-      options = default_options.merge(options)
-      full_path = "#{path}#{extname}"
-      get_url(full_path, options[:https]) if files.include?(full_path)
-    end
-    
-    def urls(options={})
-      default_options = {:https => false}
-      options = default_options.merge(options)
-      files.map {|f| get_url(f, options[:https])}
-    end
-
-    def screenshots(options={})
-      default_options = {:https => false}
-      options = default_options.merge(options)
-      ((1..7).map{|i| get_url("#{path}_#{i}.jpg", options[:https])} if success?) || []
-    end
-
-    def cancel
-      connection.post("/encodings/#{id}/cancel.json")['canceled']
-    end
-
-    def retry
-      connection.post("/encodings/#{id}/retry.json")['retried']
-    end
-
-    private
-
-    def get_url(end_path, https)
-      "#{https ? factory.https_url : factory.url}#{end_path}"
-    end
-  end
-end

data/lib/telestream_cloud/resources/factory.rb

@@ -1,72 +0,0 @@
-module TelestreamCloud
-  class Factory < Base
-    include TelestreamCloud::Updatable
-    
-    attr_reader :connection
-
-    def initialize(attributes={})
-      super(attributes)
-      connection_params = TelestreamCloud.connection.to_hash.merge!(:factory_id => id)
-      @connection = Connection.new(connection_params)
-      TelestreamCloud.factories[id] = self
-    end
-
-    class << self
-
-      def connection
-        TelestreamCloud.connection
-      end
-      
-      private
-
-      def build_resource(attributes)
-        resource = TelestreamCloud::Factory.new(attributes)
-      end
-    end
-
-    def https_url
-      uri = URI.parse(url)
-      uri.scheme = "https"
-      uri.to_s
-    end
-
-    def eu?
-      region == "eu"
-    end
-
-    def us?
-      region == "us"
-    end
-
-    def region
-      return 'eu' if connection.api_host == TelestreamCloud::EU_API_HOST
-      return 'us' if connection.api_host == TelestreamCloud::US_API_HOST
-      return 'gce' if connection.api_host == TelestreamCloud::GCE_API_HOST
-    end
-
-    def videos
-      VideoScope.new(self)
-    end
-
-    def encodings
-      EncodingScope.new(self)
-    end
-
-    def profiles
-      ProfileScope.new(self)
-    end
-
-    def method_missing(method_symbol, *arguments)
-      lazy_load
-      super
-    end
-
-    private 
-    
-    def lazy_load
-      reload unless @loaded
-    end
-
-  end
-end
-

data/lib/telestream_cloud/resources/profile.rb

@@ -1,22 +0,0 @@
-module TelestreamCloud
-  class Profile < Resource
-    include TelestreamCloud::Updatable
-
-    has_many :encodings
-
-    def preset?
-      !preset_name
-    end
-
-    # override attributes command and preset_name
-    # to ovoid <method undefined> when profile is a preset or not
-    def command
-      @attributes['command']
-    end
-
-    def preset_name
-      @attributes['preset_name']
-    end
-
-  end
-end

data/lib/telestream_cloud/resources/resource.rb

@@ -1,48 +0,0 @@
-module TelestreamCloud
-  class Resource < Base
-    include TelestreamCloud::Destroyers
-    include TelestreamCloud::Associations
-    include TelestreamCloud::FactoryConnection
-
-    def initialize(attributes={})
-      super(attributes)
-      @attributes['factory_id'] ||= TelestreamCloud.factory.id
-    end
-
-    class << self
-      include TelestreamCloud::FactoryConnection
-
-      def factory
-        TelestreamCloud.factory
-      end
-
-      # delegate to the scope if the method exists
-      def method_missing(method_symbol, *args, &block)
-        scope = TelestreamCloud::const_get("#{sti_name}Scope").new(self)
-        if scope.respond_to?(method_symbol)
-           scope.send(method_symbol, *args, &block)
-        else
-          super
-        end
-      end
-
-    end
-
-    def factory
-      TelestreamCloud.factories[factory_id]
-    end
-
-    def reload
-      perform_reload("factory_id" => factory_id)
-      reset_associations
-      self
-    end
-
-    private
-
-    def load_and_reset(response)
-      load_response(response.merge('factory_id' => factory.id))
-    end
-
-  end
-end

data/lib/telestream_cloud/resources/video.rb

@@ -1,39 +0,0 @@
-module TelestreamCloud
-  class Video < Resource
-    include VideoState
-    has_many :encodings
-
-    class << self
-      def first
-        VideoScope.new(self).per_page(1).first
-      end
-    end
-
-    def metadata
-      connection.get("/videos/#{id}/metadata.json")
-    end
-
-    def delete_source
-      connection.delete("/videos/#{id}/source.json")
-    end
-
-    def preview_url(options={})
-      default_options = {:https => false}
-      options = default_options.merge(options)
-      get_url("#{path}_1.jpg", options[:https]) if success?
-    end
-
-    def url(options={})
-      default_options = {:https => false}
-      options = default_options.merge(options)
-      get_url("#{path}#{extname}", options[:https]) if success?
-    end
-
-    private
-
-    def get_url(end_path, https)
-      "#{https ? factory.https_url : factory.url}#{end_path}"
-    end
-
-  end
-end

data/lib/telestream_cloud/telestream_cloud.rb

@@ -1,69 +0,0 @@
-module TelestreamCloud
-
-  extend self
-  extend Forwardable
-
-  attr_reader :factory, :factories
-  attr_reader :connection
-
-  def_delegators :connection, :get, :post, :put, :delete, :api_url, :setup_bucket, :signed_params
-
-  RESOURCES = {
-    flip: TelestreamCloud::Flip
-  }
-
-  def configure(auth_params=nil, &block)
-    raise ArgumentError, "missing auth params or block" unless auth_params || block_given?
-
-    if !auth_params
-      config = Config.new
-      if (block.arity > 0)
-        block.call(config)
-      else
-        config.instance_eval(&block)
-      end
-    elsif auth_params.is_a?(String)
-      config = Config.from_panda_url(auth_params)
-    else
-      config = Config.from_hash(auth_params)
-    end
-
-    configure_with_auth_params(config)
-    true
-  end
-
-  def configure_heroku
-    configure_with_auth_params Config.from_panda_url(ENV['PANDASTREAM_URL'])
-    true
-  end
-
-  def connect!(auth_params)
-    @connection = Connection.new(auth_params)
-  end
-
-  def connection
-    raise TelestreamCloud::ConfigurationError, "Telestream Cloud is not configured!" unless @connection
-    @connection
-  end
-
-  def default_adapter=(adapter_name)
-    @adapter = adapter_name.to_sym
-  end
-
-  def default_adapter
-    @adapter
-  end
-
-  def resources(resource_name)
-    RESOURCES[resource_name].new
-  end
-  
-  private
-
-  def configure_with_auth_params(config)
-    config.validate!
-    connect!(config.to_hash)
-    @factories = {}
-    @factory = Factory::new(:id => @connection.factory_id)
-  end
-end

data/lib/telestream_cloud/upload_session.rb

@@ -1,40 +0,0 @@
-module TelestreamCloud
-  class UploadSession
-    attr_reader :uploader
-
-    def initialize(file_name, options = {})
-      @uploader = Uploader.new(options.merge(file: File.new(file_name)))
-    end
-
-    def error_message
-      uploader.error && uploader.error.message
-    end
-
-    def start(_ = nil)
-      uploader.upload
-    end
-
-    def status
-      uploader.status.to_s
-    end
-
-    def resume
-      start
-    end
-
-    def video
-      uploader.video
-    end
-
-    def file_name
-      uploader.reader.name
-    end
-
-    def file_size
-      uploader.reader.size
-    end
-
-    def abort
-    end
-  end
-end