optimizeplayer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f50c14cf61e2c561dbc3b3b8310c231d2e6e1652
+  data.tar.gz: 2b6daaac6d8e5216100e9493f66479fbf300690b
+SHA512:
+  metadata.gz: c0bfd170656005386f7fdf8f6af7862889f2519e627e3e5579f9cea34a6d7542e7d3e4d8e23f16ed26472ce47620c6031021ad5a02b087140af51d0c0110fa23
+  data.tar.gz: 9d80be4410dc108070136edcb6215d29106377e052fa9851f462256ab0eeb9af73b86f1d31b7e71680110415ede6857d6dbca8d9b3b7ae60c43d00285d7fef9b

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.10.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in optimize_player.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 OptimizePlayer, Inc
+
+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.md

@@ -0,0 +1,26 @@
+# OptimizePlayer
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'optimizeplayer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install optimizeplayer
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/optimizeplayer/optimizeplayer-ruby.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "optimize_player"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/optimize_player.rb

@@ -0,0 +1,45 @@
+# Version
+require "optimize_player/version"
+
+require 'cgi'
+require 'set'
+require 'openssl'
+require 'rack/utils'
+require 'rest_client'
+require 'json'
+
+require 'optimize_player/client'
+require 'optimize_player/converter'
+require 'optimize_player/signer'
+
+# Proxies
+require 'optimize_player/proxies/base_proxy'
+require 'optimize_player/proxies/account_proxy'
+require 'optimize_player/proxies/folder_proxy'
+require 'optimize_player/proxies/project_proxy'
+require 'optimize_player/proxies/asset_proxy'
+require 'optimize_player/proxies/integration_proxy'
+
+# Resources
+require 'optimize_player/api_object'
+require 'optimize_player/account'
+require 'optimize_player/folder'
+require 'optimize_player/project'
+require 'optimize_player/asset'
+require 'optimize_player/integration'
+require 'optimize_player/media_info'
+require 'optimize_player/encoding'
+
+# Errors
+require 'optimize_player/errors/optimize_player_error'
+require 'optimize_player/errors/api_connection_error'
+require 'optimize_player/errors/api_error'
+require 'optimize_player/errors/bad_request'
+require 'optimize_player/errors/connection_error'
+require 'optimize_player/errors/forbidden'
+require 'optimize_player/errors/resource_not_found'
+require 'optimize_player/errors/socket_error'
+require 'optimize_player/errors/unauthorized'
+require 'optimize_player/errors/unhandled_error'
+require 'optimize_player/errors/unprocessable_entity'
+require 'optimize_player/errors/method_not_allowed'

data/lib/optimize_player/account.rb

@@ -0,0 +1,24 @@
+module OptimizePlayer
+  class Account < ApiObject
+    def save(opts={})
+      attrs = {}
+      @new_data.each do |n|
+        attrs[n] = @data[n]
+      end
+      attrs = attrs.merge(opts)
+
+      if attrs.any?
+        response = context.client.send_request(context.entity_name, :patch, attrs)
+        refresh_from(response)
+      end
+      self
+    end
+
+    def delete(opts={})
+      response = context.client.send_request(context.entity_name, :delete)
+      refresh_from(response)
+      self
+    end
+    alias_method :destroy, :delete
+  end
+end

data/lib/optimize_player/api_object.rb

@@ -0,0 +1,161 @@
+module OptimizePlayer
+  class ApiObject
+    @@permanent_attributes = Set.new([:id, :cid, :object, :created_at, :updated_at])
+
+    attr_reader :context
+
+    def initialize(context, attrs={})
+      @context = context
+      @data = attrs
+      @new_data = Set.new
+    end
+
+    def inspect()
+      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@data)
+    end
+
+    def metaclass
+      class << self; self; end
+    end
+
+    def self.construct_from(context, response)
+      api_object = self.new(context, response)
+      api_object.refresh
+
+      api_object
+    end
+
+    def to_hash
+      @data
+    end
+
+    def keys
+      @data.keys
+    end
+
+    def values
+      @data.values
+    end
+
+    def to_json(*a)
+      JSON.generate(@data)
+    end
+
+    def as_json(*a)
+      @data.as_json(*a)
+    end
+
+    def [](k)
+      @data[k]
+    end
+
+    def []=(k, v)
+      send(:"#{k}=", v)
+    end
+
+    def refresh
+      instance_eval do
+        add_accessors(@data.keys)
+      end
+
+      @data.each do |k, v|
+        @data[k] = Converter.convert_to_object(context, v)
+      end
+
+      self
+    end
+
+    def refresh_from(data)
+      removed = Set.new(@data.keys - data.keys)
+      added = Set.new(data.keys - @data.keys)
+
+      instance_eval do
+        remove_accessors(removed)
+        add_accessors(added)
+      end
+      removed.each do |k|
+        @data.delete(k)
+        @new_data.delete(k)
+      end
+      data.each do |k, v|
+        @data[k] = Converter.convert_to_object(context, v)
+        @new_data.delete(k)
+      end
+    end
+
+    def save(opts={})
+      attrs = {}
+      @new_data.each do |n|
+        attrs[n] = @data[n]
+      end
+      attrs = attrs.merge(opts)
+
+      if attrs.any?
+        response = context.client.send_request("#{context.entity_name}/#{id}", :patch, attrs)
+        refresh_from(response)
+      end
+      self
+    end
+
+    def delete(opts={})
+      response = context.client.send_request("#{context.entity_name}/#{id}", :delete)
+      refresh_from(response)
+      self
+    end
+    alias_method :destroy, :delete
+
+    def method_missing(name, *args)
+      if name.to_s.end_with?('=')
+        attr = name.to_s[0...-1].to_sym
+        add_accessors([attr])
+        begin
+          mth = method(name)
+        rescue NameError
+          raise NoMethodError.new("Cannot set #{attr} on this object")
+        end
+        return mth.call(args[0])
+      else
+        return @data[name.to_s] if @data.has_key?(name.to_s)
+      end
+
+      super
+    end
+
+    def respond_to_missing?(symbol, include_private = false)
+      @data.has_key?(symbol) || super
+    end
+
+    def add_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if @@permanent_attributes.include?(k.to_sym)
+          k_eq = :"#{k}="
+          define_method(k) { @data[k] }
+          define_method(k_eq) do |v|
+            if v == ""
+              raise ArgumentError.new(
+                "You cannot set #{k} to an empty string." +
+                "We interpret empty strings as nil in requests." +
+                "You may set #{self}.#{k} = nil to delete the property.")
+            end
+
+            @data[k] = v
+            @new_data.add(k)
+          end
+        end
+      end
+    end
+
+    def remove_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if @@permanent_attributes.include?(k.to_sym)
+          k_eq = :"#{k}="
+          remove_method(k) if method_defined?(k)
+          remove_method(k_eq) if method_defined?(k_eq)
+        end
+      end
+    end
+  end
+end

data/lib/optimize_player/asset.rb

@@ -0,0 +1,5 @@
+module OptimizePlayer
+  class Asset < ApiObject
+
+  end
+end

data/lib/optimize_player/client.rb

@@ -0,0 +1,177 @@
+module OptimizePlayer
+  class Client
+    API_URI = "http://api.optimizeplayer.com/v1/"
+
+    def initialize(access_token, secret_key, api_endpoint=nil)
+      @api_endpoint = api_endpoint || API_URI
+      @access_token = access_token
+      @secret_key = secret_key
+    end
+
+    def account
+      @account ||= OptimizePlayer::Proxies::AccountProxy.new(self)
+    end
+
+    def projects
+      @projects ||= OptimizePlayer::Proxies::ProjectProxy.new(self)
+    end
+
+    def assets
+      @assets ||= OptimizePlayer::Proxies::AssetProxy.new(self)
+    end
+
+    def folders
+      @folders ||= OptimizePlayer::Proxies::FolderProxy.new(self)
+    end
+
+    def integrations
+      @integrations ||= OptimizePlayer::Proxies::IntegrationProxy.new(self)
+    end
+
+    def send_request(url, method, params = {})
+      headers = {:accept => :json}
+
+      url = @api_endpoint + url + "?access_token=#{@access_token}"
+
+      case method.to_s.downcase.to_sym
+      when :get, :delete
+        url += "#{URI.parse(url).query ? '&' : '?'}#{uri_encode(params)}" if params && params.any?
+        payload = nil
+      else
+        payload = params
+      end
+
+      url = OptimizePlayer::Signer.new.sign_url(url, @secret_key)
+
+      request_opts = {
+        :headers => request_headers.update(headers),
+        :method => method,
+        :open_timeout => 30,
+        :payload => payload,
+        :url => url,
+        :timeout => 80
+      }
+
+      begin
+        response = RestClient::Request.execute(request_opts)
+      rescue RestClient::BadRequest,
+             RestClient::Unauthorized,
+             RestClient::ResourceNotFound,
+             RestClient::Forbidden,
+             RestClient::UnprocessableEntity => e
+
+        json_obj = JSON.parse(e.http_body)
+        error = json_obj['error']
+        message = json_obj['message']
+        error_klass_name = e.class.name.split('::')[-1]
+        error_klass = Object.const_get("OptimizePlayer::Errors::#{error_klass_name}")
+
+        raise error_klass.new(e.http_code, error, message)
+
+      rescue RestClient::MethodNotAllowed => e
+        raise OptimizePlayer::Errors::MethodNotAllowed.new(405, 'MethodNotAllowed', 'Method Not Allowed')
+
+      rescue SocketError => e
+        message = "Unexpected error communicating when trying to connect to OptimizePlayer. " +
+                  "You may be seeing this message because your DNS is not working."
+        raise OptimizePlayer::Errors::SocketError.new(nil, 'NetworkError', message)
+
+      rescue Errno::ECONNREFUSED => e
+        message = "Unexpected error communicating with OptimizePlayer."
+        raise OptimizePlayer::Errors::ConnectionError.new(nil, 'ConnectionError', message)
+
+      rescue RestClient::ServerBrokeConnection, RestClient::RequestTimeout => e
+        message = "Could not connect to OptimizePlayer. " +
+                  "Please check your internet connection and try again."
+        raise OptimizePlayer::Errors::ConnectionError.new(nil, 'ConnectionError', message)
+
+      rescue RestClient::ExceptionWithResponse => e
+        if code = e.http_code and body = e.http_body
+          begin
+            json_obj = JSON.parse(body)
+          rescue JSON::ParserError
+            raise_api_error(code, body)
+          end
+          error = json_obj['error'] || 'error'
+          message = json_obj['message'] || 'Unexpected error'
+
+          raise OptimizePlayer::Errors::ApiError.new(code, error, message)
+        else
+          message = "Unexpected error communicating with OptimizePlayer."
+          raise OptimizePlayer::Errors::UnhandledError.new(nil, 'UnhandledError', message)
+        end
+      end
+
+      begin
+        JSON.parse(response.body)
+      rescue JSON::ParserError => e
+        raise_api_error(response.code, response.body)
+      end
+    end
+
+    private
+
+      def request_headers
+        headers = {
+          :user_agent => "OptimizePlayer/v1 RubyBindings/#{OptimizePlayer::VERSION}",
+          :content_type => 'application/json'
+        }
+
+        begin
+          headers.update(:x_optimize_player_client_user_agent => JSON.generate(user_agent))
+        rescue => e
+          headers.update(:x_optimize_player_client_raw_user_agent => user_agent.inspect,
+                         :error => "#{e} (#{e.class})")
+        end
+      end
+
+      def raise_api_error(code, body)
+        message = "Invalid response object from API: #{body.inspect}"
+        raise OptimizePlayer::Errors::ApiError.new(code, 'InvalidResponse', message)
+      end
+
+      def uri_encode(params)
+        flatten_params(params).map { |k,v| "#{k}=#{url_encode(v)}" }.join('&')
+      end
+
+      def url_encode(key)
+        URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+      end
+
+      def flatten_params(params)
+        result = []
+        params.each do |key, value|
+          calculated_key = url_encode(key)
+          if value.is_a?(Hash)
+            result += flatten_params(value, calculated_key)
+          elsif value.is_a?(Array)
+            result += flatten_params_array(value, calculated_key)
+          else
+            result << [calculated_key, value]
+          end
+        end
+        result
+      end
+
+      def user_agent
+        @uname ||= get_uname
+        lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+        {
+          :bindings_version => OptimizePlayer::VERSION,
+          :lang => 'ruby',
+          :lang_version => lang_version,
+          :platform => RUBY_PLATFORM,
+          :publisher => 'optimizeplayer',
+          :uname => @uname
+        }
+
+      end
+
+      def get_uname
+        `uname -a 2>/dev/null`.strip if RUBY_PLATFORM =~ /linux|darwin/i
+      rescue Errno::ENOMEM => ex
+        "uname lookup failed"
+      end
+  end
+end