WO2014078318A2

WO2014078318A2 - Resource management system

Info

Publication number: WO2014078318A2
Application number: PCT/US2013/069712
Authority: WO
Inventors: Martin Carl EUERLE
Original assignee: Euerle Martin Carl
Priority date: 2012-11-15
Filing date: 2013-11-12
Publication date: 2014-05-22
Also published as: WO2014078318A3

Abstract

This invention is a method for a Resource Management System (RMS) for managed loading of all Javascript ^TM functions and runtime alterations of all JavaScript ^TMfunctions for a JavaScript ^TM based system.

Description

DESCRIPTION

BACKGROUND OF INVENTION

[0001] The JavaScript language as defined in its specification has only the most basic functionality. However, design patterns can be created to support more complex functionality. While frameworks exist that load functionality and that also load functionality in correct dependency order, there currently does not exist a framework that correctly loads out-of-dependency order functions while also supporting runtime alteration of defined classes. These features are useful for creating a JavaScript code base that 1) supports true object oriented functionality, such as inheritance and interfaces, and 2) that dynamically adds functionality managed by a Resource Management System (RMS) where the RMS is able to monitor and alter functions and yet freeze the functionality to prevent unwanted alterations from being added to core functionality.

[0002] There are several JavaScript frameworks that handle resource loading.

Implementers of CommonJS standards, implementers of the Asynchronous Module Definition (AMD), and RequireJS represent some of the most popular resource load frameworks. In general, they require a configuration to identify the location of the source code and a design pattern that uses globally scoped functions to initiate resource loading, dependency loading and resource usage. These frameworks are limited to loading resources in order and providing correct resolution of their dependencies. RequireJS has an additional capability of un-defining a module, which means a resource is no longer available to the system.

[0003] There are several JavaScript frameworks that handle the alteration of defined and instantiated objects at runtime. In general, they are used as inheritance extending frameworks, such as jQuery, Base2, Js. Class, mootools, ContainerJS, etc. The inheritance frameworks are very strictly limited to providing functionality that copies one objects functions to another object. ContainerJS identifies specific functionality to be added to a specific object. None of these existing JavaScript frameworks include the capability of correctly loading the order of dependencies or allowing a programmer to alter the runtime of defined classes, of which this invention claims.

[0004] As JavaScript applications have become more complex, resolving problems related to managing code resources becomes more critical. Needs currently unmet using existing frameworks include an application's ability to load resources through a single control point, including the ability to validate inheritance, to implement the proper interface at the time of resource loading, and to add and control language features and additional functionality. These unmet needs are what this invention covers.

SUMMARY

[0006] In developing a large JavaScript application, the weaknesses of JavaScript becomes obvious: "truthy" values, poor type definition, and behind the scenes hoisting. These basic and core problems are troublesome but can be overcome by adhering to strict code guidelines. Additional problems include these:

• Prototype inheritance is awkward;

• Interfaces are not supported natively;

• Determining the type of an object is limited to base types only;

• No native ability to centrally manage loaded resources;

• No native ability to load developer code versus optimized code for debugging purposes;

• No native ability to load multiple versions of code objects in separate scopes.

[0007] Complex applications are difficult to create due to a number of missing features in the language:

• clean inheritance implementation

• support for interfaces

• ability to load additional code through a built in API

• ability to determine an object's type

• centrally managed resource loading • multiple choices for source loading (i.e. minified code vs developer code)

• native control for scoping multiple versions of functions.

[0008] Embodiments of the present invention support the development of more complex applications:

• inheritance via metadata definition - code-less design pattern

• interface support via metadata definition - code-less design pattern

• required resources identified via metadata definition

• resource type identification via metadata definition

• fully qualified name-spacing of resources via metadata definition - code-less design pattern

• resource version support via metadata property

• constructor control

• post developer class definition control

• instantiate control

• runtime addition of functions to resource

• resource definition has access to resource references via a single object

• version identification via metadata definition

• runtime identification of source versus minified representations of code

• runtime ability to prevent a class from being altered

[0009] Embodiments of the present invention are intended to solve multiple issues related to programing large, system based JavaScript applications: simplified inheritance support, interface support, system based object creation control, multiple resource version support, common identification for the objects fully qualified name, object manipulation lock down and object metadata.

[0010] In one embodiment, all class based resources are altered to have a common function to determine the fully qualified name of the object, namely a "getClassName" function. [0011] In one embodiment, all class based resources are altered to have a common function to determine if one object is an instance of another object, matching the second object's name and version, namely a "isInstanceOf ' function.

[0011.1] In one embodiment, all class based resources are altered to have a common function to determine if one object is a class of another object, matching the second object's name, namely a "isClassOf ' function.

[0012] In one embodiment, the method creates inheritance at runtime using a named property. As the method loads the resource, the resource can also be verified.

[0013] In one embodiment, the method defines, identifies, implements and verifies interfaces.

[0014] In one embodiment, the method identifies required resources via a named property that loads resources in the correct dependency order and also creates a Resource

Reference containing the required versions of available resources by a specific resource.

[0015] In one embodiment, a named property identifies resource types.

[0016] In one embodiment, the method dynamically creates any object's namespace that the method has identified via a named property in the metadata.

[0017] In one embodiment, the named property in the metadata identifies resource version loading and usage.

[0017.1] In one embodiment, the Resource Function property name can be named such that it identifies its functionality, such as 'Class', 'Instance', 'Module', 'Enum', etc., thus not requiring a separately named property to identify the Resource Function usage. [0017.2] In one embodiment, the prototype inheritance chain is flattened, providing all functionality in a single level of the object prototype.

[0018] In one embodiment, the method creates and controls constructor functions, thereby surrendering control of all aspects of object instantiation to the invention.

[0019] In one embodiment, the invention has control of a resource class, instance, interface, module, genobject, or application after a developer defines these respective resources. The invention can, therefore, alter the resources and lock functionality so that other code cannot alter functionality.

[0020] In one embodiment, the invention provides a single object, a Resource Reference, that provides references to all required resources.

[0021] In one embodiment, version identification is supported, with the ability to substitute and alias name for a fully qualified name.

[0022] In one embodiment, resources can be selected via either URL parameter or configuration to support resource loading of developer-readable code or performance- optimized code. This can greatly improve a developer's ability to resolve issues or enhance code.

[0023] The invention can be implement in many ways, property names in the JavaScript literal can be altered, property names can be omitted, property names can be added for additional runtime functionally enhancements. Object class names and class functions may be altered.

DETAILED DESCRIPTION

[0024] The invention can be implemented in numerous ways: as an application, as a process, as a system, or as a computer network where instructions are sent over communication links. The general order of the process may be altered within the scope of the invention.

Preliminary Information:

[0025] All code samples are for the demonstration of invention concepts. The code could be done in a variety of ways.

[0026] Names of properties are variables and can be changed; name s may be renamed to fullQualifiedName s or some other value. All other properties likewise may be changed.

[0027] Names of functions are variables and may be changed; rms.defme( .... ) may be changed. All other function names likewise may be changed.

[0028] The following Code Sample 1 is a simplified example of how a Resource Unit can be defined separately, then be defined by the RMS.

Code Sample 1 - simplified : var resourceUnit = {

name s {value} ,

version s {value} ,

resourceType_s {value}

required_ary

{

name s com. Bar" , version s 2012.10.10 alias Bar

} resource fn function ( resourceReference ) {

var Foo = resourceReference . declare (

function (object_p) {

this._bar = resourceReference . newClass ( "Bar" ) ;

} ) ;

RMS . define ( resourceUnit ) ;

[0029] The following shows how the Resource Unit is defined within the call to RMS.defme.

Code Sample 2:

//(#1: RMS — the Resource Management System)

//(#2: RMS. define)

RMS . define (

//(#3: Resource Unit)

{

//(#4.1: namespace)

name_s : "{value}",

//(#4.2: version)

version_s : "{value}",

//(#4.3: resource Type)

resourceType_s : "{value}",

//(#4.4: extends)

extends_s : "{value}",

//(#4.5: required resources)

required_ary : [

{

name_s : "{value}", version_s : "{value}", alias_s alue}"

}

] ,

//(#4.6: interface)

interface_ary : [

{ name_s : "{value}", type_s : "{value}" //(#4.7: implements)

implements_ary : [

] ,

//(#4.8: sealed) isSealed_b : {value},

//(#4.9: frozen)

isFrozen_b : {value},

//(#4.10: extensible)

isExtensible_b : {value}

//(#4.11 : Resource Function)

resource_fn : function(/* (#5: Resource Reference)*/ resourceReference

) {

//(#6: Resource Class)

var Foo = resourceReference . declareClass (

//(#7: User Constructor Function - UCF)

function (object_p) {

}

) ;

//(#6.1: Resource Class Variable - RCV)

Foo . newVariable = ...

//(#6.2: Resource Class Function - RCF)

Foo . newFunction = function ( ... ) {

}

//(#6.3: Resource Prototype Function: RPF)

Foo . prototype . newFunction = function ( ) {

}

return ( Foo ) [0030] The RMS Object is a singleton system wide object for managed loading of system resources.

[0031] The RMS Object contains a primary function "define" that is called to define a Resource from a Resource Unit.

[0032] Resource Unit is passed to the RMS. define function.

[0033] The RMS. define function reads the the Resource Units properties (#4.1 - 4.11), determines if all required resource are available, if not it will load them.

[0034] The RMS. define function then creates a Resource Reference Object.

[0035] A Resource Reference Object contains all the dependencies for a Resource Unit. It contains the Resource Unit meta data. It contains system properties. It also contains a set of useful functions:

.declare

Declares a new resource for the RMS

.newObject

Returns a new instance of a named class passing provided parameters. .getClass

Returns the named class as a function,

.getlnstance

Returns a singleton instance of a named class.

.getSystemProperty

Returns a named system property.

[0036] The Developer code in the Resource Unit that is represented in the Resource Function has multiple states:

• Defined: The developer code prior to being called. • Declared: The Resource Class that is returned to the RMS.

• Active: The Returned Resource Class the the RMS has validated and is

available for other Resource Units.

• Object: is a new instance of the Resource Class.

[0037] The RMS. define function, having a fully initialized Resource Reference Object, calls the Resource Unit function "resource fn" (#4.11) and passes the Resource

Reference in as a parameter.

[0038] The code in the Resource Function will create a variable and set it to be equal to the Resource Reference function "declare" and pass in a function that will managed by the system as part of the constructor phase for the Resource.

[0039] Calling the Resource Reference "declare" function will:

• Create a name-spaced variable that is derived from (#4.1) name_s, if the

Resource Unit is a resource type that requires a name space

• Create prototype base inheritance from the class that is derived from (#4.4) extends s, if the Resource Unit is a resource type that uses inheritance

• Create a system managed constructor that encapsulates the developer provided constructor function, if the Resource Unit is a resource type that has a constructor. The managed constructor provides the system with the ability to monitor and interact when objects are created from resources.

• Add prototype and non prototype functions "getClassName" that determines a fully qualified name, if the Resource Unit is a resource type that requires it.

• Add prototype and non prototype functions "isInstanceO ' that support

determining if another object is an instance of the current resource.

• Add meta data to the constructor function that identifies class name, function names, and function variables.

• Performs validations appropriate for resource type. [0040] Completion of the call to the Resource Reference "declare" function will be returned to the Resource Function. The returned value will be set equal to the developer resource class variable.

[0041] The remainder of the developer functionality in the Resource Function will be called. Upon completion of the Resource Function call, the Resource Class declaration variable will be returned to the RMS.

[0042] The RMS will do post validations:

• Verify that an indicated interface is valid

• Verify that an indicated implementing interface is valid

• Verify that the resource type is valid for the returned Resource Class

[0043] The RMS will seal, freeze, or identify as not extensible the declared Resource Class if identified in the Resource Unit.

[0044] If the Resource Class passes validation, it will be identified as being active and ready for use by Resource Units that have the resource as a dependency.

[0044.1] Activating a Resource Unit can be alternately implemented using the Activation Module instead of the resourceReference.declareClass function. The Activation Module would validate and activate the code that is returned from the Resource Units

resource Jn, thereby formulating the Resource Function as follows:

//(#4.11 : Resource Function)

resource_fn : function ( resourceReference ) {

//(#6: Resource Class)

var Foo = function (object_p) {

}

//(#6.1: Resource Class Variable - RCV)

Foo . newVariable = ... //(#6.2: Resource Class Function - RCF)

Foo . newFunction = function ( ... ) {

}

//(#6.3: Resource Prototype Function: RPF)

Foo . prototype . newFunction = function ( ) {

}

return ( Foo ) ;

}

[0045] An Example of a Resource Function Name reflecting its usage and alternative declarative property names:

RMS . define (

{

ame Os . dir . Person" ,

Version ' 1.0.0 " ,

Extends Object",

Includes [

{

ame Os . lang. Object" , Version : "1.0.0",

Alias : "Object"

] ,

Class : function ( Reference ) {

//(#6: Resource Class)

var Person = function ( firstName_s_p ) {

this ._firstName_s_c = firstName_s_p ;

}

Person . property . getFirstName = function ( ) { return ( this ._firstName_s_c ) ; }

Claims

Claim 1 : A method comprised of stored instructions supporting the loading of

JavaScript™ functions and runtime alterations of JavaScript functions, hereinafter referred to as the Resource Management System.

Claim 2: A method as recited in claim 1, wherein the programming language is a prototype-based language.

Claim 3 : A method as recited in claim 1 , wherein the programming language is a script language.

Claim 4: A method as recited in claim 1, wherein the programming language is JavaScript.

Claim 5 : A method as recited in claim 1 , wherein the Resource Management System loads developer resources, deployed non-minified resources, or deployed minified resource based on URL parameter or configuration.

Claim 6: A method as recited in claim 5, wherein a developer resource is defined in a JavaScript literal, hereinafter referred to as a Resource Unit.

Claim 7: A method as recited in claim 6, wherein the Resource Unit has properties identifying, at minimum: 1) the Resource Units' fully qualified name; and 2) the Resource Units' version; 3) the Resource Unit type identifying a class or a module; and also may include 4) for inheritance purposes, the parent class of the Resource Unit; 5) a list of dependent resources for the Resource Unit, identified by name, version, and optional alias; 6) a list of interfaces that are required to be implemented by the Resource Unit, identified by name, and version; and 7) an identification that the Resource Unit is unalterable; and 8) a list of Resource Units that are available in a module. Claim 8: A method as recited in claim 6, wherein the Resource Unit contains a function that represents a class, or a list of Resource Units. The function is hereinafter referred to as a "Resource Function". Alternatively, the Resource Function property may be named to identify the functionality of the Resource Unit without using a separate property to identify the Resource Unit type.

Claim 9: A method as recited in claim 8, wherein the class represents an algorithm, hereinafter referred to as a "Resource Class."

Claim 10: A method as recited in claim 1, wherein the Resource Management System contains an "Activation Module." The module accepts a Resource Unit, identifies and verifies the dependencies that are required from the Resource Unit's properties. Any required but unavailable dependencies are loaded.

Claim 11 : A method as recited in claim 10, wherein the Activation Module loads all dependent classes into an object, hereinafter referred to as a "Resource Reference." The Activation Module passes the Resource Reference to the Resource Function. The Resource Reference contains an API that has the ability to create new objects from Resource Classes and get instances of objects derived from Resource Classes.

Claim 12: A method as recited in claim 10, wherein the Activation Module activates the Resource Function in the case that the Resource Function contains a Resource Class. The Activation Module dynamically: 1) alters the code so that the class variable uses a fully qualified name taken from the Resource Units' properties, 2) renames the original constructor, 3) creates a system controlled constructor that calls the renamed constructor; 4) implements native JavaScript prototype based inheritance in cases where inheritance is identified or alternatively flattens the prototype chain while maintaining inheritance functionality; 5) validates whether identified interfaces are implemented correctly in cases where an interface is identified,; 6) adds code for said claim in cases where code is to be unalterable; 7) adds a getter function that identifies the fully qualified name of the Resource Class; 8) adds a function to determine if another object is of the same fully qualified name and version; 9) adds a function that can call a parent class function; 10) adds metadata that identifies a) fully qualified names, b) versions, c) parent classes, d) implemented interfaces, e) function names, f) function return values, g) function parameter names and values, and h) types of resources; i) classes that an instantiated class is an instance of; j) classes that the current class is of the same class namespace; and 11) adds a function to determine if another object is of the same type. Successful completion activates the Resource Units code so that it can be used by the system. This process is hereinafter referred to as "Code Activation."

Claim 13: A method as recited in claim 10, wherein the Activation Module employs Code Activation either within the call to the Resource Function using the Resource Reference API, or after the Resource Class has been returned from the call to the

Resource Function.