oj-loader/test-ohsojuicy/build/app.js

Load OJ files into your WebPack bundle! Write your app like you haven't done before.

/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}


/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	var oj = __webpack_require__(1)
	/*--(0)> /Users/Ingwie/Work/oj-loader/test-ohsojuicy/Log.oj*/var Log = $oj_oj._registerClass({ $oj_c_Log:1 }, null, function($oj_s, $oj_m) { function Log() { this.constructor = Log;this.$oj_id = ++$oj_oj._id;}
	$oj_s.$oj_f_info_ = function(msg) {
	    console.log(msg);
	}
	return Log;});
	/*<(0)--*/
	var App = $oj_oj._registerClass({ $oj_c_App:1 }, null, function($oj_s, $oj_m) { function App() { this.constructor = App;this.$oj_id = ++$oj_oj._id;}
	$oj_s.$oj_f_run = function() {
	    $oj_oj._cls.$oj_c_Log.$oj_f_info_("Hello from " + "Testing" + "!");
	}
	return App;});

	$oj_oj.msgSend($oj_oj._cls.$oj_c_App,{ $oj_f_run: 1 });


/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/*
	    runtime.js, runtime for the oj language
	    by musictheory.net, LLC.

	    Public Domain.
	*/

	;(function() { "use strict";

	var root = this;
	var previousOj = root.oj;

	var sDebugStackDepth = 0;
	var sDebugCallbacks  = null;
	var _classNameToMakerArrayMap = { };
	var _classNameToClassMap      = { };
	var _classNameToSuperNameMap  = { };

	function create(o)
	{
	    function f() {}
	    f.prototype = o;
	    return new f();
	}


	function hop(obj, prop)
	{
	    return Object.prototype.hasOwnProperty.call(obj, prop);
	}


	function mixin(from, to, overwrite, callback)
	{
	    for (var key in from) { if (hop(from, key) && (overwrite || !hop(to, key))) {
	        var value = from[key];
	        if (callback) callback(key, value);
	        to[key] = value;
	    }}
	}


	function _getDisplayName(className, methodName, prefix)
	{
	    if (className.indexOf("$oj$") != 0) {
	        className = _getReadableForRawName(className);
	    }

	    if (methodName.indexOf("$oj$") != 0) {
	        methodName = _getReadableForRawName(methodName);
	        methodName = methodName.replace(/([A-Za-z0-9])_/g, "$1:");
	    }

	    return [ prefix, "[", className, " ", methodName, "]" ].join("");
	}


	function throwUnrecognizedSelector(receiver, selector)
	{
	    throw new Error("Unrecognized selector: " + sel_getName(selector) + " sent to instance " + receiver);
	}


	function _registerClass(nameObject, superObject, callback)
	{
	    var isSubclassOfBase = false;

	    if (!superObject) {
	        superObject = { BaseObject: 1 };
	        isSubclassOfBase = true;
	    }

	    var name = _getRawName(nameObject); 
	    var superName = _getRawName(superObject);

	    var makerArray;
	    var cls;

	    _classNameToSuperNameMap[name] = superName;
	    var maker = function() {
	        var superclass = isSubclassOfBase ? BaseObject : _classNameToClassMap[superName];
	        if (!superclass) return;     

	        var instance_methods = { };
	        var class_methods    = { };
	        
	        cls = callback(class_methods, instance_methods);

	        cls.displayName  = name;
	        cls["$oj_name"]  = name;
	        cls["$oj_super"] = superclass;
	        cls.prototype    = new superclass();

	        mixin(superclass, cls);

	        mixin(class_methods, cls, true, function(key, method) {
	            method.displayName = _getDisplayName(name, key, "+");
	        });

	        mixin(instance_methods, cls.prototype, true, function(key, method) {
	            method.displayName = _getDisplayName(name, key, "-");
	        });

	        _classNameToClassMap[name] = cls;

	        var makerArray = _classNameToMakerArrayMap[name];
	        if (makerArray) {
	            for (var i = 0, length = makerArray.length; i < length; i++) {
	                makerArray[i]();
	            }
	        }
	    }

	    if (isSubclassOfBase || _classNameToClassMap[superName]) {
	        maker();
	    } else {
	        makerArray = _classNameToMakerArrayMap[superName];
	        
	        if (makerArray) {
	            makerArray.push(maker);
	        } else {
	            _classNameToMakerArrayMap[superName] = [ maker ]
	        }
	    }
	}


	function noConflict()
	{
	    root.oj = previousOj;
	}


	function getClassList()
	{
	    var results = [ ];

	    for (var key in _classNameToClassMap) { if (hop(_classNameToClassMap, key)) {
	        results.append(_classNameToClassMap[key]);
	    }}

	    return results;
	}


	function getSubclassesOfClass(cls)
	{
	    if (!cls) return null;

	    var results = [ ];
	    var name = cls["$oj_name"];

	    for (var key in _classNameToSuperNameMap) { if (hop(_classNameToSuperNameMap, key)) {
	        var superName = _classNameToSuperNameMap[key];

	        if (superName == name) {
	            results.push(_classNameToClassMap[key]);
	        }
	    }}

	    return results;
	}


	function isObject(object)
	{
	    return !!(object && object.constructor["$oj_name"]);
	}


	function setDebugCallbacks(callbacks)
	{
	    sDebugCallbacks = callbacks;
	}


	function _getRawName(selector)
	{
	    if (!selector) return null;

	    var name = Object.keys && Object.keys(selector)[0];

	    if (!name) {
	        for (var key in selector) { if (selector.hasOwnProperty(key)) {
	            return key;
	        }}
	    }

	    return name;
	}


	function _getReadableForRawName(inName)
	{
	    if (inName.indexOf("$oj$") != 0) {
	        return inName.substr(6);
	    }

	    return inName;
	}


	function sel_getName(selector)
	{
	    if (!selector) return null;
	    var name = _getRawName(selector);
	    if (name) name = name.substr(6);
	    return name;
	}


	function sel_isEqual(sel1, sel2)
	{
	    return _getRawName(sel1) == _getRawName(sel2);
	}


	function class_getName(cls)
	{
	    if (cls && cls["$oj_name"]) {
	        return _getReadableForRawName(cls["$oj_name"]);
	    }

	    return null;
	}


	function class_getSuperclass(cls)
	{
	    return cls["$oj_super"];
	}


	function class_isSubclassOf(cls, superclass)
	{
	    while (cls) {
	        if (cls === superclass) return true;
	        cls = class_getSuperclass(cls);
	    }

	    return false;
	}


	function object_getClass(object)
	{
	    return object.constructor;
	}


	function class_respondsToSelector(cls, selector)
	{
	    return !!cls.prototype[_getRawName(selector)];
	}


	function msgSend(receiver, selector)
	{
	    return receiver ? (
	        receiver[_getRawName(selector)] ||
	        throwUnrecognizedSelector(receiver, selector)
	    ).apply(receiver, Array.prototype.slice.call(arguments, 2)) : receiver;
	}
	msgSend.displayName = "oj.msgSend";


	function msgSend_Object_keys(receiver, selector)
	{
	    return receiver ? (
	        receiver[Object.keys(selector)[0]] ||
	        throwUnrecognizedSelector(receiver, selector)
	    ).apply(receiver, Array.prototype.slice.call(arguments, 2)) : receiver;
	}
	msgSend_Object_keys.displayName = "oj.msgSend";


	function msgSend_debug(receiver, selector)
	{
	    if (!receiver) return receiver;

	    var name = _getRawName(selector);
	    var imp  = receiver[imp];

	    if (!imp) {
	        throwUnrecognizedSelector(receiver, selector)
	    }

	    if (++sDebugStackDepth > 256) {
	        throw new Error("Maximum call stack depth exceeded.");
	    }

	    var result;
	    try {
	        if (sDebugCallbacks && sDebugCallbacks.willSendMessage) sDebugCallbacks.willSendMessage(arguments);
	        result = receiver.apply(Array.prototype.slice.call(arguments, 2));
	        if (sDebugCallbacks && sDebugCallbacks.didSendMessage)  sDebugCallbacks.didSendMessage(arguments);

	    } finally {
	        sDebugStackDepth--;
	    }

	    return result;
	}
	msgSend_debug.displayName = "oj.msgSend";


	var oj = {
	    _id:                      0,
	    _registerClass:           _registerClass,
	    _cls:                     _classNameToClassMap,

	    noConflict:               noConflict,

	    getClassList:             getClassList,
	    getSubclassesOfClass:     getSubclassesOfClass,
	    getSuperclass:            class_getSuperclass,
	    isObject:                 isObject,
	    sel_getName:              sel_getName,
	    sel_isEqual:              sel_isEqual,
	    class_getName:            class_getName,
	    class_getSuperclass:      class_getSuperclass,
	    class_isSubclassOf:       class_isSubclassOf,
	    class_respondsToSelector: class_respondsToSelector,
	    object_getClass:          object_getClass,
	    msgSend:                  Object.keys ? msgSend_Object_keys : msgSend,

	    msgSend_debug:            msgSend_debug,
	    setDebugCallbacks:        setDebugCallbacks
	}


	var BaseObject = function BaseObject() { }

	BaseObject.alloc = function() { return new this(); }
	BaseObject["class"] = function() { return this; }
	BaseObject.superclass = function() { return class_getSuperclass(this); }
	BaseObject.className = function() { return class_getName(this); }
	BaseObject.respondsToSelector_ = function(aSelector) { return !!this[_getRawName(aSelector)]; }
	BaseObject.instancesRespondToSelector_ = function(aSelector) { return class_respondsToSelector(this, aSelector); }
	BaseObject.isKindOfClass_ = function(cls) { return class_isSubclassOf(this, cls); }
	BaseObject.isMemberOfClass_ = function(cls) { return this === cls; }
	BaseObject.isSubclassOfClass_ = function(cls) { return class_isSubclassOf(this, cls); }
	BaseObject.isEqual_ = function(other) { return this === other; }

	BaseObject.prototype.init = function() { return this; }
	BaseObject.prototype.copy = function() { return object_getClass(this).alloc().init(); }
	BaseObject.prototype.superclass = function() { return class_getSuperclass(object_getClass(this)); }
	BaseObject.prototype["class"] = function() { return object_getClass(this); }
	BaseObject.prototype.className = function() { return class_getName(object_getClass(this)); }
	BaseObject.prototype.respondsToSelector_ = function(aSelector) { return class_respondsToSelector(object_getClass(this), aSelector); }
	BaseObject.prototype.performSelector_ = function(aSelector) { return oj.msgSend(this, aSelector); }
	BaseObject.prototype.performSelector_withObject_ = function(aSelector, object) { return oj.msgSend(this, aSelector, object); }
	BaseObject.prototype.performSelector_withObject_withObject_ = function(aSelector, o1, o2) { return oj.msgSend(this, aSelector, o1, o2); }
	BaseObject.prototype.description = function() { return "<" + this.className() + " " + this["$oj_id"] + ">" }
	BaseObject.prototype.toString = function() { return this.description(); }
	BaseObject.prototype.isKindOfClass_ = function(cls) { return class_isSubclassOf(object_getClass(this), cls); }
	BaseObject.prototype.isMemberOfClass_ = function(cls) { return object_getClass(this) === cls; }
	BaseObject.prototype.isEqual_ = function(other) { return this === other; }

	_classNameToClassMap["BaseObject"] = BaseObject;

	if (true) {
	    module.exports = oj;

	    if (typeof global != "undefined" && typeof global != "function") {
	        global["$oj_oj"] = oj;
	    }

	} else if (typeof define === "function" && define.amd) {
	    define(oj);
	} else {
	    root.oj = root["$oj_oj"] = oj;
	}

	}).call(this);

	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }
/******/ ]);