funfx 0.2.0

data/lib/funfx/flex/flex_app_id.rb

@@ -0,0 +1,15 @@
+module FunFX
+  module Flex
+    module FlexAppId #:nodoc:
+      def full_id(flex_id)
+        full_id = (instance_variable_defined?(:@id_prefix)) ? "#{@id_prefix}|" : ""
+        full_id += flex_id
+      end
+
+      def automation_id(flex_id)
+        full_flex_id = full_id(flex_id)
+        "{automationID: '#{full_flex_id}'}"
+      end
+    end
+  end
+end

data/lib/funfx/flex/tabular_data.rb

@@ -0,0 +1,22 @@
+module FunFX
+  module Flex
+    module TabularData      
+      def column_names
+        get_tabular_property_value("columnNames", Table).first
+      end
+
+      def values(start_index, end_index)
+        invoke_tabular_method("getValues", Table, start_index, end_index)
+      end
+
+      def num_columns
+        get_tabular_property_value("numColumns", Integer)
+      end
+
+      def num_rows
+        get_tabular_property_value("numRows", Integer)
+      end
+
+    end
+  end
+end

data/lib/funfx/meta/class_dot.erb

@@ -0,0 +1,24 @@
+digraph G {
+  rankdir = BT;
+
+  fontname = "Bitstream Vera Sans"
+  fontsize = 8
+
+  node [
+    fontname = "Bitstream Vera Sans"
+    fontsize = 8
+    shape = "record"
+  ]
+
+  edge [
+    fontname = "Bitstream Vera Sans"
+    fontsize = 8
+  ]
+  
+<% classes.each do |klass| %>
+  <%= klass.name %> [
+    label = "{<%= klass.name %>|<%= klass.dot_property_list %>|<%= klass.dot_event_list %>}"
+  ]
+  <% if klass.superclass_name %><%= klass.name %> -> <%= klass.superclass_name %><% end %>
+<% end %>
+}

data/lib/funfx/meta/code.erb

@@ -0,0 +1,33 @@
+require 'funfx'
+require 'funfx/flex/element'
+require 'funfx/flex/tabular_data'
+
+module FunFX
+  module Flex
+    module Elements
+<% classes.each do |klass| -%>
+
+      class <%= klass.name %> < <%= klass.superclass_name || 'Element' %>
+<% if klass.tabular? -%>
+        include TabularData
+<% end -%>
+<% klass.properties.each do |property| -%>
+
+        def <%= property.ruby_name %>
+          get_property_value('<%= property.name %>', <%= property.ruby_type %>)
+        end
+<% end -%>
+<% klass.events.each do |event| -%>
+        def <%= event.to_method %>
+          fire_event(<%= event.arg_list("'#{event.name}'") %>)
+        end
+<% end -%>
+      end
+      
+      def <%= klass.lookup_method %>(*locator_hash)
+        <%= klass.name %>.new(self, nil, *locator_hash)
+      end
+<% end -%>
+    end
+  end
+end

data/lib/funfx/meta/generator.rb

@@ -0,0 +1,18 @@
+require 'funfx/meta/parser'
+require 'erb'
+
+module FunFX
+  module Meta
+    class Generator
+      def initialize(classes, template_name)
+        @classes, @template_name = classes, template_name
+      end
+      
+      def generate
+        template = ERB.new(IO.read(File.dirname(__FILE__) + "/#{@template_name}.erb"), nil, '-<>')
+        classes = @classes
+        template.result(binding)
+      end
+    end
+  end
+end

data/lib/funfx/meta/parser.rb

@@ -0,0 +1,190 @@
+require 'funfx/decoder'
+require 'rubygems'
+begin
+  require 'libxml'
+rescue LoadError
+  STDERR.puts "LibXML not installed. gem install libxml-ruby"
+end
+begin
+  require 'active_support'
+rescue LoadError
+  STDERR.puts "activesupport not installed. gem install activesupport"
+end
+
+module FunFX
+  module Meta
+    class ClassLib
+      META_API = File.dirname(__FILE__) + '/../../../../flex/src/AutoQuickEnv.xml'
+
+      def initialize
+        @lib = Hash.new(MetaClass.new)
+        
+        doc = LibXML::XML::Document.file(META_API)
+        doc.find('/TypeInformation/ClassInfo').map do |class_info|
+          klass = FlexMetaClass.new(class_info)
+          @lib[klass.name] = klass
+        end
+        
+        @lib.values.each do |c|
+          c.link_with(self)
+        end
+        
+        @classes = []
+        object.add_children_recursive(@classes)
+      end
+      
+      def [](name)
+        @lib[name]
+      end
+      
+      def object
+        self[nil]
+      end
+      
+      def classes(names = nil)
+        return @classes if names.nil?
+        return @classes.select{|c| names.index(c.name)}
+      end
+    end
+
+    class MetaClass
+      attr_reader :children
+      
+      def initialize
+        @children = []
+      end
+      
+      def add_children_recursive(a)
+        @children.each do |c|
+          a << c
+          c.add_children_recursive(a)
+        end
+      end
+    end
+    
+    class FlexMetaClass < MetaClass
+      def initialize(class_info)
+        super()
+        @class_info = class_info
+      end
+
+      def link_with(lib)
+        s = lib[superclass_name]
+        unless s.nil?
+          @superclass = s
+          @superclass.children << self
+        end
+      end
+      
+      def name
+        @class_info['Name']
+      end
+      
+      def superclass_name
+        @class_info['Extends']
+      end
+      
+      def properties
+        @class_info.find('Properties/Property').map do |property|
+          ['columnNames'].include?(property['Name']) ? nil : Property.new(property, false)
+        end.compact
+      end
+
+      def events
+        @class_info.find('Events/Event').map do |event|
+          Event.new(event)
+        end
+      end
+      
+      def tabular?
+        @class_info['SupportsTabularData'] == 'true'
+      end
+      
+      def dot_property_list
+        l = properties.map{|p| p.to_dot}.join('\l')
+        l == "" ? l : "#{l}\\l"
+      end
+
+      def dot_event_list
+        l = events.map{|e| e.to_method.gsub(/"/, '\"')}.join('\l')
+        l == "" ? l : "#{l}\\l"
+      end
+      
+      def lookup_method
+        name.underscore.gsub(/^flex_/, '')
+      end
+    end
+    
+    class Property
+      def initialize(property, param)
+        @property, @param = property, param
+      end
+      
+      def name
+        @property['Name']
+      end
+      
+      def ruby_name
+        if @param
+          name.underscore
+        else
+          name.underscore + (ruby_type == TrueClass ? '?' : '')
+        end
+      end
+
+      def ruby_type
+        type = @property.find('PropertyType').first['Type'].underscore.to_sym
+        Decoder.convert_type(type)
+      end
+      
+      def default_value
+        default = @property['DefaultValue']
+        return nil if default.nil?
+        ruby_type.from_funfx_string(default)
+      end
+      
+      def to_dot
+        "#{ruby_name} : #{ruby_type.name}"
+      end
+      
+      def to_arg
+        (default_value ? "#{ruby_name}=#{default_value.inspect}" : ruby_name)
+      end
+      
+    end
+    
+    class Event
+      def initialize(event)
+        @event = event
+      end
+      
+      def name
+        @event['Name']
+      end
+
+      def ruby_name
+        name.underscore
+      end
+      
+      def args
+        @event.find('Property').map do |property|
+          Property.new(property, true)
+        end
+      end
+      
+      def arg_list(pre)
+        a = args.map{|arg| arg.ruby_name}
+        ([pre] + a).flatten.join(", ")
+      end
+      
+      def arg_list_with_defaults
+        args.map{|arg| arg.to_arg}.join(", ")
+      end
+
+      def to_method
+        arg_list = args.map{|a| a.to_arg}.join(", ")
+        "#{ruby_name}(#{arg_list})"
+      end
+    end
+  end
+end

data/lib/funfx/version.rb

@@ -0,0 +1,9 @@
+module FunFX
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/rake_tasks/deployment.rake

@@ -0,0 +1,34 @@
+desc 'Release the website and new gem version'
+task :deploy => [:check_version, :website, :release] do
+  puts "Remember to create SVN tag:"
+  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
+    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
+  puts "Suggested comment:"
+  puts "Tagging release #{CHANGES}"
+end
+
+desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
+task :local_deploy => [:website_generate, :install_gem]
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end
+
+desc 'Install the package as a gem, without generating documentation(ri/rdoc)'
+task :install_gem_no_doc => [:clean, :package] do
+  sh "#{'sudo ' unless Hoe::WINDOZE }gem install pkg/*.gem --no-rdoc --no-ri"
+end
+
+namespace :manifest do
+  desc 'Recreate Manifest.txt to include ALL files'
+  task :refresh do
+    `rake check_manifest | patch -p0 > Manifest.txt`
+  end
+end

data/rake_tasks/environment.rake

@@ -0,0 +1,7 @@
+task :ruby_env do
+  RUBY_APP = if RUBY_PLATFORM =~ /java/
+    "jruby"
+  else
+    "ruby"
+  end unless defined? RUBY_APP
+end

data/rake_tasks/generation.rake

@@ -0,0 +1,37 @@
+namespace :generate do
+  desc "Generate class diagrams"
+  task :diagrams do
+    require 'funfx/meta/generator'
+		require 'funfx/meta/parser'
+
+    diagrams = {
+      :all    => nil,
+      :first  => %w{FlexMenuBar FlexLabel FlexObject},
+      :second => %w{FlexButton FlexRadioButton FlexPopUpButton FlexCheckBox FlexDateChooser FlexSlider},
+      :third  => %w{FlexLabel FlexProgressBar FlexNumericStepper FlexLoader FlexRule FlexVideoDisplay},
+    }
+    
+    lib = FunFX::Meta::ClassLib.new
+    diagrams.each do |file, names|
+      classes = lib.classes(names)
+      generator = FunFX::Meta::Generator.new(classes, :class_dot)
+      dot = "website/diagrams/#{file}.dot"
+      pdf = "website/diagrams/#{file}.pdf"
+      File.open(dot, 'wb') {|io| io.write generator.generate}
+      sh "dot -T pdf -o #{pdf} #{dot}"
+      rm dot
+    end
+  end
+
+  desc "Generate code"
+  task :code do
+    require 'funfx/meta/generator'
+		require 'funfx/meta/parser'
+
+    lib = FunFX::Meta::ClassLib.new
+    classes = lib.classes
+    generator = FunFX::Meta::Generator.new(classes, :code)
+    code = 'lib/funfx/flex/elements.rb'
+    File.open(code, 'wb') {|io| io.write generator.generate}
+  end
+end

data/rake_tasks/hoe_ext.rake

@@ -0,0 +1,11 @@
+task :release do
+  puts %{
+************************************
+Now it's time to make a tag in Git:
+
+tag -a "v#{FunFX::VERSION::STRING}" -m "Release #{FunFX::VERSION::STRING}"
+git push --tags
+************************************
+  }
+  
+end

data/rake_tasks/rspec.rake

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+
+namespace :spec do
+  desc "Run the API specs"
+  Spec::Rake::SpecTask.new(:api) do |t|
+    t.rcov = true
+    t.rcov_opts = ["--exclude gems,spec"]
+    t.spec_opts = ['--options', "spec/spec.opts"]
+    t.spec_files = FileList['spec/funfx/flex/**/*_spec.rb']
+  end
+
+  desc "Run the meta specs (code generation)"
+  Spec::Rake::SpecTask.new(:meta) do |t|
+    t.spec_opts = ['--options', "spec/spec.opts"]
+    t.spec_files = FileList['spec/funfx/meta/**/*_spec.rb']
+  end
+
+  desc "Run the Demo App specs"
+  Spec::Rake::SpecTask.new(:demo_app) do |t|
+    t.rcov = true
+    t.rcov_opts = ["--exclude gems,spec"]
+    t.spec_opts = ['--options', "spec/spec.opts"]
+    t.spec_files = FileList['spec/funfx/demo_app/**/*_spec.rb']
+  end
+end
+
+task :spec => ['spec:api', 'spec:meta', 'spec:demo_app']

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/funfx.rb'}"
+puts "Loading funfx gem"
+exec "#{irb} #{libs} --simple-prompt"