zephyrus 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d767155594140e1d9015b8719daef8a282b9b923
+  data.tar.gz: 65da044b30406b4867358ea7ec5ce9cd8aa4e196
+SHA512:
+  metadata.gz: b2ab7e5dee75cb06be4ab5e2068ea6c840c0f97d7f6645c4621c9894de45cc6f7116b2e7506e1804ba746818b9663e0dc48a589792debf099cd38975ece296a8
+  data.tar.gz: 72c9705d9e91e571f18c8198909803ebc514f1be962c9870b24a0d55f9119a5c7ee0454d6bdafbdff3c652b6e1751c9dd33f0270e6e38e80bf8cc9dd19fd5743

data/lib/zephyrus/configuration.rb

@@ -0,0 +1,49 @@
+require 'singleton'
+
+module Zephyrus
+
+  def self.configuration( &block )
+    Configuration.instance().instance_eval( &block ) unless block.nil?
+    Configuration.instance()
+  end
+
+  class Configuration
+
+    include Singleton
+
+    def self.reloadable?
+      false
+    end
+
+    def self.define_attribute( attribute_name, options = {} )
+      
+      class_eval(
+        "def #{attribute_name}( *arguments ); " +
+           "@#{attribute_name} = arguments.first unless arguments.empty?; " +
+           "@#{attribute_name} || " +
+             ( options[ :default ].nil? ?
+                "nil" :
+                ( options[ :default ].is_a?( String ) ? 
+                    "'#{options[ :default ]}'" : 
+                      "#{options[ :default ]}" ) ) + ";" +
+        "end",
+        __FILE__, 
+        __LINE__
+      )
+    end
+
+    # the api uri; DO NOT COMMIT A MODIFIED DEFAULT
+    define_attribute :api_uri,      default: 'https://zephyrus.boxxspring.com'
+    define_attribute :api_credentials
+
+    def from_hash( configuration )
+  
+      configuration.each_pair do | name, value |
+        self.instance_variable_set( "@#{name}", value )
+      end
+        
+    end
+
+  end
+
+end

data/lib/zephyrus/operation.rb

@@ -0,0 +1,147 @@
+module Zephyrus
+
+  class Operation 
+
+    def initialize( path, parameters = {} )
+      @path = path 
+      @parameters = ( parameters || {} ).deep_dup
+      @key = nil
+    end
+
+    def key
+      return @key ||= begin
+        result = 0
+        query = @parameters.to_param
+        if ( @path.present? || @query.present? )          
+          query = query.split( '&' ).sort.join( '&' )
+          addressable = Addressable::URI.new      
+          addressable.path = @path 
+          addressable.query = query unless query.blank?
+          result = FNV.new.fnv1a_32( addressable.to_s )
+        end  
+        result     
+      end
+    end
+
+    def where( parameters )
+      self.spawn( parameters )
+    end
+
+    def destroy
+      result = nil
+      Zephyrus::Request.new.tap do | request |
+        response = request.destroy( @path, @parameters )
+        if response.present?
+          result = response.resources
+        end
+      end
+      result
+    end 
+
+    def order( by, direction = 'desc' )
+      self.spawn( sort_by: by, sort_direction: direction )
+    end
+
+    def limit( _limit )
+      self.spawn( count: _limit )
+    end
+
+    def offset( _offset )
+      self.spawn( offset: _offset )
+    end
+
+    def include( *arguments )
+      self.spawn( :include => self.normalize_include( *arguments ) )
+    end
+
+    def query( &block )
+      result = nil
+      Zephyrus::Request.new.tap do | request |
+        request.get( @path, @parameters ).tap do | response |
+          result = response.resources
+          if block_given?
+            case block.arity 
+              when 0; yield 
+              when 1; yield result
+              when 2; yield result, response
+            end
+          end  
+        end
+      end
+      result
+    end
+
+    def read( &block )
+      response = nil
+      result = nil
+      self.query do | _result, _response | 
+        result = _result
+        response = _response 
+      end
+      if response.success? 
+        result = result.first if result.present? && result.is_a?( Enumerable )
+        if block_given?
+          case block.arity 
+            when 0; yield 
+            when 1; yield result
+            when 2; yield result, response
+          end
+        end 
+      end
+      result
+    end
+
+    def write( node, objects, &block )
+      result = nil
+      Zephyrus::Request.new.tap do | request |
+        serializer = Zephyrus::Serializer.new( objects )
+        response = request.post( @path, @parameters, serializer.serialize( node ) )
+        if response.present?
+          result = response.resources
+          if block_given?
+            case block.arity 
+              when 0; yield 
+              when 1; yield result
+              when 2; yield result, response
+            end
+          end        
+        end 
+      end
+      result
+    end
+
+    protected; def spawn( parameters  )
+      Zephyrus::Operation.new( 
+        @path,
+        @parameters.deep_merge( parameters || {} )
+      )
+    end
+
+    protected; def normalize_include( *arguments )
+
+      includes = {}
+      arguments.each do | argument |
+        case argument
+        when Array
+          argument.each do | value  |
+            includes.deep_merge!( self.normalize_include( value ) )
+          end
+        when Hash 
+          argument.each do | key, value |
+            if !includes.include?( key ) || includes[ key ] === true 
+              includes[ key ] = self.normalize_include( value )
+            else
+              includes[ key ].deep_merge!( self.normalize_include( value ) )
+            end
+          end
+        else 
+          includes[ argument ] = true
+        end
+      end
+      includes 
+
+    end
+
+  end
+
+end

data/lib/zephyrus/parser.rb

@@ -0,0 +1,136 @@
+module Zephyrus
+
+  class Parser
+
+    def initialize( content = {} )
+      @content = content
+      yield self if block_given?
+    end
+
+    def name 
+      @content.include?( '$this' ) ?
+        @content[ '$this' ][ 'name' ] :
+        nil
+    end
+
+    def type_name 
+      @content.include?( '$this' ) ?
+        @content[ '$this' ][ 'type_name' ] :
+        nil
+    end
+
+    def type_name?( name )
+      self.type_name == name.to_s 
+    end
+
+    def key
+      'id' 
+    end
+
+    def keys 
+      @content.include?( '$this' ) ?
+        @content[ '$this' ][ 'ids' ] :
+        nil
+    end
+
+    def associations  
+      @content.include?( '$associations' ) ?
+        @content[ '$associations' ] :
+        nil
+    end
+
+    def resources
+      result = nil
+      unless self.name.blank?
+        result = self.keys.map do | key | 
+          self.resource_by( name, key, { 'type_name' => self.type_name } ) 
+        end
+      end
+      result
+    end
+
+    def resource_by( name, key, options = {} )
+
+      @resources_index ||= Hash.new { | hash, key | hash[ key ] = {} }
+      @resource_index_mutex ||= Hash.new { | hash, key | hash[ key ] = [] }
+      
+      @resources_index[ name ][ key ] ||= begin
+
+        # lock the resource index for this name/key combination
+        # note: this prevents zephyrus objects that are associated with  
+        #       themselves from causing a stack overflow
+        return nil if @resource_index_mutex[ name ].include?( key )
+        @resource_index_mutex[ name ].push( key )
+
+        result = nil
+        resource_attributes = resource_attribute_index[ name ][ key ]
+        if resource_attributes.present? 
+          type_name = resource_attributes[ 'type_name' ]
+          klass = nil 
+          klass = ( Zephyrus.const_get( type_name.camelize ) rescue nil ) \
+            if type_name.present?
+          if klass.nil?
+            type_name = options[ 'type_name' ]
+            klass = ( Zephyrus.const_get( type_name.camelize ) rescue nil ) \
+              if type_name.present?
+          end
+          if klass.present?
+            result = klass.new( 
+              resource_attributes, 
+              self.resource_associations_by( name, key ) 
+            )
+          end
+        end
+
+        # unlock the resource index for this name/key combination
+        @resource_index_mutex[ name ].delete( key )
+  
+        result 
+
+      end
+    
+    end
+
+    def resource_associations_by( name, key )
+      result = Hash.new { | hash, key | hash[ key ] = [] }
+      associations = self.associations
+      if associations && associations.include?( name )
+        association = associations[ name ].detect do | association |
+          association[ 'id' ] == key 
+        end
+        if association.present?
+          association.each do | key, value |
+            unless key == 'id'
+              type_name = value[ 'type_name' ]
+              result[ key ] = ( value[ 'ids' ] || [] ).map do | associated_id |
+                self.resource_by( 
+                  key, 
+                  associated_id, 
+                  { 'type_name' => type_name } 
+                )
+              end
+              result[ key ].compact!
+            end
+          end
+        end
+      end 
+      result     
+    end
+
+    def resource_attribute_index 
+      @resource_attribute_index ||= begin 
+        index = Hash.new { | hash, key | hash[ key ] = {} }
+        @content.each do | key, resources_attributes |
+          unless key[0] == '$'
+            resources_attributes.each do | resource_attributes |
+              index[ key ][ resource_attributes[ 'id' ] ] = resource_attributes
+            end
+          end
+        end
+        index
+      end
+    end
+
+  end
+
+end

data/lib/zephyrus/request.rb

@@ -0,0 +1,96 @@
+require 'net/https'
+require 'addressable/uri'
+
+module Zephyrus
+
+  class Request
+
+    def initialize( default_parameters = {} )
+  
+      # parse the API uri
+      uri = URI.parse( Zephyrus.configuration.api_uri )
+
+      # construct http request
+      @http = Net::HTTP.new( uri.host, uri.port )
+      
+      # use ssl when https is the uri scheme                       
+      @http.use_ssl = ( uri.scheme == 'https' )
+      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      # retain the default parameters 
+      @default_parameters = default_parameters.stringify_keys
+  
+    end
+
+    def destroy( path, parameters = {} )
+
+      begin  
+               
+        request = Net::HTTP::Delete.new( 
+          compose_request_path( path, parameters ), 
+          { 'Content-Type' =>'application/json' }
+        )
+
+        response = Response.new( @http.request( request ) )
+        
+      rescue Timeout::Error
+        response = nil
+      end
+
+      response
+    
+    end
+
+    def get( path, parameters = {} )
+  
+      response = nil
+      
+      begin  
+        response = Response.new( 
+          @http.get( compose_request_path( path, parameters ) ) 
+        )
+      rescue Timeout::Error
+        response = nil
+      end
+        
+      response
+                      
+    end
+
+    def post( path, parameters = {}, body = {} )
+  
+      response = nil
+      
+      begin  
+               
+        request = Net::HTTP::Post.new( 
+          compose_request_path( path, parameters ), 
+          { 'Content-Type' =>'application/json' }
+        )
+        request.body = body.to_json
+
+        response = Response.new( @http.request( request ) )
+        
+      rescue Timeout::Error
+        response = nil
+      end
+        
+      response
+                      
+    end
+
+    protected; def compose_request_path( path, parameters = {} )
+
+      parameters = @default_parameters.merge( parameters.stringify_keys )
+      addressable = Addressable::URI.new
+      
+      addressable.path = path 
+      addressable.query = parameters.to_param unless parameters.blank?
+
+      addressable.to_s
+
+    end
+
+  end
+
+end

data/lib/zephyrus/resources/attribute_error.rb

@@ -0,0 +1,7 @@
+module Zephyrus
+  
+  class AttributeError < Error
+    field :attribute
+  end
+
+end

data/lib/zephyrus/resources/base.rb

@@ -0,0 +1,67 @@
+module Zephyrus
+
+  class Base
+
+    class << self
+
+      def inherited( subclass )
+        subclass.fields = {}.merge( self.fields )
+      end
+
+      def field( name, options = {} )
+        
+        self.fields[ name.to_sym ] = options.merge( name: name )
+        
+        class_eval(
+          "def #{name}(); " +
+          "@#{name}.is_a?( FalseClass ) ? @#{name} : (" +
+             "@#{name} || " +
+               ( options[ :default ].nil? ?
+                  "nil" :
+                  ( options[ :default ].is_a?( String ) ? 
+                      "'#{options[ :default ]}'" : 
+                        "#{options[ :default ]}" ) ) + ");" +
+          "end;" +
+          " " +
+          "attr_writer :#{name};",
+          __FILE__, 
+          __LINE__
+        )
+
+      end
+
+      def has_one( name, options = {} )
+        define_method name do 
+          associations = self.instance_variable_get( "@_#{name.to_s.pluralize}" )
+          associations.present? ? associations.first : options[ :default ]
+        end
+      end
+
+      def has_many( name, options = {} )  
+        define_method name do 
+          self.instance_variable_get( "@_#{name}" ) || options[ :default ] || []
+        end
+      end
+
+    end
+
+    class_attribute :fields, instance_writer: false
+    self.fields = {}
+
+    field :type_name
+    has_many  :errors
+
+    def initialize( attributes = {}, associations = {} )
+      self.type_name = self.class.name.gsub( /Zephyrus::/, '' ).underscore
+      attributes.each do | key, value |
+        send( "#{key}=", value ) if respond_to?( "#{key}=" )
+      end
+      associations.each do | key, value |
+        self.instance_variable_set( "@_#{key}", value )
+      end
+      yield self if block_given?
+    end
+
+  end
+
+end

data/lib/zephyrus/resources/error.rb

@@ -0,0 +1,7 @@
+module Zephyrus
+  
+  class Error < Base
+    field :message
+  end
+
+end

data/lib/zephyrus/resources/forbidden_error.rb

@@ -0,0 +1,6 @@
+module Zephyrus
+  
+  class ForbiddenError < Error
+  end
+
+end

data/lib/zephyrus/resources/input.rb

@@ -0,0 +1,13 @@
+module Zephyrus
+  class Input < Base
+    field :id
+    field :created_at
+    field :updated_at
+    field :state
+    field :key
+    field :uid
+    field :uuid
+
+    has_many :outputs
+  end
+end

data/lib/zephyrus/resources/malformed_parameter_error.rb

@@ -0,0 +1,6 @@
+module Zephyrus
+  
+  class MalformedParameterError < Error
+  end
+
+end

data/lib/zephyrus/resources/missing_parameter_error.rb

@@ -0,0 +1,6 @@
+module Zephyrus
+  
+  class MissingParameterError < Error
+  end
+
+end

data/lib/zephyrus/resources/not_found_error.rb

@@ -0,0 +1,6 @@
+module Zephyrus
+  
+  class NotFoundError < Error
+  end
+
+end

data/lib/zephyrus/resources/output.rb

@@ -0,0 +1,12 @@
+module Zephyrus
+  class Output < Base
+    field :id
+    field :created_at
+    field :updated_at
+    field :key
+    field :uid
+    field :uuid
+    field :state
+    field :input_id
+  end
+end

data/lib/zephyrus/resources/recording_output.rb

@@ -0,0 +1,10 @@
+
+module Zephyrus
+  class RecordingOutput < Output
+
+    field :recording
+    field :instance_id
+    field :last_recording_started_at
+
+  end
+end

data/lib/zephyrus/resources/routing_output.rb

@@ -0,0 +1,9 @@
+module Zephyrus
+  class RoutingOutput < Output
+
+    field :url
+    field :authentication_username
+    field :authentication_password
+
+  end
+end

data/lib/zephyrus/resources/transcoding_output.rb

@@ -0,0 +1,13 @@
+
+module Zephyrus
+  class TranscodingOutput < Output
+
+    field :mime_type
+    field :video_bitrate
+    field :audio_bitrate
+    field :height
+    field :width
+    field :audio_sample_rate
+
+  end
+end

data/lib/zephyrus/response.rb

@@ -0,0 +1,51 @@
+module Zephyrus
+
+  class Response
+
+    attr_reader :code
+    attr_reader :body
+    attr_reader :resources 
+    
+    def initialize( http_response )
+
+      @success = http_response.is_a?( Net::HTTPOK )
+
+      @code = http_response.code
+      @resources = []
+
+      @body = decode_response_body( http_response )
+
+      if ( @body && @body.respond_to?( :keys ) )
+        Zephyrus::Parser.new( @body ) do | parser |
+          @resources = parser.resources
+          @success = !parser.type_name?( :error )
+        end
+      else
+        @success = false
+        @resources << Zephyrus::Error.new( 
+          message: "#{@code}: #{http_response.message}."
+        )
+      end
+    end
+
+    def success?
+      @success
+    end
+    
+    def failure?
+      not @success
+    end
+    
+    protected; def decode_response_body( http_response )
+      body = http_response.body
+
+      if body.present?
+        JSON.parse( body ) rescue nil
+      else
+        nil
+      end
+    end
+
+  end
+  
+end

data/lib/zephyrus/serializer.rb

@@ -0,0 +1,31 @@
+module Zephyrus
+
+  class Serializer
+
+    def initialize( payload = [], options = {} )
+      @payload = [ payload ].flatten
+      @options = options
+    end
+
+    def serialize( node, options = {} )
+      result = {}
+      result[ node ] = @payload.map do | object |
+        node_object = {}
+        node_object[ :type_name ] = ( 
+          object.respond_to?( :type_name ) ? 
+            object.type_name :
+            object.class.name.gsub( /Zephyrus::/, '' ).underscore 
+        )
+        if object.respond_to?( :fields )
+          object.fields.each do | name, options | 
+            node_object[ name.to_sym ] = object.send( name )
+          end
+        end
+        node_object
+      end
+      result
+    end
+
+  end
+
+end

data/lib/zephyrus/version.rb

@@ -0,0 +1,3 @@
+module Zephyrus
+  VERSION = '0.1.0'
+end

data/lib/zephyrus.rb

@@ -0,0 +1,28 @@
+require 'active_support'
+require 'active_support/all'
+require 'fnv'
+
+require 'zephyrus/configuration'
+require 'zephyrus/response'
+require 'zephyrus/request'
+require 'zephyrus/parser'
+require 'zephyrus/serializer'
+require 'zephyrus/operation'
+
+require 'zephyrus/resources/base'
+
+# Errors
+require 'zephyrus/resources/error'
+require 'zephyrus/resources/forbidden_error'
+require 'zephyrus/resources/attribute_error'
+require 'zephyrus/resources/missing_parameter_error'
+require 'zephyrus/resources/attribute_error'
+require 'zephyrus/resources/malformed_parameter_error'
+require 'zephyrus/resources/not_found_error'
+
+# Resources
+require 'zephyrus/resources/input'
+require 'zephyrus/resources/output'
+require 'zephyrus/resources/routing_output'
+require 'zephyrus/resources/transcoding_output'
+require 'zephyrus/resources/recording_output'

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: zephyrus
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Asher Kory
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fnv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+description: The zephyrus gem implements a client to the Sportsrocket Zephyrus API
+email: asher@sportsrocket.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/zephyrus.rb
+- lib/zephyrus/configuration.rb
+- lib/zephyrus/operation.rb
+- lib/zephyrus/parser.rb
+- lib/zephyrus/request.rb
+- lib/zephyrus/resources/attribute_error.rb
+- lib/zephyrus/resources/base.rb
+- lib/zephyrus/resources/error.rb
+- lib/zephyrus/resources/forbidden_error.rb
+- lib/zephyrus/resources/input.rb
+- lib/zephyrus/resources/malformed_parameter_error.rb
+- lib/zephyrus/resources/missing_parameter_error.rb
+- lib/zephyrus/resources/not_found_error.rb
+- lib/zephyrus/resources/output.rb
+- lib/zephyrus/resources/recording_output.rb
+- lib/zephyrus/resources/routing_output.rb
+- lib/zephyrus/resources/transcoding_output.rb
+- lib/zephyrus/response.rb
+- lib/zephyrus/serializer.rb
+- lib/zephyrus/version.rb
+homepage: http://sportsrocket.com
+licenses:
+- MS-RL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Sportsrocket SDK for interacting with Zephyrus
+test_files: []