flex_scaffold 0.1.0

data/lib/mtag_helper.rb

@@ -0,0 +1,98 @@
+require 'cgi'
+require 'erb'
+
+module ActionView
+  module Helpers #:nodoc:
+    # Use these methods to generate Flex <mx:> tags programmatically when you can't use
+    # a Builder. By default, they output XML compliant tags.
+    module TagHelper
+      include ERB::Util
+
+      # Returns an empty XML tag of type +name+ which by default is XML 
+      # compliant. Add attributes by passing an attributes 
+      # hash to +options+. For attributes with no value like (disabled and 
+      # readonly), give it a value of true in the +options+ hash. You can use
+      # symbols or strings for the attribute names.
+      #
+      #   tag("TextInput") 
+      #    # => <mx:TextInput />
+      #   tag("TextInput", { :id => 'field_desc', :width => '274', text => '{ image_grid.selectedItem.desc }' }) 
+      #    # => <mx:TextInput width="274" text="{ image_grid.selectedItem.desc }" id="field_desc" />
+      def mx_tag(name, options = nil, open = false)
+        name = name.to_s.camelize
+        "<#{tag_ns}#{name}#{tag_options(options) if options} />"
+      end
+
+      # Returns an XML block tag of type +name+ surrounding the +content+. Add
+      # attributes by passing an attributes hash to +options+. For attributes 
+      # with no value, give it a value of true in 
+      # the +options+ hash. You can use symbols or strings for the attribute names.
+      #
+      #   content_tag('FormItem', content_tag('TextInput'), :id => "image_desc")
+      #    # => <mx:FormItem id="image_desc">
+      #            <mx:TextInput />
+      #         </mx:FormItem>
+      #
+      # Instead of passing the content as an argument, you can also use a block
+      # in which case, you pass your +options+ as the second parameter.
+      #
+      #   <% mx_content_tag 'FormItem', :id => "image_desc" do -%>
+      #      <mx:TextInput />
+      #   <% end -%>
+      #    # => <mx:FormItem id="image_desc"><mx:TextInput /></mx:FormItem>
+      #    
+      # Alternatively to passed in the tag name as a string, you can pass it in as
+      # a symbol and it will be CamelCased
+      # 
+      #   content_tag(:form_item, content_tag(:text_input), :id => "image_desc")
+      #    # => <mx:FormItem id="image_desc">
+      #            <mx:TextInput />
+      #         </mx:FormItem>
+      # 
+      def mx_content_tag(name, content_or_options_with_block = nil, options = nil, &block)
+        name = name.to_s.camelize
+        if block_given?
+          options = content_or_options_with_block if content_or_options_with_block.is_a?(Hash)
+          content = capture(&block)
+          concat(mx_content_tag_string(name, content, options), block.binding)
+        else
+          content = content_or_options_with_block
+          mx_content_tag_string(name, content, options)
+        end
+      end
+
+      # Returns a CDATA section with the given +content+.  CDATA sections
+      # are used to escape blocks of text containing characters which would
+      # otherwise be recognized as markup. CDATA sections begin with the string
+      # <tt><![CDATA[</tt> and end with (and may not contain) the string <tt>]]></tt>.
+      #
+      #   cdata_section("private function clearForm():void {field_title.text = '';}")
+      #    # => <![CDATA[
+      #             private function clearForm():void {
+      #                 field_title.text = '';
+      #             }
+      #         ]]>
+      def cdata_section(content)
+        "<![CDATA[#{content}]]>"
+      end
+
+      # Returns the escaped +xml+ without affecting existing escaped entities.
+      #
+      #   escape_once("1 > 2 &amp; 3")
+      #    # => "1 &lt; 2 &amp; 3"
+      def escape_once(html)
+        fix_double_escape(html_escape(html.to_s))
+      end
+
+      private
+        def mx_content_tag_string(name, content, options)
+          tag_options = options ? tag_options(options) : ""
+          "<#{tag_ns}#{name}#{tag_options}>#{content}</#{name}>"
+        end
+        
+        def tag_ns
+          "mx:"
+        end
+     end
+  end
+end

data/lib/mxml_helper.rb

@@ -0,0 +1,107 @@
+require File.dirname(__FILE__) + '/mtag_helper'
+
+module ActionView
+  module Helpers
+    # Provides functionality for working with MXML in your views.
+    #
+    # If you wish to use this library and its helpers (ActionView::Helpers::MxmlHelper), 
+    # you must:
+    #
+    # * Use <tt>flex_scaffold :model</tt> in your controller. 
+
+    module MxmlHelper
+    
+      # Returns the ActionScript that link to the model to the server as a REST
+      # +resource+
+      # 
+      # Example:
+      # 	<mx:Script>
+      #  		<![CDATA[
+      #  		
+      #  		private function clearForm():void  {
+      #  	      field_name.text = '';
+      #            field_title.text = '';
+      #            field_size.text = '';
+      #            field_uri.text = '';
+      #            field_desc.text = '';
+      #  	    }
+      #  
+      #  		public function deletegraphics(id:String):void {
+      #  			deletegraphic.url = "/graphics/" + id + ".xml";
+      #  			deletegraphic.send({_method: "DELETE"});
+      #  		}
+      #              
+      #          private function sendgraphicUpdate():void {      	
+      #  			    	
+      #                var params:Object = new Object();
+      #                params['_method'] = "PUT";
+      #                params['graphic[name]'] = field_name.text; 
+      #                params['graphic[title]'] = field_title.text; 
+      #                params['graphic[size]'] = field_size.text; 
+      #                params['graphic[uri]'] = field_uri.text; 
+      #                params['graphic[desc]'] = field_desc.text; 
+      #  
+      #  			   updategraphic.url = "/graphics/" + graphic_grid.selectedItem.id + ".xml";
+      #  	           updategraphic.send(params);
+      #          } 	            
+      #         
+      #          ]]>
+      #    	</mx:Script> 
+      def mx_resource(model, *args)
+      
+      end
+      
+      # Returns the mx HTTPSService defined for a REST service call to rails
+      # 
+      # Example: 
+      #     <mx:HTTPService id="listimage" url="/images.xml" useProxy="false" method="GET"/>
+      #    	<mx:HTTPService id="updateimage" useProxy="false" method="POST" result="listimage.send()"/>
+      #    	<mx:HTTPService id="deleteimage" useProxy="false" method="POST" result="listimage.send()"/>
+      #    	<mx:HTTPService id="createimage" url="/images.xml" useProxy="false" method="POST" result="listimage.send()"
+      #    	   contentType="application/xml">
+      #            <mx:request xmlns="">
+      #                <image>
+      #                   <title>{field_title.text}</title>
+      #                   <filename>{field_filename.text}</filename>
+      #                   <desc>{field_desc.text}</desc>
+      #                   <size>{field_size.text}</size>
+      #                </image>
+      #            </mx:request>
+      #    	</mx:HTTPService>
+
+      def mx_service
+      
+      end
+
+      # Returns the application mxml tag
+      # 
+      # Example:
+      #    <mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" 
+      #    	layout="absolute" 
+      #    	width="100%" 
+      #    	height="100%" 
+      #    	creationComplete="{list<%= singular_name %>.send();}"
+      #    	xmlns:egenial="*"
+      #    	backgroundColor="#808080"
+      #    	backgroundGradientColors="[#808080, #ffffff]">
+      
+      def mx_application(name, *args, &block)
+      
+      end
+
+      # Returns the validators mxml tag
+      # 
+      # Example:
+      #      <mx:StringValidator source="{field_create_title}" property="text" 
+      #        tooShortError="This string is shorter than the minimum allowed length of 4." 
+      #        tooLongError="This string is longer than the maximum allowed length of 255." 
+      #        minLength="4" maxLength="255"  
+      #        trigger="{btn_add_create}" triggerEvent="click" />
+      
+      def mx_validators
+      
+      end
+      
+    end
+  end
+end

data/lib/rest_scaffolding.rb

@@ -0,0 +1,137 @@
+require 'action_controller'
+
+module ActionController # :nodoc:
+  module FlexRestScaffolding # :nodoc:
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+    end
+    
+    # REST Scaffolding provides Flex REST actions for creating, reading,
+    # updating, and destroying records.
+    # 
+    # Also returns the schema for the record
+    #
+    # Example:
+    #
+    #  class ContactsController < ActionController::Base
+    #    flex_scaffold :contacts
+    #  end
+    module ClassMethods
+      # Adds Flex REST actions to the controller.  The options
+      # are the same as for ActionView::Scaffolding.scaffold, except
+      # that the <tt>:suffix</tt> option is not currently supported.
+      #
+      # These are merely the same as a resource albeit a couple of mods
+
+      def flex_scaffold(model_id, options = {})
+        options.assert_valid_keys(:class_name, :suffix, :size)
+        
+        swf_size      = options[:size] || FlexScaffold::Config.default_size
+        singular_name = model_id.to_s
+        class_name    = options[:class_name] || singular_name.camelize
+        plural_name   = singular_name.pluralize
+        
+        class_eval <<-"end_eval", __FILE__, __LINE__
+        # GET /contacts
+        # GET /contacts.xml
+        def index
+          flex_index
+        end
+        
+        def flex_index
+          @#{singular_name} = #{class_name}.find(:all)
+          @swf_name = "_#{plural_name}"
+          @page_title = "#{plural_name.camelize}"
+          @size = "#{swf_size}"
+      
+          respond_to do |format|
+            format.html { render :template => "#{FlexScaffold::Config.plugin_name}/index" } # index.rhtml
+            format.xml  { render :xml => @#{singular_name}.to_xml }
+          end       
+        end
+      
+        # GET /contacts/1
+        # GET /contacts/1.xml
+        def show
+          @#{singular_name} = #{class_name}.find(params[:id])
+      
+          respond_to do |format|
+            format.html # show.rhtml
+            format.xml  { render :xml => @#{singular_name}.to_xml }
+          end
+        end
+      
+        # GET /contacts/new
+        def new
+          @#{singular_name} = #{class_name}.new
+        end
+      
+        # GET /contacts/1;edit
+        def edit
+          @#{singular_name} = #{class_name}.find(params[:id])
+        end
+      
+        # POST /contacts
+        # POST /contacts.xml
+        def create
+          @#{singular_name} = #{class_name}.new(params[:#{singular_name}])
+      
+          respond_to do |format|
+            if @#{singular_name}.save
+              flash[:notice] = '#{class_name} was successfully created.'
+              format.html { redirect_to contact_url(@#{singular_name}) }
+              format.xml  { head :created } # :location => contact_url(@#{singular_name}) # removed from original
+            else
+              format.html { render :action => "new" }
+              format.xml  { render :xml => @#{singular_name}.errors.to_xml }
+            end
+          end
+        end
+      
+        # PUT /contacts/1
+        # PUT /contacts/1.xml
+        def update
+          @#{singular_name} = #{class_name}.find(params[:id])
+      
+          respond_to do |format|
+            if @#{singular_name}.update_attributes(params[:#{singular_name}])
+              flash[:notice] = '#{class_name} was successfully updated.'
+              format.html { redirect_to contact_url(@#{singular_name}) }
+              format.xml  { head :ok }
+            else
+              format.html { render :action => "edit" }
+              format.xml  { render :xml => @#{singular_name}.errors.to_xml }
+            end
+          end
+        end
+      
+        # DELETE /contacts/1
+        # DELETE /contacts/1.xml
+        def destroy
+          @#{singular_name} = #{class_name}.find(params[:id])
+          @#{singular_name}.destroy
+      
+          respond_to do |format|
+            format.html { redirect_to contacts_url }
+            format.xml  { head :ok }
+          end
+        end
+        
+        # GET /contacts/schema/1
+        # GET /contacts/schema/1.xml
+        # TODO: changes routes so that this does not require an ID
+        def schema
+          response.headers["Content-Type"] = "text/xml"
+          render :text => schema_xml(#{class_name})
+        end
+         
+        end_eval
+      end
+    end
+  end
+end
+
+ActionController::Base.class_eval do
+  include ActionController::FlexRestScaffolding
+end

data/lib/validations.rb

@@ -0,0 +1,180 @@
+module FlexScaffold
+
+  class Validations
+      
+    VALIDATIONS_INFO =  %w( message with on in maximum minimum too_short too_long ) 
+    SCHEMA_INFO      =  %w( type limit default ) 
+    
+    def initialize(base={},attrs={}) # :nodoc:
+      @record, @attrs, @schema_attrs = base, attrs, {}
+    end
+
+    # Adds a validation of an attribute (+attr_name+) to the record and returns the individual set
+    # that was added
+    def add(attr_name, type, configuration={})
+       attribute = add_type_to_hash(attr_name, type)
+       VALIDATIONS_INFO.each do |rule| attribute.update(rule.to_s => configuration[rule.to_sym]) unless configuration[rule.to_sym].nil? end      
+      @attrs
+    end
+    
+    # Adds the schema information into the validation of the attributes. This information includes the 
+    # +type+, +limit+, and +default+ values. 
+    def load_schema_info(class_name=@record)
+      @attrs.merge(get_schema_info(class_name))
+    end
+
+    # Returns the schema-based validation information of the attributes. This information includes the 
+    # +type+, +limit+, and +default+ values. It is categorised by the attribute name
+    def get_schema_info(class_name=@record)
+      klass = Object.const_get(class_name.to_s.camelize) rescue nil
+      if klass && klass < ActiveRecord::Base
+         klass.columns.each do |col|
+            attribute = add_schema_to_hash(col.name)
+            SCHEMA_INFO.each do |info| attribute.update(info => eval("col.#{info}.to_s")) end
+        end
+      end
+      @schema_attrs
+    end
+    
+    # Removes all the validations that have been added
+    def clear
+      @attrs = {}
+    end
+    
+    # Returns the attribute validations
+    def validations
+      @attrs
+    end
+    
+    # Yields each attribute and associated details per validation added
+    def each
+      @attrs.each_key { |attr| @attrs[attr].each { |msg| yield attr, msg } }
+    end
+        
+    # Returns true if no validations have been added
+    def empty?
+      @attrs.empty?
+    end
+
+    # Returns the number of attributes with validations
+    def size
+      @attrs.size
+    end
+    
+    # Returns the string of attributes with validations
+    def to_s
+      @attrs.to_s
+    end
+    
+    # Returns an XML representation of the validation object
+    def to_xml
+      @attrs.to_xml
+    end
+    
+    private
+    
+    # TODO: refactor to allow for hierarchical key
+    def add_column_to_hash(hash, key)
+      hash.update(key.to_s => {}) if hash[key.to_s].nil?
+      hash[key.to_s]
+    end
+
+#  "name"=>{"length"=>{"maximum"=>6,
+#                      "too_long"=>"Your name can't be longer than 6 characters"}, 
+#           "presence"=>{}, 
+#           "inclusion"=>{"in"=>["john", "fred", "tom"]}}
+
+    def add_type_to_hash(key, type)
+      add_column_to_hash(add_column_to_hash(@attrs, key), type)
+    end
+
+#  "name"=>{"schema"=>{"default"=>6,
+    
+    def add_schema_to_hash(key)
+      add_column_to_hash(add_column_to_hash(@schema_attrs, key), :schema)
+    end
+        
+  end
+end
+
+module ActiveRecord #:nodoc:
+  
+  class Base
+      
+      # Returns just the validations set in the model on each attribute
+      cattr_accessor :validations
+      @@validations = {}
+
+      class << self
+
+        # Creates an object and returns all validations without persisting
+        def new_validations
+           object = new # this triggers the validations so that they are captured
+           schema = schema_validations
+           object.instance_variable_set(:@validations, schema.merge(validations) )
+           unset_aliases
+           object
+        end
+        
+        # Returns the schema validations defined in the migration
+        def schema_validations
+            FlexScaffold::Validations.new(name).get_schema_info
+        end
+        
+      end
+            
+  end
+  
+  module Validations # :nodoc:
+  
+    def self.included(base) # :nodoc:
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods # :nodoc:
+        
+        VALIDATE_METHODS = %w( presence 
+                               format 
+                               numericality 
+                               exclusion 
+                               inclusion 
+                               uniqueness
+                               length
+                               acceptance)
+
+        VALIDATE_METHODS.each do |method|
+                              
+        class_eval <<-"end_eval", __FILE__, __LINE__
+             alias_method "base_validates_#{method}_of", "validates_#{method}_of"
+             def new_validates_#{method}_of(*attr_names)
+              configuration = {}
+              configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
+              add_validation(:@@validations, attr_names, :#{method}, configuration)
+              base_validates_#{method}_of(attr_names, configuration)
+            end
+            alias_method "validates_#{method}_of", "new_validates_#{method}_of"
+ 
+          end_eval
+        end
+        
+        protected
+        
+        def unset_aliases # :nodoc:
+          sing = class << self; self; end
+          VALIDATE_METHODS.each do |method|
+             sing.send :alias_method, "validates_#{method}_of", "base_validates_#{method}_of"
+          end
+        end
+        
+        private
+        
+        # Update the list of validations for the model. This adds new validations
+        # to the class <tt>@@validations</tt> variable
+        def add_validation(class_var, attr, method, configuration)
+          class_variable_set(class_var, FlexScaffold::Validations.new(nil, class_variable_get(class_var)).add(attr, method, configuration))
+        end
+        
+    end
+  end
+end
+

data/public/crossdomain.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0"?>
+<cross-domain-policy>
+	<allow-access-from domain="*" />
+</cross-domain-policy>
+
+

data/public/history.htm

@@ -0,0 +1,21 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+<script type='text/javascript' language='JavaScript1.2' charset='utf-8'>
+var v = new top.Vars(top.getSearch(window));
+var fv = v.toString('$_');
+</script>
+</head>
+<body >
+<script type='text/javascript' language='JavaScript1.2' charset='utf-8'>
+document.writeln('<object id=\"utility\" name=\" \" classid=\"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000\" codebase=\"" + activexDownloadURL + "#version=7,0,14,0\" width=\"100\" height=\"50\">');
+document.writeln('<param name=\"movie\" value=\"history.swf\" />');
+document.writeln('<param name=\"FlashVars\" value=\"'+fv+'&$_lconid='+top.lc_id+'\"/>');
+document.writeln('<param name=\"quality\" value=\"high\" />');
+document.writeln('<param name=\"bgcolor\" value=\"#FFFFFF\" />');
+document.writeln('<param name=\"profile\" value=\"false\" />');
+document.writeln('<embed id=\"utilityEmbed\" name=\"history.swf\" src=\"history.swf\" type=\"application/x-shockwave-flash\" flashvars=\"'+fv+'&$_lconid='+top.lc_id+'\" profile=\"false\" quality=\"high\" bgcolor=\"#FFFFFF\" width=\"100\" height=\"50\" align=\"\" pluginspage=\"" + pluginDownloadURL + "\"></embed>');
+document.writeln('</object>');
+</script>
+</body>
+</html>