Step 1: Setup

The directory structure I used was as follows.

convert.rb (the ruby script)
compile.sh (the shell script)
fonts/ (a directory for font files - .ttf and .otf)
as/ (a directory for the generated ActionScript)
swfs/ (a directory for the compiled swf files)

Step 2: Prep fonts

Ok told a tiny white lie when I said it was all automated. Since (to my knowledge) you can’t inspect a font file to determine if it’s normal, regular, bold, italic, or bold italic (the weights and styles Flex understands) you’ll have to set up a naming convention that the Ruby script can parse. You’ll be using the font name to create an ActionScript class so it should also be a legal name.

Here’s an example using the Arial family.

Arial.ttf (regular fontWeight and normal fontStyle)
Arial_Italic.ttf (regular fontWeight and italic fontStyle)
Arial_Bold.ttf (bold fontWeight and normal fontStyle)
Arial_BoldItalic.ttf (bold fontWeight and italic fontStyle)

Step 3: The Ruby Script

require 'find'

# delete any previous as
Find.find( 'as' ) do | as |
  if File.extname( as ) == ".as"
    File.unlink as
  end
end

# generate new as
Find.find( 'fonts' ) do | font |
  if File.file?( font )
    # extension name
    ext = File.extname( font )
    # is font
    if ext == ".ttf" || ext == ".otf"
      # file name
      full_name = File.basename( font )
      name = File.basename( font, ext )
      # font weight and style
      font_weight = ""
      font_style = ""
      if full_name.include? "_Bold" + ext
        font_weight = "fontWeight='bold',"
      end
      if full_name.include? "_Italic" + ext
        font_style = "fontStyle='italic',"
      end
      if full_name.include? "_BoldItalic" + ext
        font_weight = "fontWeight='bold',"
        font_style = "fontStyle='italic',"
      end
      # generate as
      f = File.new("as/#{name}.as",  "w+")
      f.write "package
      {
        import flash.display.Sprite;

        public class #{name} extends Sprite
        {
          [Embed(source='../fonts/#{full_name}', fontName='#{name}', #{font_weight} #{font_style} unicodeRange='U+0000-U+00FF,U+2100-U+214F')]
          public var Font:Class;
        }
      }"
      # some helpful output
      print ',"', "#{name}", '"'
    end
  end
end

In TextMate you can open this script and hit Command-R to run it, or run it via the command line ‘ruby convert.rb’. Once the script runs you’ll have generated ActionScript files in the ‘as’ directory ready to be compiled.

Step 4: The Shell Script

echo "<h2>Fonts Custom Compile</h2>";
echo "<code> Started @ `date "+%H:%M:%S"`</code><br />";

for i in `cd as/; ls *.as`; do
  swf=`echo $i |  awk -F. '{print $1}'`
  swf="$swf.swf"
  "/Applications/Adobe Flex Builder 3/sdks/3.3.0.4589/bin/mxmlc" -file-specs="as/$i" -o="swfs/$swf" -managers="flash.fonts.AFEFontManager" 2>&1;
done

You’ll need to customize the script for your Flex SDK location, mine is at "/Applications/Adobe Flex Builder 3/sdks/3.3.0.4589/bin/mxmlc". The hidden gem in there is -managers="flash.fonts.AFEFontManager", about 90% of fonts will compile without it but the rest were blowing up until I added that argument.

Again with TextMate you can run the script with Command-R. Each font will take about five seconds to compile, my set of over 100 fonts took over ten minutes

That’s it! The SWFs are compiled and ready to be runtime loaded into a Flex app. Creating the ActionScript for 100+ fonts would have been a multi-day process but with a little scripting it took less than an hour.

In the example below there are two models in Rails, ‘Group’ and ‘Category’, Group has_many Categories and Category belongs_to Group. Here’s the Flex code for the Categories DataGrid, groupName is the labelFunction that spits out a Category’s Group name (equivalent to @category.group.name in ruby):

<?xml version="1.0" encoding="utf-8"?>
<mx:VBox xmlns:mx="http://www.adobe.com/2006/mxml" width="100%" height="100%">

    <mx:Script>
        <![CDATA[
            import mx.controls.dataGridClasses.DataGridColumn;

            private function groupName( item:Object, column:DataGridColumn ):String
            {
                return item.group.name;
            }

        ]]>
    </mx:Script>

    <mx:DataGrid id="dataGrid" width="100%" height="100%">
        <mx:columns>
            <mx:DataGridColumn headerText="Name" dataField="name" />
            <mx:DataGridColumn headerText="Group" labelFunction="groupName" />
        </mx:columns>
    </mx:DataGrid>

</mx:VBox>

Here’s a video intro. And Django runs out of the box (in the box?) – well some parts are missing like no relational db – still you can’t beat the one line deployment!

Docs! Running Django on Google App Engine

I should say plans for Ruby as they are looking for a project owner to work on the port. I’d volunteer myself (famous last words) but while I love Ruby I don’t know the ins and outs of the language as well as I do ActionScript.

In any case having one framework “to rule them all” would be a great boost to productivity as you wouldn’t have to mentally switch gears between the front (Flash/Flex) and back (PHP/Ruby etc.) ends.

Using HotRuby it is possible to use straight Ruby to build a Flash app.

When Microsoft released Silverlight the one feature that got a lot of people excited was that you could use the language you were most familiar with to build a RIA. Apparently Adobe has an internal project which allows any C or C++ code to run in the Flash Player or on AIR. This means that any language built on C/C++ will also run which means that Java, Python, and my beloved Ruby could also run. Schwing!

Ted is a Python guy so he talks about IronPython and JPython but of course Ruby has JRuby and IronRuby so I’m sure the behavior would be similar.

Like many organizations Adobe has lots of legacy C/C++ code ranging from PhotoShop filters, to PDF renderers, to readers and writers of every file format in existence, font libraries, to very complex vector renderers, and text layout code. Beyond Adobe there are many open source libraries that could be leveraged as components as well. The big thing for me is that these are not ports of these libraries, they run identical to the original source code down. For example the behavior of Python in Flash Player is identical to C-Python vs the ported behavior under the IronPython and Jython projects. The goal here is to bring lots of these legacy assets, code libraries, and languages into Flash Player and Adobe AIR perfectly so that any developer can leverage them cross-platform to build software. It would not shock me to see some of these components added into the Flash Player component cache so that they essentially are built into the player on first use.

InfoWorld has more.

For the Rails rate I’d guess that Rails is to Ruby as Flex is to ActionScript. I threw PHP in there as well to mix it up.

ActionScript hourly bill rates
ActionScript bill rate (low): $50.00
ActionScript bill rate (high): $75.00
ActionScript pay rate (low): $32.50
ActionScript pay rate (high): $48.75
Average hourly bill rate: $62.50

Adobe Flex hourly bill rates
Adobe Flex bill rate (low): $75.00
Adobe Flex bill rate (high): $125.00
Adobe Flex pay rate (low): $48.75
Adobe Flex pay rate (high): $81.25
Average hourly bill rate: $100.00

Flash hourly bill rates
Flash bill rate (low): $50.00
Flash bill rate (high): $75.00
Flash pay rate (low): $32.50
Flash pay rate (high): $48.75
Average hourly bill rate: $62.50

Flash Design (no full data but this was the average)
Average hourly bill rate: $50

Flash Remoting hourly bill rates
Flash Remoting bill rate (low): $60.00
Flash Remoting bill rate (high): $80.00
Flash Remoting pay rate (low): $39.00
Flash Remoting pay rate (high): $52.00
Average hourly bill rate: $70.00

Ruby hourly bill rates
Ruby bill rate (low): $75.00
Ruby bill rate (high): $95.00
Ruby pay rate (low): $48.75
Ruby pay rate (high): $61.75
Average hourly bill rate: $85.00

PHP hourly bill rates
PHP bill rate (low): $70.00
PHP bill rate (high): $90.00
PHP pay rate (low): $45.50
PHP pay rate (high): $58.50
Average hourly bill rate: $80.00

Flex had an average hourly bill rate of $70 a couple of months ago so it’s on the move (what recession?), if you’re an ActionScript Developer still doing Flash work get on the Flex train and raise those rates!

The rates seem about right to me (actually remoting seems low), what do you think?

<%= link_to_remote image_tag('cms/add_16.gif', :id => "color_add"),
      :url => { :controller => "colors", :action => "new_ajax",
      :id => @product.id },
      :with => "{ color_id: $F('color_id') }"
%>

But in Rails 2.0 the parameter wouldn’t go along for the ride, it seemed that the new authenticity_token that gets sent with Ajax calls was messing things up. Here’s the fix

<%= link_to_remote image_tag('cms/add_16.gif', :id => "color_add"),
      :url => { :controller => "colors", :action => "new_ajax",
      :id => @product.id },
      :with => "'color_id='+$F('color_id')"
%>

I freely admit JavaScript/Ajax is my weakest language so if I was doing it wrong the entire time let me know

As he mentions previously you did something like

<% form_for(@client) do |f| %>
    <%= render :partial => 'form', :locals => {:f => f} %>
    <%= submit_tag 'Create' %>
<% end %>

but now you can just do…

<% form_for(@client) do |f| %>
    <%= render :partial => f %>
    <%= submit_tag 'Create' %>
<% end %>

Cleaner and more intuitive, nice!