I’ve been working on a more detailed branch of the Ruby Shipping Gem.
I’m hoping to be able to release some of all of the edits back as either a fork or to the main branch.

Other Ruby of interest:

• Cloud-Crowd: Distributed Task Handling via Cloud
• AuctionBoss: An early look at handling the online Auction House for World of Warcraft. Looks neat though it’s just getting started since the online AH is so new.
• EventMachine: EventMachine is a pretty neat way to handle incoming and outgoing network connections, among other things. I’m using it in a current project so thought I’d link it for those that haven’t heard of it yet.
• RubyGame: RubyGame is like PyGame but for Ruby. Seriously. No insult to RubyGame but it has the same goals so I feel that it’s an apt summary

That’s about it for now.
Hopefully I’ll have something code based to post again soonish.

I’ve restored the data from a straight sql dump so some things may work incorrectly until I notice them and fix them.

On a further note, the HDDs were never replaced as they did not come back as faulty from SeaGate’s utilities and I’m too cheap to buy new ones right now.

It just strikes me as strange that it’s failing after a little over a year.
I’ve only had one other hard drive fail on me and that was at 11 months.
I still have some older drives that work perfectly should I choose to use them and their monstrous 1 gig of space around somewhere.

Anyway, backing up to a large drive sometime soon.
Down time should be minimal for those that care.

~makkura

Full details found here: http://bit.ly/5YAv

I know it’s a little redundant because most people stumbling here will already know about it but just in case you don’t, well now you do.

~makkura

As with any new technology this experience was a little bumpy.
This post will discuss some of those bumps, both those that involve Titanium and those that do not.
For those needing more information on either of these technologies, visit:
WoWHorn’s Home Page
Titanium’s Home Page

Read on….

WoWArmory and FireFox:
The first thing that caught me was getting the XML for WoW’s achievements.
Not only are there ten different sheets to grab for the achievements, not all browsers just grab the xml.
By specifying the information to feed the site about the ‘agent’ that is contacting it, you can get the proper results.
In this case, if you tell WoWArmory that you’re using Firefox, you can get the xml sheets out of it.
This technique works both in Javascript and in Ruby (as well as other langages).
Thanks to Quick Armory (among other places) I was able to find this out.
We use this agent: ‘User-agent’: ‘Mozilla/5.0 (en-US; rv:1.8.1.3; IJustWantXML) Gecko/20070309 Firefox/2.0.0.3′.

Titanium and Ruby:
Titanium allows for the usage of Ruby together with your normal web development tools of HTML/CSS/JavaScript.
Unfortunately there are issues using classes in this environment for PR3. The Ruby code has a habit of losing access to the JavaScript’s window and thus losing communication with the rest of the program. This issue is being worked on and will hopefully be smoothed out soon.

The work around? Don’t use classes.
Ruby functions are directly callable in the Javascript of the page if they aren’t inside of a class.

Even though the Ruby here isn’t that heavy, the functions call each other and were meant to be in a class. So it felt a little strange to have these ‘free floating’ functions.

Titanium and Ruby: The Major Error:
The strangest problem I’ve had with Titanium and Ruby is a new one. The Titanium development team is now aware of it and diligently looking into a fix for it.

This issue is that systems that do not have a local copy of Ruby installed on them crash when calling the ruby code of WoWHorn, specifically the XML gathering script. It is quite strange and, of course, not as intended as Titanium has its own Ruby build with it.
So the current work around for this is to install a local copy of Ruby.

Ruby & XML (x10):
An issue I’ve found with gathering all these XML files is that it takes some time.
As I was running late on this initial release, I didn’t push to fix it when the rest of the application did not run at all.
Thanks to being able to use Ruby with Titanium, I will be able to separate these calls into threads to speed it up.

SQLite:
Titanium uses Webkit so has access to SQLite.
Though I didn’t have too many problems feeding data into SQLite, I did keep getting errors with database locks.
So a note for anyone using SQLite, it likes to lock but really only uses explicit locks on writes.
If you’re encountering a lot of lock errors, check any kind of loops you may have. When I moved from a single file to all ten files, I forgot where my openDB function was and I was trying to reopen the database for every page. SQLite did not like that.

Javascript:
Thanks to some heavier needs for Javascript and some instruction/help from Keeto from Keetology, I have found that JavaScript isn’t just that nifty little language that helped with some effects back in the 90′s.
The object code for javascript is nice and I like the way it works. It is still a bit confusing to me, though.
I had a lot of problems with errors caused by variable scope, variable naming, syntax, and general typos.
This wouldn’t normally be an issue except for, due to calls to the Titanium framework, I couldn’t use the tools I am used to for finding these errors (names the FireFox error console).
I was finally pointed to the console section of the web inspector to help find these. Webkit’s web inspector is not a tool I’m used to so it will take some time for it to feel smooth to me.

Paths:
Knowing your current wording directory isn’t quite as simple as it used to be when using Titanium.
For instance, when you’re testing an application out via Package and Launch, your current working directory is the Titanium Developer directory, sometimes.
This is easily fixed, however, by using the path ‘app://’ to refer to your application’s Resources directory.
If the language you’re using can’t find it, like Ruby won’t, you can use the Titanium modules to help locate it with: Titanium.App.appURLToPath(‘app://’).

Finally:
Though it had its bumps, designing with Titanium has been pretty fun.
Of course I could have approached the program with only one language, such as JavaScript only, but Titanium lets me use what I want so it is my decision to decide what I want to use or what is best for the situation.

I expect Titanium to become even more friendly to other languages as well as smoother to find usage information about than it is now in PR3.

There have been some articles written giving overviews of the Titanium Developer application.
This is the application that helps you manage your Titanium projects, test code samples, and keep up with the Titanium community.
This tutorial isn’t about the application so much as what is involved in making your application.
For a more broad look at Titanium Developer check out the official screencast for PR3: Titanium Developer – Preview Release 3 Features.
Notes: Due to a reload of the database the images for this section have been lost. The plugin handling toggling the subsections is also no longer in support. For now all divs are visible and no images are available.
This is an old tutorial now so it will stay as is unless a request comes in.

Installation / Upgrading: [+/-]

Project Creation: [+/-]

Alright, you should be inside the Titanium Developer program after your installation finished or you went and opened it because you’re abit ahead fo the game here.
If you’re looking at the listing of projects, hit the Create Project button, it is a small plus sign in a circle.
If you’re looking a list of frameworks like JQuery and MooTools, you’re in the right place.

Project Listing

Creating a Project

From here you want to select the additional tools you may want to use for your project.
Just highlight want you want and hit Continue.
Don’t fret too much! You can always add them later or add other libraries just like you would on a normal webpage.

The next page is your projects information.
Fill it out and hit Create.
It’s simple, I promise.

Creating a Project: Details

The Project Name is the name of your application to be.
This will also be used to help organize it by giving it a dedicated folder with a matching name.
The Project Description is a summary of what your application is for or does.
The Publisher Name is you or your company.
The Publisher URL is your home page or your company’s home page.
The Project Location is the local location to store your project’s folder. It has a standard browse button there next to it.
The Application Image is the icon that will be used for your application. It aslo has a standard browse button next to it.

Got everything filled in and ready to go?
Hit Create and we’ll move on.

Adding Content: [+/-]

Alright, your project exists and you’re ready to add some code!
Where do you do that?
Well your project has its own folder so let’s go there and take a look.
You’ll have to find this one yourself as you specified that directory when you were filling out the basic project information.
Once you get there, take a look at the folder structure.

File Structure of a Project

The main things to notice here are the ‘tiapp.xml’, the ‘dist’ folder, and the ‘Resources’ folder.
The ‘tiapp.xml’ file is filled with the information you filled in when creating your project but it also handles some window sizing and control material.
You can see more information on it in my post: TiApp.xml – Some Detail On Defaults.

The ‘dist’ folder will populate with data when you Package and Launch your project. It pretty much holds the local data for your project then.

The ‘Resources’ folder is the most important thing for you here.
It acts like your base web directory of a website.
Remember how Titanium uses web languages, right?
Well this is where it starts treating things like a website or webapp.

File Structure of a Project: Resources Folder

Open it up and you’ll see an ‘index.html’ file.
The ‘index.html’ file is the first file that is displayed when your application opens.
Note: The icon you chose for your application may be here as well. As of PR3 it appears your icon file may be linked to rather than copied to your Resources folder.

Understand this ‘Resources’ directory is just base folder of a web site.
That means you can add any content you want under this folder and get access to it just like you would in a normal website.
Want to make a ‘js’ folder for your javascript files? An ‘images’ folder for your images? Go for it! Just remember to add ‘js/’ or ‘images’/ to your path when referencing them.

Speaking of referencing to this folder, Titanium saves you some effort by making the ‘Resources’ folder equivalent to ‘app://’.
So your ‘images’ folder above would be ‘app://images/’ and your javascript files would be ‘app://js/’.
Your index is ‘app://index.html’ as well.

Open up that ‘index.html’ file and take a peek inside.
You’ll see it is a very basic webpage welcoming you to Titanium.
Any frameworks that you chose to include when you created your project are also here.
You can add more by adding them in the code here. Don’t worry you don’t have to add references or anything somewhere else. It’s all right here.
Take a few moments to edit it, add in some custom text or your favorite feature.
Need some inspiration? Try out a Notification Tutorial.
Save and close your editor.

Index.html with default content

Testing Your Application: [+/-]

#image: TiDev in project window with project selected

Back in the Titanium Developer application on the Projects tab your project should be listed along with any others you have started.
Click its name to open up some details on it.
Replacing the date next to the project name are a couple of icons.
The minus sign will let you delete your project.
The ‘box’ icon will let you run or package your project for installation.
Go ahead and click the box.

Project Package / Install / Launch Options

You should be presented with some options:
- Package and Launch
- Run Application Installer
- Package for Distribution

To test your application you’ll want to use Package and Launch.
This will prepare your application to run and then run it so you can see it in action.
Feel free to give it a whirl and see some of your code in action.

Simple Titanium App Running w/ Debugger

Packing for Distribution: [+/-]

If you followed the Testing Your Application section you’ll be in the right place to begin packing your application.
If not, open up the Titanium Developer, go to the Projects tab, select your project, and push the box icon next to your project name.

Package for Distribution Options

Here you are greeted with icons to select the platforms (OS-X, Windows, and Linux) to build the application for.
Go ahead and at select one or more of them and we’ll move on.
You can then choose if the Titanium runtime files will be bundled with your installer or downloaded when the installer is installing your application.
The Network option is smaller and a good idea in case the user already has the runtime files.
Since I’m just testing, I usually use the Bundled options even though it can be pretty large.

Below the basic Network /Bundled option is a listing of the different modules.
You can choose to Exlude a module entirely, leave it downloadable on install, or bundle it.
This will let you customize what is actually going with your application and is your best bet when you get to the point when you’re trying to make your installer a little smaller.
Before you jump down to the Package button look down there for a little check box.
See him? He’s there to let you make your application public in the cloud.
If you check him and Package he’ll show up on the Apps tab and make your application easier for others to access.
Once you’ve at least selected a general packaing method hit Package along the bottom.

Packaing Project: In Progress Cloud

You will be packaged via the Titanium Cloud.
You will see an animation with a cloud to show you it is packaing the application.
When it is done you will be given a link to your application for each of the operating systems you chose.
There is also a link to visit a page containing them all.

Packing Project: Finished - Download Options

Follow a link and grab your application.
Congratulations on completing your application in Titanium!

There hasn’t been much discussion of what’s in the tiapp.xml file since PR1 of Titanium.
Since this file controls a lot of how your program starts up and acts initially, it is important to know what it does.
The tiapp.xml file is generated automatically when your project is created via the Titanium Developer.
It can, however, be edited manually after that.

Here’s a sample tiapp.xml:

com.makkura.test_application_demo
	test_application_demo
	1.0
makkura
	www.aterism.com
	2009 by makkura
	
		initial

		app://index.html
		700
		3000
		0
		800
		3000
		0
		false
		true
		true
		false
		false
		true
	

The Details:

Most of the code here is self explainitory.
We’ll be going out of order a little in this explaination.
The first couple lines set up the xml version and allow Titanium to parse it correctly.

Publisher Information:

The <publisher> tag gives the name of the publisher of the application. This is usually ‘you’ or ‘your company’.
The <url> tag gives the URL of the publisher.
The <name>, <publisher>, and <url> tags cover the information about you, the publisher.

Application Information:

The <id> tag identifies your application.
It follows the convention of ‘com.<publisher>.<application_name>’.
Data on your program will be stored in a folder with that tag name.
Windows: C:\Documents and Settings\All Users\Application Data\Titanium\appdata
OS-X: /Library/Application Support/Titanium/appdata
Linux: /TitaniumApp/appdata/

The <version> tag shows the version number of your program.
It starts at 1.0 and is not changed automatically. If you keep this number up to date, it can help identify what version your users have and if they need updates.
The <copyright> tag is filled with <current_year> by <publisher> on creation of the project.

Window Information:

The rest of the file specifies things about your application for when it opens.
Notice these are all enclosed by the <window> tags.

Identification:

The <id> tag specifies the window name for the first application window.
This is set by default to ‘initial’.
Using the Titanium API you can refer to this window with Titanium.UI.windows["initial"] or Titanium.UI.windows[0].
You can use either the id name or the index number to refer to your windows.

The <title> tag refers to the title that will be placed on the window.
This is equivalent to the HTML <title> tag.

The <url> tag specifies what file is going to be opened as content for this window.
It is set by default to ‘app://index.html’.
‘app://’ points to your current project’s Resources folder so this is the same as ‘path/application/Resources/index.html’.
In my example’s case that would be ‘/test_application_demo/Resources/index.html’.

Size:

The <min-height> and <max-height> tags control the minimum and maximum height of the window respectively.
Similarly the <min-width> and <max-width> tags control the minimum and maximum width of the window.
By default these are set to extreme values to not interefere with the application’s sizing.

The <height> and <width> tag assign the default size of the window when it opens.

If you need your window to conform to a specific size then these are the values you’ll need to edit.

Control:

The <maximizable>, <minimizable>, and <closable> tags handle the standard actions you expect from the Minimize, Maximize, and Close buttons in the corner of the title bar.
These are all set to ‘true’ by default.
Any that are disabled will be ‘greyed out’ and unusable.
If they are all disabled then they will not appear on the title bar at all.
(Greying out and being removed from the title bar completely may depend on the OS the application is run on.)

The <fullscreen> tag handles if the application is full screen or not.
It is set to ‘false’ by default.
If it is set to ‘true’ the application will take up the whole window and will not have the standard title bar and Minimize, Maximize, Close controls visible.

Chrome:

The <chrome> tag handles what custom chrome is available.
It is set to ‘true’ by default.
If it is set to ‘false’ the title bar will not appear.
The <chrome> tag also contains a value ‘scrollbars=”true”‘.  This value handles if there are usuable scrollbars if the content reaches far enough horizontally or vertically.
If it is set to ‘false’ there will be no scrollbars to use.

That covers everything in the TiApp.xml file by default.
There may be additional fields used by the different OS builds or fields the developes have added but not used by default.
I leave it to those more adventurous to handle those.

If you have additional fields that are specific to your OS in your tiapp.xml by default, please let me know and I will add in a refernce to them here.
~makkura

The initial plans for content here involve: Titanium (www.titaniumapp.com), Ruby (www.ruby-lang.org), HTML(www.w3.org), CSS(www.w3.org), JavaScript(developer.mozilla.org), Python(www.python.org), and various JavaScript frameworks according to whim including JQuery(www.jquery.com) and MooTools(www.mootools.net).

Why such a large range of tools?  Namely because Titanium can allow them all to work together in the same environment for huge amounts of flexability. Each of the languages listed here are things I have some experience with but I am not an expert in any of them. Hopefully something I find of interest to post here is of value to you, the reader.

-makkura