using namespace kyle; - home

So, it's been awhile, yes? Lots of new stuff, nothing to go on about right now, but I do have something to go on about. I recently had to have my iPhone replaced by Apple, so I backed up my device using iTunes. When I had the new device, I restored back to the device. To my unfortunate findings however, my previous apps were not back on the device, nor were they queued for download. Now, I know the app information is stored in the backup from previous experience, but I did not want to download all the apps again manually. I decided to give Apple a call and see if they could help me out. This was the gist of the conversation: Make sure you're signed into the app store on the device. Make sure your Mac is on the latest version of OS X. Make sure your iPhone is on the latest version of OS X. Check your previously purchased items, is that what you were looking for? And then the "genius" told me that when you backup your device, the apps and their data is not backed up with them. A total load of bull. Anyways, he was unable to help me and I informed him of the actuality that iOS backups do contain the app data, and it should restore the apps if you have the apps on your computer (but I did not, even though I had transferred purchases with my backup). So what is a programmer/coder to do? Automate this task, of course. Please find my easy steps below: 1. Copy all apps to a folder 2. Open a terminal and cd to the folder. 3. run this command: ls | sed 's/App - //' > output.txt 4. Save a file with this content in the same folder. <?php $data = explode("\n",file_get_contents('output.txt')); foreach($data as $bundle){ $bundleInfo = json_decode(file_get_contents('http://itunes.apple.com/lookup?bundleId='.$bundle),true); exec( sprintf( 'open -a "iTunes" %s', escapeshellarg( str_replace('https','itunes',$bundleInfo['results'][0]['trackViewUrl']) ) ) ); sleep(5); } ?> Then run the file. Wait for iTunes to show you the app page, and click on "Download". Wait 5 seconds for the next app to show up in iTunes. Hurrah.

Today I challenged myself to come up with two vastly different approaches to a problem. The problem being that I needed to conform a string of text to lines of a certian length without breaking words. My first approach was to use arrays and a bunch of logic. The second method was to use regular expressions. I think the regular expression approach is much more delightful. See below. <?php function conformTextToLengthOld($text,$length){ $words = explode(' ',$text); $lines = array(); $currentLine = &$lines[]; $currentLength = 0; foreach($words as $word){ if($currentLength + count($currentLine) + strlen($word) > $length && $currentLength != 0){ $currentLine = &$lines[]; $currentLength = 0; } $currentLength += strlen($word); $currentLine[] = $word; } $lines = array_map(function($in){ return implode(' ',$in); },$lines); return implode('<br/>',$lines); } function conformTextToLength($text,$length){ return str_replace( "\n", '<br/>', trim( preg_replace( '/(.{1,' . $length . '})(?:\s|$)/', "\$1\n", $text ) ) ); } var_dump( conformTextToLengthOld('Be a better friend to my taste buds.',11), conformTextToLength('Be a better friend to my taste buds.',11) ); ?> Outputs: string(48) "Be a better<br/>friend to<br/>my taste<br/>buds." string(48) "Be a better<br/>friend to<br/>my taste<br/>buds." Interesting stuff.

As some may notice, my blog is called "using namespace kyle;" which is a language construct of C++. Well, up until now, I didn't actually know very much about C++ and recently I've wanted to correct this gap in knoweldge. I've started learning up on C++ and have found a lot of cool things about it. I find most interesting and fun is how C++ handles memory. From what I've determined, C++ is a front-end to memory managment. When you define a variable, it allocates some memory addresses for that variable and the size is determined by the type of variable. I find that pretty cool and amazing. Keep in mind, I come from scripting languages. Currently, I've been trying to think of ways to break the memory by tricking C++ into doing things (I wouldn't really consider it tricking but I'm not sure of a better use of words). One example I've found is inistalizing a variable then taking the address and pointing it to a pointer of a different underlying type. Having the address of a char be pointed to an int type. You can check out all of my progress on learning C++ through my github page.

Hello everyone (or myself). It's been awhile since I last posted. The reason for this is I've been busy. Back at my job Celerity, they moved me over to a Portal Admin position, which drained me. So much so that I quit my job and started looking for new jobs in Milwaukee, WI. I found one. So I've been dealing with moving and I'm startling to settle in. However, this is a blog about programming, not my life. So, what brings me here today? I'm back to working on my PHP simple language, which I have dubbed thee "SimplePHP". Clever, right? Anyways, I've been working on making a language grammar for TextMate so it actually seems like a real language. This code simply generates: <?php class Person extends Humonoid implements Talkable { /** * @param string firstName */ public $firstName = 'Kyle'; /** * @param string lastName */ public $lastName = 'Kirby'; /** * @uses self::$firstName * @return string firstName */ public function getFirstName(){ return $this->firstName; } /** * @param string $firstName * @uses self::$firstName * @return void */ public function setFirstName($firstName = 'Kyle'){ $arguments = func_get_args(); if(isset($arguments[0]) && !is_string($arguments[0])){ throw new \Exception('An ' . gettype($firstName) . ' was passed to argument $firstName on method Person::setFirstName(); however a string was expected.'); } unset($arguments); $this->firstName = $firstName; return $this; } /** * @uses self::$lastName * @return string lastName */ public function getLastName(){ return $this->lastName; } /** * @param string $lastName * @uses self::$lastName * @return void */ public function setLastName($lastName = 'Kirby'){ $arguments = func_get_args(); if(isset($arguments[0]) && !is_string($arguments[0])){ throw new \Exception('An ' . gettype($lastName) . ' was passed to argument $lastName on method Person::setLastName(); however a string was expected.'); } unset($arguments); $this->lastName = $lastName; return $this; } /** * @param Person $who Someone to talk to * @return string The text that was talked. */ public function talk(Person $who){ return 'Hello ' . $who->getFirstName() . '!'; } } ?> Okay, so, maybe the generated code isn't all that simple. But it's all there. All the getters and setters and fun stuff. Of course, this isn't the limit to the scripting language. Check this out: Only 43 lines of code, and most of it isn't logical code. Just defining variables and comments. This is what it produces (prepare to have your mind blown) <?php namespace test; class TestClass extends TestAbc implements TestDef { /** * @param string readOnlyProperty */ protected $_readOnlyProperty; /** * @param resource writeOnlyProperty */ protected $_writeOnlyProperty; /** * @param array readWriteProperty */ protected $_readWriteProperty; /** * @param integer readOnlyPublicProperty */ protected $_readOnlyPublicProperty; /** * @param MyClass writeOnlyPublicProperty */ protected $_writeOnlyPublicProperty; /** * @param TestClass instance */ protected static $_instance; /** * @param string someWeirdEvaluatedThing */ protected $_someWeirdEvaluatedThing; /** * @uses self::$_readOnlyProperty * @return string readOnlyProperty */ public function getReadOnlyProperty(){ return $this->_readOnlyProperty; } /** * @param resource $writeOnlyProperty * @uses self::$_writeOnlyProperty * @return void */ public function setWriteOnlyProperty($writeOnlyProperty){ $arguments = func_get_args(); if(isset($arguments[0]) && !is_resource($arguments[0])){ throw new \Exception('An ' . gettype($writeOnlyProperty) . ' was passed to argument $writeOnlyProperty on method test\TestClass::setWriteOnlyProperty(); however a resource was expected.'); } unset($arguments); $this->_writeOnlyProperty = $writeOnlyProperty; return $this; } /** * @uses self::$_readWriteProperty * @return array readWriteProperty */ public function getReadWriteProperty(){ return $this->_readWriteProperty; } /** * @param array $readWriteProperty * @uses self::$_readWriteProperty * @return void */ public function setReadWriteProperty(array $readWriteProperty){ $this->_readWriteProperty = $readWriteProperty; return $this; } /** * @uses self::$_readOnlyPublicProperty * @return integer readOnlyPublicProperty */ public function getReadOnlyPublicProperty(){ return $this->_readOnlyPublicProperty; } /** * @param integer $readOnlyPublicProperty * @uses self::$_readOnlyPublicProperty * @return void */ protected function _setReadOnlyPublicProperty($readOnlyPublicProperty){ $arguments = func_get_args(); if(isset($arguments[0]) && !is_integer($arguments[0])){ throw new \Exception('An ' . gettype($readOnlyPublicProperty) . ' was passed to argument $readOnlyPublicProperty on method test\TestClass::setReadOnlyPublicProperty(); however a integer was expected.'); } unset($arguments); $this->_readOnlyPublicProperty = $readOnlyPublicProperty; return $this; } /** * @uses self::$_writeOnlyPublicProperty * @return MyClass writeOnlyPublicProperty */ protected function _getWriteOnlyPublicProperty(){ return $this->_writeOnlyPublicProperty; } /** * @param MyClass $writeOnlyPublicProperty * @uses self::$_writeOnlyPublicProperty * @return void */ public function setWriteOnlyPublicProperty(MyClass $writeOnlyPublicProperty){ $this->_writeOnlyPublicProperty = $writeOnlyPublicProperty; return $this; } /** * @uses self::$_instance * @return TestClass instance */ public static function getInstance(){ if(self::$_instance === null){ self::$_instance = new TestClass; } return self::$_instance; } /** * @uses self::$_someWeirdEvaluatedThing * @return string someWeirdEvaluatedThing */ public function getSomeWeirdEvaluatedThing(){ if($this->_someWeirdEvaluatedThing === null){ $this->_someWeirdEvaluatedThing = $this->readOnlyPublicProperty() + 5; } return $this->_someWeirdEvaluatedThing; } /** * @return void */ protected function ___construct(){ // Do nothing } /** * @param array $inputArray * @return string */ public function firstMethod(array $inputArray){ return implode(', ',$inputArray); } /** * This method will implode by = instead * of ,. * * @param array $inputArray * @return string Imploded by =. */ public function secondMethod(array $inputArray){ return implode('=',$inputArray); } /** * @param array $inputArray * @param bool $toggle This is just a random toggle, ignore it. * @return string */ public function thirdMethod(array $inputArray, $toggle = true){ $arguments = func_get_args(); if(isset($arguments[1]) && !is_bool($arguments[1])){ throw new \Exception('An ' . gettype($toggle) . ' was passed to argument $toggle on method test\TestClass::thirdMethod(); however a bool was expected.'); } unset($arguments); if($toggle){ return $this->secondMethod($inputArray); } } } ?> 185 lines of code. Count them. We just took 41 lines of code and were able to produce more than 4 times that. Talk about time saving, yeah? Well, I'm off for now. For future reference, here is the generator

Hello. After posting my previous post, I realized there were a few issues with my code. I found that KO doesn't handle observableArrays with duplicate values very well. It handles them just fine, but when you go and remove the DOM node that was assocoated with it, things get messy. To fix this, I've revised my code. <script> (function(ko,$){ // This is a utility function that will create a function // to generate options based on a value accessor. // The result will be a function that returns the created // options. // A dream, within a dream, within a dream. Yeah, I'm insane. var createOptions = function(assigner,defaultOptions){ return function(valueAccessor){ if(typeof assigner == 'function'){ var res = assigner(); assigner = res[0]; defaultOptions = res[1]; } var options = $.extend({},defaultOptions); var value = valueAccessor(); if(ko.isObservable(value)){ options[assigner] = value; } else { $.extend( options, value ); } return function(){ return options; } } } /** * start draggable * * A basic binder that allows the element to be dragged. */ ko.bindingHandlers.draggable = { modelKey: 'ko.bh.draggable.model', afterRenderCallback: function(elements, model){ $(elements).each(function(){ $(this).data( ko.bindingHandlers.draggable.modelKey, model ); }); }, generateOptions: createOptions( function(){ return [ 'with', { afterRender: ko.bindingHandlers.draggable.afterRenderCallback, draggable: {} } ]; } ), init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext){ var options = ko.bindingHandlers.draggable.generateOptions(valueAccessor); $(element).data( ko.bindingHandlers.draggable.modelKey, options().with ); $(element).draggable(options().draggable); return ko.bindingHandlers['with'].init( element, options, allBindingsAccessor, viewModel, bindingContext ); }, update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext){ var options = ko.bindingHandlers.draggable.generateOptions(valueAccessor); return ko.bindingHandlers['with'].update( element, options, allBindingsAccessor, viewModel, bindingContext ); } } /** * end draggable */ /** * start droppable * * A basic binder that allows the element to be dragged. */ ko.bindingHandlers.droppable = { wasDroppedFromSortable: false, generateOptions: createOptions( 'data', { droppable: {} } ), init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext){ var options = ko.bindingHandlers.droppable.generateOptions(valueAccessor); var model = options().data; $(element).droppable( $.extend( { accept: function(dragging){ // Check for the 'accept' method on the property if(typeof model.accept == 'function'){ // Evaluate and return the 'accept' method, // passing in the model and the element being // dragged. return model.accept( $(dragging).data( ko.bindingHandlers.draggable.modelKey ), dragging ); } else { return true; } }, drop: function(event,ui){ // In case of sortable being dropped here, // we need to tell the sortable not to sort. // This global variable does just that. ko.bindingHandlers.droppable.wasDroppedFromSortable = true; if(typeof model.onDrop == 'function'){ // Evaluate the onDrop method of the model // passing in the model dropped on it, // the event, and jQuery UI Map return model.onDrop( $(ui.draggable).data(ko.bindingHandlers.draggable.modelKey), event, ui ); } else { return true; } } }, options().droppable ) ); }, update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext){ var options = ko.bindingHandlers.draggable.generateOptions(valueAccessor); } } /** * end droppable */ ko.bindingHandlers.sortable = { sourceKey: 'ko.bh.sortable.source', generateOptions: createOptions( 'foreach', { afterRender: ko.bindingHandlers.draggable.afterRenderCallback, sortable: {} } ), init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext){ var options = ko.bindingHandlers.sortable.generateOptions(valueAccessor); $(element).data( ko.bindingHandlers.sortable.sourceKey, options().foreach ); $(element).sortable( $.extend( options().sortable, { connectWith: '*', // This defines better what can be connected // to this sortable. (This is a mod on jQuery UI) connectWithCallback: function(event,ui){ var containerArray = ui.instance.element.data(ko.bindingHandlers.sortable.sourceKey); var model = this.currentItem.data(ko.bindingHandlers.draggable.modelKey); if(typeof containerArray.accept == 'function'){ return containerArray.accept(model,options().foreach,this.currentItem); } else { return true; } }, stop: function(event, ui){ // Who we're sending to. var target = $(ui.item.data('sortableItem').currentContainer.element); // Who's sending it. var source = $(event.target); // What's the UI element? var droppedElement = $(ui.item); // The model that is being sent. var droppedModel = droppedElement.data(ko.bindingHandlers.draggable.modelKey); // The observableArray of the sender. var sourceObservable = source.data(ko.bindingHandlers.sortable.sourceKey); // The ObservableArray of the receiver. var targetObservable = target.data(ko.bindingHandlers.sortable.sourceKey); // The offset the item was placed at. var targetOffset = droppedElement.prevAll().length; // Cancel the default action, since we'll be updating // everything using ko bindings source.sortable('cancel'); // This is different than above because // we've ran cancel(), which put the item // back to it's start. var sourceOffset = droppedElement.prevAll().length; var wasAccepted = ( typeof targetObservable.accept == 'function' && targetObservable.accept(droppedModel,sourceObservable,droppedElement) == true || typeof targetObservable.accept == 'undefined' ); var wasDroppedOntoDroppable= ko.bindingHandlers.droppable.wasDroppedFromSortable; ko.bindingHandlers.droppable.wasDroppedFromSortable = false; var handleTarget = function(){ if(targetObservable.indexOf(droppedModel) != -1){ // dropping into something that already has that // item requires special attention. targetObservable.valueWillMutate(); var key = "setDomNodeChildrenFromArrayMapping_lastMappingResult"; ko.utils.domData.set(target.get(0),key,[]); $(target).children().remove(); targetObservable.valueHasMutated(); } targetObservable.splice( targetOffset, 0, droppedModel ); } if(wasAccepted && !wasDroppedOntoDroppable){ if(typeof targetObservable.beforeRecieve == 'function'){ targetObservable.beforeRecieve(sourceObservable,droppedModel,source); } if(typeof sourceObservable.beforeSend == 'function'){ targetObservable.beforeSend(targetObservable,droppedModel,source); } if( // The only thing that isn't writable is computed, // or something else. We double check it's an ko.isWriteableObservable(sourceObservable) == false && // Make sure it's an observable and not something // else. ko.isObservable(sourceObservable) ){ var subscribable = sourceObservable.subscribe( function(){ var key = "setDomNodeChildrenFromArrayMapping_lastMappingResult"; ko.utils.domData.set(source.get(0),key,[]); $(element).children().remove(); }, sourceObservable, 'beforeChange' ); handleTarget(); subscribable.dispose(); } else { sourceObservable.splice( sourceOffset, 1 ); handleTarget(); } $(droppedElement).remove(); if(typeof targetObservable.afterRecieve == 'function'){ targetObservable.afterRecieve(sourceObservable,droppedModel,source); } if(typeof sourceObservable.afterSend == 'function'){ targetObservable.afterRecieve(targetObservable,droppedModel,source); } } } } ) ); /** * To allow the ability of custom dropping allowance, * we override _rearrange so we can give the feeling * that the element isn't allow. This is called everyime * a sortable is hovered over another and it re-renders * the list to show that an element can be dropped. * We simply stop this process if that target does not * accept the element. We further verify on drop * to make sure the target does accept it. */ // Grab an instance of the sortable. var data = $(element).data('sortable'); // Assign a backup for _rearrange data._rearrangeOld = data._rearrange; // Overwrite _rearrange data._rearrange = function(event,ui){ // If the options supplied to this sortable // contain the method 'connectWithCallback' // then we run it, supplying the event // and the ui variable. if(typeof this.options.connectWithCallback == 'function'){ if(this.options.connectWithCallback.apply(this,[event,ui])){ // We can accept this sort, call the old _rearrange return data._rearrangeOld.apply(this,arguments); } else{ return false; } } else { return data._rearrangeOld.apply(this,arguments); } } return ko.bindingHandlers['template'].init( element, options, allBindingsAccessor, viewModel, bindingContext ); }, update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext){ return ko.bindingHandlers['template'].update( element, ko.bindingHandlers.sortable.generateOptions(valueAccessor), allBindingsAccessor, viewModel, bindingContext ); } } ko.extenders.sortable = function(target, options){ target.accept = options.accept || function(model, source, element){return true;}; target.beforeSend = options.beforeSend || function(model, source, target, element){}; target.afterSend = options.afterSend || function(model, source, target, element){}; target.beforeRecieve = options.beforeRecieve || function(model, source, target, element){}; target.afterRecieve = options.afterRecieve || function(model, source, target, element){}; } // This extender allows you to handle droppable things, such as // what the droppable can accept, and what to do when an // object is dropped. ko.extenders.droppable = function(target, options){ target.accept = options.accept || function(model, source, element){return true;}; target.onDrop = options.onDrop || function(model,event,ui){}; return target; } ko.extenders.nonMultipleDroppable = function(target, options){ target.accept = function(model,source, element){ if(source == target){ return true; } else if(target.indexOf(model) == -1){ return (options.accept || function(){return true;})(model,source,element); } else { return false; } }; target.onDrop = options.onDrop || function(model,event,ui){}; return target; } })(ko,jQuery); </script>

Good Evening. I've recently become very interested in Knockout.js. So much so that I've made my own bindings. These bindings are used to join jQuery UI drag/drop/sortable to knockout. I've seen some implementations, but I wasn't very fond of them. Here is a quick feature list: 1. Binding an observableArray to a UI Sortable 2. Binding an observable to droppable/draggable. 3. Defining what can be dropped on sortable/droppable by using an extension. 4. Binding sortable to a computed property. It's far more extensive than this, but here is the code: http://jsfiddle.net/7SFuR/4/ <script type="text/javascript"> (function(ko,jQuery){ /** * To allow dropping between sortables and droppables, * we define a varaible in our scope * that tells wether or not a ko.droppable binding * handled the event, that way the sorting * doesn't randomly sort. */ var dropped = false; // A basic binder that allows the element to be dragged. ko.bindingHandlers.draggable = { modelKey: 'ko.bindingHandlers.draggable.model', update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext){ // Define the owning modle of this element. $(element).data(ko.bindingHandlers.draggable.modelKey,ko.utils.unwrapObservable(valueAccessor())) // Make it draggable. $(element).draggable(); } } // A binder to allow an element to be dropped on. // This works for sortable and draggable. ko.bindingHandlers.droppable = { makeValueAccessor: function(valueAccessor){ var bindingValue = valueAccessor(); if(typeof bindingValue.data == 'undefined'){ return { data: bindingValue, droppable: {} }; } else { return { data: bindingValue.data, droppable: bindingValue.droppable || {} }; } }, update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext){ var options = ko.bindingHandlers.droppable.makeValueAccessor(valueAccessor); var model = options.data; $(element).droppable( $.extend( {}, options.droppable, { accept: function(dragging){ // Check for the 'accept' method on the property if(typeof model.accept == 'function'){ // Evaluate and return the 'accept' method, // passing in the model and the element being // dragged. return model.accept( $(dragging).data(ko.bindingHandlers.draggable.modelKey),dragging ); } else { return true; } }, drop: function(event,ui){ // In case of sortable being dropped here, // we need to tell the sortable not to sort. // This global variable does just that. dropped = true; if(typeof model.onDrop == 'function'){ // Evaluate the onDrop method of the model // passing in the model dropped on it, // the event, and jQuery UI Map return model.onDrop( $(ui.draggable).data(ko.bindingHandlers.draggable.modelKey), event, ui ); } else { return true; } } } ) ) } } ko.bindingHandlers.sortable = { arrayKey: 'ko.bindingHandlers.sortable.array', makeTemplateValueAccessor: function(valueAccessor){ // Manditory afterAdd event. var afterAdd = function(element,index,model){ // Bind the model to the element for retrieval // later. $(element).data(ko.bindingHandlers.draggable.modelKey,model); } return function(){ var bindingValue = ko.utils.unwrapObservable(valueAccessor()); if((!bindingValue) || typeof bindingValue.length == 'number'){ return { containerArray: valueAccessor(), foreach: valueAccessor(), afterAdd: afterAdd, // Extended options for the sortable. sortable: {} }; } return { containerArray: bindingValue.data, foreach: ko.utils.unwrapObservable(bindingValue.data), includeDestroyed: bindingValue.includeDestroyed || false, afterAdd: function(element,index,model){ // Make sure to execute the manditory afterAdd afterAdd(element,index,model); (bindingValue.afterAdd || function(){})(element,index,model) }, beforeRemove: bindingValue.beforeRemove || function(){}, afterRender: bindingValue.afterRender || function(){}, // Extended options for the sortable. sortable: bindingValue.sortable || {} }; } }, init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext){ // Get the options var options = ko.bindingHandlers.sortable.makeTemplateValueAccessor(valueAccessor); // Assign a reference of the observableArray to the dom element. $(element).data(ko.bindingHandlers.sortable.arrayKey,options().containerArray); // Initalize the template ko.bindingHandlers.template.init( element, options, allBindingsAccessor, viewModel, bindingContext ); // Create the sortable $(element).sortable( // Merge options $.extend( {}, options().sortable, { allowMultiple: false, // Connects with everything. connectWith: '*', // This defines better what can be connected // to this sortable. (This is a mod on jQuery UI) connectWithCallback: function(event,ui){ var containerArray = ui.instance.element.data(ko.bindingHandlers.sortable.arrayKey); var model = this.currentItem.data(ko.bindingHandlers.draggable.modelKey); if(typeof containerArray.accept == 'function'){ return containerArray.accept(model,options().containerArray,this.currentItem); } else { return true; } }, // Handle stopping of sorting // This will update the observableArrays stop: function(event,ui){ // Who we're sending to. var target = $(ui.item.data('sortableItem').currentContainer.element); // Who's sending it. var sender = $(event.target); // What's the UI element? var droppedElement = $(ui.item); // The model that is being sent. var droppedModel = droppedElement.data(ko.bindingHandlers.draggable.modelKey); // The observableArray of the sender. var senderArray = sender.data(ko.bindingHandlers.sortable.arrayKey); // The ObservableArray of the receiver. var targetArray = target.data(ko.bindingHandlers.sortable.arrayKey); // The offset the item was placed at. var targetOffset = droppedElement.prevAll().length; // Cancel the default action, since we'll be updating // everything using ko bindings sender.sortable('cancel'); // This is different than above because // we've ran cancel(), which put the item // back to it's start. var senderOffset = droppedElement.prevAll().length; function clearComputedData(){ // We want to tell the template engine to // refresh this node. To do this, // we grab the old array that the template // engine uses to determine wether or not // a change was made. // Set the key var key = "setDomNodeChildrenFromArrayMapping_lastMappingResult"; // Grab the array. var current = ko.utils.domData.get(sender.get(0),key); // Set the item at the offset that was dragged from // to undefined, this way the template engine will // recreate the node. current[senderOffset].arrayEntry = undefined; // We reassign the data. ko.utils.domData.set(sender.get(0),key,current); } function refresh(){ // Remove the item from the sender and make sure it that was // the model that was dropped on the target ... if(senderArray.splice(senderOffset,1)[0] != droppedModel){ throw new Error("Something went horribly wrong."); } // add it back to the sender. senderArray.splice(senderOffset,0,droppedModel); } // If the item was dropped on a droppable // this variable will be true. // If it is, then we want to restore // the sortable so nothing gets // messed up by accident upon dragging. if(dropped == true){ dropped = false; // If the sender is a computed observable if(senderArray.__ko_proto__ == ko.computed){ clearComputedData(); // We notify subscribers that this computed // observable has changed. senderArray.notifySubscribers(); // We remove the ui element. droppedElement.remove(); } else { refresh(); droppedElement.remove(); } // end excution. If the sender was not computed, // we just let the dragged element go back to its // place. return; } // We validate that the target can accept this drop. if( typeof targetArray.accept == 'function' && targetArray.accept(droppedModel,senderArray,droppedElement) == true ){ // Read the comments above for how this works. if(senderArray.__ko_proto__ == ko.computed){ clearComputedData(); } else { if(senderArray.splice(senderOffset,1)[0] != droppedModel){ throw new Error("Something went horribly wrong."); } } // We add the element to the target. targetArray.splice(targetOffset,0,droppedModel); // Remove the dragged entity. droppedElement.remove(); } else { if(senderArray.__ko_proto__ != ko.computed){ refresh(); droppedElement.remove(); } } } } ) ); // Here, we override the _rearrange method to allow // us to better define what's allowed to be to connected // and what's not. // Grab an instance of the sortable. var data = $(element).data('sortable'); // Assign a backup for _rearrange data._rearrangeOld = data._rearrange; // Overwrite _rearrange data._rearrange = function(event,ui){ // If the options supplied to this sortable // contain the method 'connectWithCallback' // then we run it, supplying the event // and the ui variable. if(typeof this.options.connectWithCallback == 'function'){ if(this.options.connectWithCallback.apply(this,[event,ui])){ // We can accept this sort, call the old _rearrange return data._rearrangeOld.apply(this,arguments); } else{ return false; } } else { return data._rearrangeOld.apply(this,arguments); } } }, update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext){ // Update the template. ko.bindingHandlers.template.update( element, ko.bindingHandlers.sortable.makeTemplateValueAccessor(valueAccessor), allBindingsAccessor, viewModel, bindingContext ); } } // Simple binding that removes an element from an observableArray // data-bind="remove: customers", this will remove the current // model (in context) from the customers array. ko.bindingHandlers.remove = { update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext){ $(element).click(function(){ valueAccessor().remove(viewModel); return false; }); } } // This extender allows you to handle droppable things, such as // what the droppable can accept, and what to do when an // object is dropped. ko.extenders.droppable = function(target, options){ target.accept = options.accept || function(model, source, element){return true;}; target.onDrop = options.onDrop || function(model,event,ui){}; return target; } ko.extenders.nonMultipleDroppable = function(target, options){ target.accept = function(model,source, element){ if(source == target){ console.log('is same'); return true; } else if(target.indexOf(model) == -1){ console.log('does not contain'); return (options.accept || function(){return true;})(model,source,element); } else { console.log('denied'); return false; } }; target.onDrop = options.onDrop || function(model,event,ui){}; return target; } })(ko,jQuery); </script>

Hello all. Just reporting on a widget that I created. It's an interface to DirecTV's guide. It's super simple. The interface gives you a textfield to search for channels. Once you have found your channel, you hit "enter" and the next three shows display. Super simple, super awesome. Video Download Now

Hello everyone (or just hello Kyle, since I don't think anyone else is reading this). Personal project development has been pretty slow lately; I've been pretty busy at work. However, these past two days I have been able to spend some time on my own interests (yay!). I was sitting at my desk at work when I thought to myself how I wish making beautiful code was easier. You have the hassle of writting propery PHPDoc, getter/setters, proper property naming and worrying about the design of all your classes. It takes so much time to do this and to worry wether or not you'll need to go back and modify something later. Then I thought, how cool would it be to have Objective-C's @synthesize on PHP. And having the ability to define parameters in a simple form much like that of C++. After stumbling around in my mind, I wondered how feasable it would be to take an Objective-C/C++ style @interface and convert it to PHP with all PHPDoc, getter/setters, properties, the works. A few hours later, I present to you the pseudo Objective-C code and the resulting PHP code: @interface ClassModel protected: static string name (r+); array *constants (r+); array *properties (r+); array *methods (r+); int type (r+); + (array) *someMethod; @end @interface ClassConstantModel protected: string name (r+); string value (r+); @end @interface ClassPropertyModel protected: int access (r+); string name (r+); string type (r+); string defaultValue (r+); bool isReference (r+); int synthesizedAccess (r+); @end @interface ClassMethodModel protected: int access (r+); string name (r+); bool isStatic (r+); bool isReference (r+); string returnType (r+); array *arguments (r+); @end @interface ClassMethodArgumentModel protected: string name (r+); string type (r+); string defaultValue (r+); bool isReference (r+); @end @interface CodeParser public: - (void) __construct: (string)withContents; protected: string codeContents; array results (r); - (array) findAll; - (array) findIndividual: (int)offset; - (void) parse; @end <?php class ClassModel { /** * Protected Properties */ /** * @param string name */ protected static $_name; /** * @param array constants */ protected $_constants; /** * @param array properties */ protected $_properties; /** * @param array methods */ protected $_methods; /** * @param int type */ protected $_type; /** * @param string $name * @uses self::$_name * @return void */ public static function setName($name){ if(!(is_string($name))){ throw new Exception('Invalid types supplied to function.'); } self::$_name = $name; } /** * @uses self::$_name * @return string name */ public static function getName(){ return self::$_name; } /** * @param array $constants * @uses self::$_constants * @return void */ public function setConstants(array $constants){ $this->_constants = $constants; } /** * @uses self::$_constants * @return array constants */ public function &getConstants(){ return $this->_constants; } /** * @param array $properties * @uses self::$_properties * @return void */ public function setProperties(array $properties){ $this->_properties = $properties; } /** * @uses self::$_properties * @return array properties */ public function &getProperties(){ return $this->_properties; } /** * @param array $methods * @uses self::$_methods * @return void */ public function setMethods(array $methods){ $this->_methods = $methods; } /** * @uses self::$_methods * @return array methods */ public function &getMethods(){ return $this->_methods; } /** * @param int $type * @uses self::$_type * @return void */ public function setType($type){ if(!(is_int($type))){ throw new Exception('Invalid types supplied to function.'); } $this->_type = $type; } /** * @uses self::$_type * @return int type */ public function getType(){ return $this->_type; } /** * @return array */ protected static function &_someMethod(){ // Do Something Here } } class ClassConstantModel { /** * Protected Properties */ /** * @param string name */ protected $_name; /** * @param string value */ protected $_value; /** * @param string $name * @uses self::$_name * @return void */ public function setName($name){ if(!(is_string($name))){ throw new Exception('Invalid types supplied to function.'); } $this->_name = $name; } /** * @uses self::$_name * @return string name */ public function getName(){ return $this->_name; } /** * @param string $value * @uses self::$_value * @return void */ public function setValue($value){ if(!(is_string($value))){ throw new Exception('Invalid types supplied to function.'); } $this->_value = $value; } /** * @uses self::$_value * @return string value */ public function getValue(){ return $this->_value; } } class ClassPropertyModel { /** * Protected Properties */ /** * @param int access */ protected $_access; /** * @param string name */ protected $_name; /** * @param string type */ protected $_type; /** * @param string defaultValue */ protected $_defaultValue; /** * @param bool isReference */ protected $_isReference; /** * @param int synthesizedAccess */ protected $_synthesizedAccess; /** * @param int $access * @uses self::$_access * @return void */ public function setAccess($access){ if(!(is_int($access))){ throw new Exception('Invalid types supplied to function.'); } $this->_access = $access; } /** * @uses self::$_access * @return int access */ public function getAccess(){ return $this->_access; } /** * @param string $name * @uses self::$_name * @return void */ public function setName($name){ if(!(is_string($name))){ throw new Exception('Invalid types supplied to function.'); } $this->_name = $name; } /** * @uses self::$_name * @return string name */ public function getName(){ return $this->_name; } /** * @param string $type * @uses self::$_type * @return void */ public function setType($type){ if(!(is_string($type))){ throw new Exception('Invalid types supplied to function.'); } $this->_type = $type; } /** * @uses self::$_type * @return string type */ public function getType(){ return $this->_type; } /** * @param string $defaultValue * @uses self::$_defaultValue * @return void */ public function setDefaultValue($defaultValue){ if(!(is_string($defaultValue))){ throw new Exception('Invalid types supplied to function.'); } $this->_defaultValue = $defaultValue; } /** * @uses self::$_defaultValue * @return string defaultValue */ public function getDefaultValue(){ return $this->_defaultValue; } /** * @param bool $isReference * @uses self::$_isReference * @return void */ public function setIsReference($isReference){ if(!(is_bool($isReference))){ throw new Exception('Invalid types supplied to function.'); } $this->_isReference = $isReference; } /** * @uses self::$_isReference * @return bool isReference */ public function getIsReference(){ return $this->_isReference; } /** * @param int $synthesizedAccess * @uses self::$_synthesizedAccess * @return void */ public function setSynthesizedAccess($synthesizedAccess){ if(!(is_int($synthesizedAccess))){ throw new Exception('Invalid types supplied to function.'); } $this->_synthesizedAccess = $synthesizedAccess; } /** * @uses self::$_synthesizedAccess * @return int synthesizedAccess */ public function getSynthesizedAccess(){ return $this->_synthesizedAccess; } } class ClassMethodModel { /** * Protected Properties */ /** * @param int access */ protected $_access; /** * @param string name */ protected $_name; /** * @param bool isStatic */ protected $_isStatic; /** * @param bool isReference */ protected $_isReference; /** * @param string returnType */ protected $_returnType; /** * @param array arguments */ protected $_arguments; /** * @param int $access * @uses self::$_access * @return void */ public function setAccess($access){ if(!(is_int($access))){ throw new Exception('Invalid types supplied to function.'); } $this->_access = $access; } /** * @uses self::$_access * @return int access */ public function getAccess(){ return $this->_access; } /** * @param string $name * @uses self::$_name * @return void */ public function setName($name){ if(!(is_string($name))){ throw new Exception('Invalid types supplied to function.'); } $this->_name = $name; } /** * @uses self::$_name * @return string name */ public function getName(){ return $this->_name; } /** * @param bool $isStatic * @uses self::$_isStatic * @return void */ public function setIsStatic($isStatic){ if(!(is_bool($isStatic))){ throw new Exception('Invalid types supplied to function.'); } $this->_isStatic = $isStatic; } /** * @uses self::$_isStatic * @return bool isStatic */ public function getIsStatic(){ return $this->_isStatic; } /** * @param bool $isReference * @uses self::$_isReference * @return void */ public function setIsReference($isReference){ if(!(is_bool($isReference))){ throw new Exception('Invalid types supplied to function.'); } $this->_isReference = $isReference; } /** * @uses self::$_isReference * @return bool isReference */ public function getIsReference(){ return $this->_isReference; } /** * @param string $returnType * @uses self::$_returnType * @return void */ public function setReturnType($returnType){ if(!(is_string($returnType))){ throw new Exception('Invalid types supplied to function.'); } $this->_returnType = $returnType; } /** * @uses self::$_returnType * @return string returnType */ public function getReturnType(){ return $this->_returnType; } /** * @param array $arguments * @uses self::$_arguments * @return void */ public function setArguments(array $arguments){ $this->_arguments = $arguments; } /** * @uses self::$_arguments * @return array arguments */ public function &getArguments(){ return $this->_arguments; } } class ClassMethodArgumentModel { /** * Protected Properties */ /** * @param string name */ protected $_name; /** * @param string type */ protected $_type; /** * @param string defaultValue */ protected $_defaultValue; /** * @param bool isReference */ protected $_isReference; /** * @param string $name * @uses self::$_name * @return void */ public function setName($name){ if(!(is_string($name))){ throw new Exception('Invalid types supplied to function.'); } $this->_name = $name; } /** * @uses self::$_name * @return string name */ public function getName(){ return $this->_name; } /** * @param string $type * @uses self::$_type * @return void */ public function setType($type){ if(!(is_string($type))){ throw new Exception('Invalid types supplied to function.'); } $this->_type = $type; } /** * @uses self::$_type * @return string type */ public function getType(){ return $this->_type; } /** * @param string $defaultValue * @uses self::$_defaultValue * @return void */ public function setDefaultValue($defaultValue){ if(!(is_string($defaultValue))){ throw new Exception('Invalid types supplied to function.'); } $this->_defaultValue = $defaultValue; } /** * @uses self::$_defaultValue * @return string defaultValue */ public function getDefaultValue(){ return $this->_defaultValue; } /** * @param bool $isReference * @uses self::$_isReference * @return void */ public function setIsReference($isReference){ if(!(is_bool($isReference))){ throw new Exception('Invalid types supplied to function.'); } $this->_isReference = $isReference; } /** * @uses self::$_isReference * @return bool isReference */ public function getIsReference(){ return $this->_isReference; } } class CodeParser { /** * Public Properties */ /** * Protected Properties */ /** * @param string codeContents */ protected $_codeContents; /** * @param array results */ protected $_results; /** * @param string $withContents * @return void */ public function __construct($withContents){ if(!(is_string($withContents))){ throw new Exception('Invalid types supplied to function.'); } // Do Something Here } /** * @param string $codeContents * @uses self::$_codeContents * @return void */ protected function _setCodeContents($codeContents){ if(!(is_string($codeContents))){ throw new Exception('Invalid types supplied to function.'); } $this->_codeContents = $codeContents; } /** * @uses self::$_codeContents * @return string codeContents */ protected function _getCodeContents(){ return $this->_codeContents; } /** * @param array $results * @uses self::$_results * @return void */ protected function _setResults(array $results){ $this->_results = $results; } /** * @uses self::$_results * @return array results */ public function getResults(){ return $this->_results; } /** * @return array */ protected function _findAll(){ // Do Something Here } /** * @param int $offset * @return array */ protected function _findIndividual($offset){ if(!(is_int($offset))){ throw new Exception('Invalid types supplied to function.'); } // Do Something Here } /** * @return void */ protected function _parse(){ // Do Something Here } } ?> The code you see is real and was generated by my script. My script is able to understand protected, private, and public method/properties. Static and instance methods/properties. Methods that have referenced arguments, and return references. By default, a property defined will have synthesized methods (getters and setters). The access level of the synthesized methods will be in the same as that of the property. You'll notice things in my psuedo code like "(r+)" or "(r)". This defines what can be done in a public scope. r+ means that get and set will be public regardless of the scope of the property. r means only get will be public, and w means only set will be public. When defining a method, you set it to static using a '+' and instance using '-', just like Objective-C. You define arguments of the method by appending a colin and a list of arguments. eg: + (void) doSomething: (int)someNumber, (array)someArray; When a method has an argument, PHP doesn't automatically type check primatives, only objects. To solve for this, the script will apply type checking to your method. I plan to add a lot more on to this script; things like abstract classes/functions, interface methods, and implements/extends syntax. Once done, I plan to share this script via DonationWare on a website. You can pick your price on it, or if you don't have the money to spare you can use it for free. Until next time!

I have a dream; a complex and simplistic one. One that has been solved, but never to the greatest extent of the idea. My dream is to have server-side integrate with client side. This has been solved by many frameworks and custom servers. All of which, or most of, require using Ajax to communicate back to the server. My dream is to eliminate the need of this extra request. Having the server snapshot custom code and render it to the client without having to do any callbacks. An example would be like this: $document->load(function($context){ if($context->isLoggedIn()){ $context->f('body').css('background','blue'); } }); This is just an idea. In writing this, it gave me a few ideas on how to implement it. Using a recording device, and using more specific if/elses with functions. We'll see how this goes.

Good evening! I had previously talked about a mysterious other dilemma that I did not have the time to write about. This dilemma really goes into the depts about design ques on frameworking. The question:

How do you associate classes that make up a whole, but define completely different functionality, and are all used in conjunction with each other? How do you abstract this to the best, and when is it considered too much abstraction?

That's a loaded question. Let's break this down some more and see if we can develope an answer (as I don't have one yet). Let's start with the smaller of the questions.

How do you abstract [classes] to the best?

This seems like an incredibily difficult question. How do you know you've actually pulled out all the pieces and made them abstract? How do you know it's not exceedingly abstract? How do you know it's abstract enough for future implementations? Okay, okay. This is super loaded. Lets go and assume you are creating a framework to be prototyped for some basic functionality. I'm going to back track. I'll provide an example; the one that provoked this question to begin with. Imagine, if you will, you are to implement a ratings/reviews API into your website. You want to do a good job, right? You want it to be extremely frameworked and use a standard API for your developers that correlates to another API. Well, ratings/reviews has several different partitions. You have search engine content, content loaded from service server, and you also have a rating's star system that is based on an XML file. These are all different parts of the services API and are all called completely differenly. Not even using the same methods (such as, one in Javascript, one uses XML, another uses static files). Not to mention, each API contains several different rending types. So, how do you split this out, but make it so that it can be used later for other parts of the website that won't be using the same configuration as another part of the website. You'll end up having a lot of classes that don't really work together but are together because they share the same parent. That's about the only relationship. The problem with this is, if another part of website needs to change the implementation, that means they have to write three new classes that extend from the base classes. This seems like God Awful horrible code. How do you overcome this hurdle and allow the classes to be easily extended, changed, modified, and accessible? Yes, you can always just make each property have getter/setter. This also seems like crappy code. Maybe not; but it seems unstandard and unsafe. Inevitably, my solution was to have a helper class that brought everything together. The class allowed you to set properties on the class by defining which rendering you'd be using and the properties for it. Also, you are able to define the renderers options for the type that it was rendering. I found this to be the best in the situation. Back to my original question. I have yet to really answer it; I know. I think the method of abstraction is really all to the eye of the beholder. Everyone thinks completely differently. Some will tell you that you should only abstract as much as the business needs you to. Others will tell you to make each and every property its own class. Where's the fine line? The line is probably at which point have you detoured and are no longer talking about the functionality you were set out to introduce. When you are going into things so off subject, so different that you're just adding code to make it more accessibile. When you reach this point, you need to take a step back and figure out what you really do need. You should never be reinventing anything. Always use what tools you have available. The line is never fine, but horribly fuzzy. You should abstract out to make things easier to expand on in the future. Abstract out to seperate smaller functionalities. For example: <?php interface RatingsAndReviewsRenderer { public function render(); } /** * We could also just ignore this entirely and realize that we can * remove the specificness and make it even more accesible. A name * change can fix this. */ interface Renderer { public function render(); } /** * Here, we have functionality that defines a class being * "configurable". Eg, the properties can be changed on the fly. */ interface IConfigurable { public function configure(array $configuration); } abstract class Configurable implements IConfigurable { public function configure(array $configuration){ // code galore } } interface