unimatrix-activist 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a3591cde5aa039445f5a07e48b3fc9818d9aed0a
+  data.tar.gz: abd4244b737b74776b35ff975f1e18144188c88e
+SHA512:
+  metadata.gz: b31c75f458bd14949e9ef6b434b7931b853c4044686ea6e1a9b33d85e3ff0cfeffd144f86bf33211bceee3b1fd07520a73609dc8a7d80f770b0d921488875e8b
+  data.tar.gz: 608b86df4e8fbf05bcbfdb44281c4098c2939e97cb8eff47082c9f9fcba4eaa1d8e958707b5531ed24781ebed0a344e97a50e59eb52cf1e21d7958b584ba7e1e

data/lib/unimatrix-activist.rb

@@ -0,0 +1,21 @@
+require 'active_support'
+require 'active_support/all'
+require 'fnv'
+
+require 'unimatrix/activist/version'
+
+require 'unimatrix/activist/configuration'
+require 'unimatrix/activist/operation'
+require 'unimatrix/activist/request'
+require 'unimatrix/activist/response'
+require 'unimatrix/activist/parser'
+require 'unimatrix/activist/serializer'
+
+require 'unimatrix/activist/resources/base'
+require 'unimatrix/activist/resources/error'
+require 'unimatrix/activist/resources/activity'
+require 'unimatrix/activist/resources/task'
+
+require 'unimatrix/activist/resources/stream_clip_creation_activity'
+require 'unimatrix/activist/resources/stream_clip_creation_task'
+require 'unimatrix/activist/resources/video_ingestion_task'

data/lib/unimatrix/activist/configuration.rb

@@ -0,0 +1,32 @@
+require 'singleton'
+
+module Unimatrix::Activist
+
+  def self.configuration( &block )
+    Configuration.instance().instance_eval( &block ) unless block.nil?
+    Configuration.instance()
+  end
+
+  class Configuration
+    include Singleton
+
+    def self.field( field_name, options={} )
+      class_eval(
+        "def #{ field_name }( *arguments ); " +
+           "@#{ field_name } = arguments.first unless arguments.empty?; " +
+           "@#{ field_name } || " +
+             ( options[ :default ].nil? ?
+                "nil" :
+                ( options[ :default ].is_a?( String ) ?
+                    "'#{ options[ :default ] }'" :
+                      "#{ options[ :default ] }" ) ) + ";" +
+        "end",
+        __FILE__,
+        __LINE__
+      )
+    end
+
+    field :url,              default: ENV[ 'ACTIVIST_URL' ]
+  end
+
+end

data/lib/unimatrix/activist/operation.rb

@@ -0,0 +1,143 @@
+module Unimatrix::Activist
+
+  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
+      Request.new.tap do | request |
+        response = request.destroy( @path, @parameters )
+        if response.present?
+          result = response.resources
+        end
+      end
+      result
+    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
+      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 if result.present? && result.is_a?( Array )
+        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
+      Request.new.tap do | request |
+        serializer = Unimatrix::Activist::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  )
+      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/unimatrix/activist/parser.rb

@@ -0,0 +1,157 @@
+module Unimatrix::Activist
+
+  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 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 parse_resource( name, attributes )
+      @resources_mutex ||= Hash.new { | hash, key | hash[ key ] = [] }
+      object_key = attributes[ key ]
+
+      # Lock the resource index for this name/key combination
+      # This prevents objects that are associated with
+      # themselves from causing a stack overflow
+      return nil if @resources_mutex[ name ].include?( object_key )
+
+      @resources_mutex[ name ].push( object_key )
+      resource = nil
+
+      if attributes.present?
+        class_name = name.singularize.camelize
+        object_class = Unimatrix::Activist.const_get( class_name ) rescue nil
+
+        if object_class.present?
+          relations = name == self.name ?
+                        self.parse_associations( attributes ) : []
+          resource = object_class.new( attributes, relations )
+        end
+        @resources_mutex[ name ].delete( object_key )
+      end
+      resource
+    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 Unimatrix::Activist 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 = ( Unimatrix::Activist.const_get( type_name.camelize ) rescue nil ) \
+            if type_name.present?
+          if klass.nil?
+            type_name = options[ 'type_name' ]
+            klass = ( Unimatrix::Activist.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/unimatrix/activist/request.rb

@@ -0,0 +1,62 @@
+require 'net/http'
+require 'addressable/uri'
+
+module Unimatrix::Activist
+
+  class Request
+
+    def initialize( default_parameters = {} )
+      uri   = URI( Unimatrix::Activist.configuration.url )
+      @http = Net::HTTP.new( uri.host, uri.port )
+
+      @http.use_ssl = ( uri.scheme == 'https' )
+      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      @default_parameters = default_parameters.stringify_keys
+    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/unimatrix/activist/resources/activity.rb

@@ -0,0 +1,20 @@
+module Unimatrix::Activist
+
+  class Activity < Base
+    field    :id
+    field    :type_name
+    field    :subject_id
+    field    :subject_type
+    field    :state
+    field    :message
+    field    :properties
+    field    :completed_at
+    field    :destroyed_at
+    field    :created_at
+    field    :updated_at
+    field    :execute_at
+
+    has_many :task
+  end
+
+end

data/lib/unimatrix/activist/resources/base.rb

@@ -0,0 +1,70 @@
+module Unimatrix::Activist
+
+  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( /Unimatrix::Activist::/, '' ).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/unimatrix/activist/resources/error.rb

@@ -0,0 +1,8 @@
+module Unimatrix::Activist
+
+  class Error < Base
+    field :code
+    field :message
+  end
+
+end

data/lib/unimatrix/activist/resources/stream_clip_creation_activity.rb

@@ -0,0 +1,12 @@
+module Unimatrix::Activist
+
+  class StreamClipCreationActivity < Activity
+    field       :in_point
+    field       :out_point
+    field       :clip_name
+    field       :original_stream_id
+    field       :video_file_url
+    field       :video_id
+  end
+
+end

data/lib/unimatrix/activist/resources/stream_clip_creation_task.rb

@@ -0,0 +1,11 @@
+module Unimatrix::Activist
+
+  class StreamClipCreationTask < Task
+    field       :in_point
+    field       :clip_name
+    field       :video_file_url
+    field       :out_point
+    field       :original_stream_id
+  end
+
+end

data/lib/unimatrix/activist/resources/task.rb

@@ -0,0 +1,21 @@
+module Unimatrix::Activist
+
+  class Task < Base
+    field   :id
+    field   :type_name
+    field   :subject_id
+    field   :activity_id
+    field   :subject_type
+    field   :state
+    field   :message
+    field   :properties
+    field   :execute_at
+    field   :started_at
+    field   :ended_at
+    field   :created_at
+    field   :updated_at
+
+    has_one :activity
+  end
+
+end

data/lib/unimatrix/activist/resources/video_ingestion_task.rb

@@ -0,0 +1,9 @@
+module Unimatrix::Activist
+
+  class VideoIngestionTask < Task
+    field       :video_id
+    field       :clip_name
+    field       :video_file_url
+  end
+
+end

data/lib/unimatrix/activist/response.rb

@@ -0,0 +1,44 @@
+module Unimatrix::Activist
+
+  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 ) )
+        Parser.new( @body ) do | parser |
+          @resources = parser.resources
+          @success   = !( parser.type_name == 'error' )
+        end
+      else
+        @success  = false
+        @resources << Error.new(
+          message: "#{ @code }: #{ http_response.message }."
+        )
+      end
+    end
+
+    def success?
+      @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/unimatrix/activist/serializer.rb

@@ -0,0 +1,31 @@
+module Unimatrix::Activist
+
+  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( /Unimatrix::Activist/, '' ).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/unimatrix/activist/version.rb

@@ -0,0 +1,5 @@
+module Unimatrix
+  module Activist
+    VERSION = "1.0.0"
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: unimatrix-activist
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Matthew Yang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-23 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
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The unimatrix-activist facilitates making requests to the Unimatrix Activist
+  application
+email:
+- matthewyang@sportsrocket.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/unimatrix-activist.rb
+- lib/unimatrix/activist/configuration.rb
+- lib/unimatrix/activist/operation.rb
+- lib/unimatrix/activist/parser.rb
+- lib/unimatrix/activist/request.rb
+- lib/unimatrix/activist/resources/activity.rb
+- lib/unimatrix/activist/resources/base.rb
+- lib/unimatrix/activist/resources/error.rb
+- lib/unimatrix/activist/resources/stream_clip_creation_activity.rb
+- lib/unimatrix/activist/resources/stream_clip_creation_task.rb
+- lib/unimatrix/activist/resources/task.rb
+- lib/unimatrix/activist/resources/video_ingestion_task.rb
+- lib/unimatrix/activist/response.rb
+- lib/unimatrix/activist/serializer.rb
+- lib/unimatrix/activist/version.rb
+homepage: http://sportsrocket.com
+licenses:
+- MIT
+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.4.6
+signing_key: 
+specification_version: 4
+summary: Unimatrix::Activist is used to communicate with Activist.
+test_files: []