extjs-mvc 0.3.10 → 0.4.0.a

data/lib/extjs/component.rb

@@ -1,71 +0,0 @@
-##
-# @class ExtJS::Component
-#
-class ExtJS::Component
-  attr_accessor :config
-  def initialize(params)
-    @config = params#params.extract_options!
-    @controller = @config.delete(:controller) unless @config[:controller].nil?
-
-    @config["items"] = [] if config["items"].nil?
-
-    if container = @config.delete(:container)
-      container.add(self)
-    end
-    @partial_config = nil
-  end
-
-  def apply(params)
-    @config.merge!(params)
-  end
-
-  ##
-  # Adds a config {} or ExtJS::Component instance to this component's items collection.
-  # NOTE:  When :partial option is used a String will of course be returned.  Otherwise an ExtJS::Component
-  # instance will be returned.
-  # @return {String/ExtJS::Component}
-  def add(*config)
-
-    options = config.extract_options!
-    if !options.keys.empty?
-      if url = options.delete(:partial)
-        # rendering a partial, cache the config until partial calls #add method.  @see else.
-        @partial_config = options
-        if (@controller.respond_to?(:partial))
-          # Merb
-          return @controller.partial(url, :with => self, :as => :container)
-        else
-          # Rails
-          return @controller.render(:partial => url, :locals => {:container => self})
-        end
-      else
-        options.merge!(@partial_config) unless @partial_config.nil?
-        options[:controller] = @controller unless @controller.nil?
-        cmp = ExtJS::Component.new(options)
-        @partial_config = nil
-        @config["items"] << cmp
-        return cmp
-      end
-    elsif !config.empty? && config.first.kind_of?(ExtJS::Component)
-      cmp = config.first
-      cmp.apply(@partial_config) unless @partial_config.nil?
-      @partial_config = nil
-      @config["items"] << cmp.config
-      return cmp
-    end
-  end
-
-  def to_json
-    config.to_json
-  end
-
-  def render
-    @config.delete("items") if @config["items"].empty?
-
-    # If there are any listeners attached in json, we have to get rid of double-quotes in order to expose
-    # the javascript object.
-    # eg:  "listeners":"SomeController.listeners.grid" -> {"listeners":SomeController.listeners.grid, ...}
-    json = @config.to_json.gsub(/\"(listeners|handler|scope)\":\s?\"([a-zA-Z\.\[\]\(\)]+)\"/, '"\1":\2')
-    "Ext.ComponentMgr.create(#{json});"
-  end
-end

data/lib/extjs/data/store.rb

@@ -1,131 +0,0 @@
-##
-# ExtJS::Data::Store
-#
-module ExtJS::Data
-  class Store
-    attr_accessor :id, :format, :type, :controller, :model
-
-    def initialize(*params)
-      options = params.extract_options!
-      
-      @config     = options[:config] || {}
-      @format     = options[:format] || 'json'
-      @fieldset   = options[:fieldset] || :default
-      @schema     = options[:schema]
-      @proxy      = options[:proxy] || 'http'
-      @writer     = options[:writer]
-      @type       = (options[:type].nil?) ? @proxy === 'direct' ? 'Ext.data.DirectStore' : "Ext.data.#{@format.capitalize}Store" : options[:type] 
-      
-      @controller = self.class.get_controller(options[:controller])
-      @model      = self.class.get_model(options[:controller], options[:model])
-
-      # Merge Reader/Proxy config
-      @config.merge!(reader)
-      @config.merge!(proxy)
-      
-      @config["baseParams"] = {} if @config["baseParams"].nil?
-      @config["baseParams"].update("fieldset" => @fieldset)
-      
-      @config["format"] = @format
-
-      # Set storeId implicitly based upon Model name if not set explicitly
-      @id = @config["storeId"] = @model.to_s.downcase unless @config["storeId"]
-    end
-
-    ##
-    # pre-load a store with data.  Not yet tested.  In theory, this *should* work.
-    #
-    def load(*params)
-      #@config["loadData"] = @model.all(params).collect {|rec| rec.to_record }
-    end
-
-    ##
-    # renders the configured store
-    # @param {Boolean} script_tag [true] Not yet implemented.  Always renders <script></script> tags.
-    def render(script_tag = true)
-      script = ''
-      # ugly hack for DirectProxy API.  Have to add an Ext.onReady() after the Store constructor to set API
-      if @proxy === 'direct'
-        auto_load = @config.delete("autoLoad")
-        cname = @controller.controller_name.capitalize
-        script = "Ext.onReady(function() { var s = Ext.StoreMgr.get('#{@config["storeId"]}');"
-        if (@config["directFn"])
-          script += "s.proxy.directFn = #{cname}.#{@config["directFn"]};"
-        else
-          script += "s.proxy.setApi({create:#{cname}.#{@config["api"]["create"]},read:#{cname}.#{@config["api"]["read"]},update:#{cname}.#{@config["api"]["update"]},destroy:#{cname}.#{@config["api"]["destroy"]}});"
-        end
-        if auto_load
-          script += "s.load();"
-        end
-        script += "});"
-      end
-
-      if @writer  # <-- ugly hack because 3.0.1 can't deal with Writer as config-param
-        json = @config.to_json
-        json[json.length-1] = ','
-        json += "\"writer\":new Ext.data.#{@format.capitalize}Writer(#{@writer.to_json})}"
-        "<script>new #{@type}(#{json});#{script}</script>"
-      else
-        "<script>new #{@type}(#{@config.to_json});#{script}</script>"
-      end
-    end
-    
-private
-
-    def self.get_controller(name)
-      begin
-        if (defined?(Rails))
-          "#{name.to_s.camelize}Controller".constantize
-        else
-          Extlib::Inflection.constantize("#{Extlib::Inflection.camelize(name)}")
-        end
-      rescue NameError
-        throw NameError.new("ExtJS::Store failed with an unknown controller named '#{name.to_s}'")
-      end
-    end
-        
-    def self.get_model(controller, model)
-      unless model.class == Class
-        begin
-          if (defined?(Rails))
-            model = ((model) ? model : controller.singularize).camelize.constantize
-          else
-            model = Extlib::Inflection.constantize(Extlib::Inflection.camelize(((model) ? model : Extlib::Inflection.singularize(controller))))
-          end
-        rescue NameError => e
-          throw NameError.new("EXTJS::Store found an unknown model #{model.to_s})")
-        end
-      end
-      model
-    end
-    
-    def proxy
-      proxy = {}
-      if @proxy === 'direct'
-        actions = ['create', 'read', 'update', 'destroy']
-        proxy["api"] = {}
-        @controller.direct_actions.each_index do |n|
-          proxy["api"][actions[n]] = @controller.direct_actions[n][:name]
-        end
-      else
-        if @config["api"]
-          proxy["api"] = {}
-          @config["api"].each {|k,v| proxy["api"][k] = "/#{@controller.controller_name}/#{v}" }
-        else
-          proxy["url"] = "/#{@controller.controller_name}.#{@format.to_s}"
-        end
-      end
-      proxy
-    end
-    
-    def reader 
-      {
-        "successProperty" => @controller.extjs_success_property,
-        "root" => @controller.extjs_root,
-        "messageProperty" => @controller.extjs_message_property
-      }.merge(@schema || @model.extjs_record(@fieldset))
-    end
-    
-    
-  end
-end

data/lib/helpers/component.rb

@@ -1,37 +0,0 @@
-##
-# ExtJS::Helpers::Component
-#
-module ExtJS::Helpers
-  module Component
-    ##
-    # add class-var @@extjs_on_ready
-    def self.included(helper)
-
-    end
-
-    def extjs_component(*params)
-      options = params.extract_options!
-      options[:controller] = self
-      ExtJS::Component.new(options)
-    end
-
-    ##
-    # Adds a script or ExtJS::Component instance to on_ready queue.  The queue is emptied and rendered to
-    # <script></script> via #extjs_render
-    #
-    def extjs_onready(*params)
-      @onready_queue = [] if @onready_queue.nil?
-      params.each do |cmp|
-        @onready_queue << cmp
-      end
-    end
-
-    ##
-    # Empties the on_ready queue.  Renders within <script></script> tags
-    #
-    def extjs_render
-      @onready_queue = [] if @onready_queue.nil?
-      "<script>\nExt.onReady(function() {\n\t#{@onready_queue.collect {|cmp| (cmp.kind_of?(ExtJS::Component)) ? cmp.render : cmp}.join("\n\t")}\n });\n</script>"
-    end
-  end
-end

data/lib/helpers/store.rb

@@ -1,7 +0,0 @@
-module ExtJS::Helpers
-  module Store
-    def extjs_store(*params)
-       ExtJS::Data::Store.new(*params)
-    end
-  end
-end

data/lib/model/active_record.rb

@@ -1,89 +0,0 @@
-##
-# ActiveRecord adapter to ExtJS::Model mixin.
-#
-module ExtJS
-  module Model
-    module ClassMethods
-      
-      def extjs_primary_key
-        self.primary_key.to_sym
-      end
-      
-      def extjs_column_names
-        self.column_names.map(&:to_sym)
-      end
-      
-      def extjs_columns_hash
-        self.columns_hash.symbolize_keys
-      end
-      
-      ##
-      # determine if supplied Column object is nullable
-      # @param {ActiveRecord::ConnectionAdapters::Column}
-      # @return {Boolean}
-      #
-      def extjs_allow_blank(col)
-        # if the column is the primary key always allow it to be blank.
-        # Otherwise we could not create new records with ExtJS because
-        # new records have no id and thus cannot be valid
-        col.name == self.primary_key || col.null
-      end
-      
-      ##
-      # returns the default value
-      # @param {ActiveRecord::ConnectionAdapters::Column}
-      # @return {Mixed}
-      #
-      def extjs_default(col)
-        col.default
-      end
-      
-      ##
-      # returns the corresponding column name of the type column for a polymorphic association
-      # @param {String/Symbol} the id column name for this association
-      # @return {Symbol}
-      def extjs_polymorphic_type(id_column_name)
-        id_column_name.to_s.gsub(/_id\Z/, '_type').to_sym
-      end
-      
-      ##
-      # determine datatype of supplied Column object
-      # @param {ActiveRecord::ConnectionAdapters::Column}
-      # @return {String}
-      #
-      def extjs_type(col)
-        type = col.type.to_s
-        case type
-          when "datetime", "date", "time", "timestamp"
-            type = "date"
-          when "text"
-            type = "string"
-          when "integer"
-            type = "int"
-          when "decimal"
-            type = "float"
-        end
-        type
-      end
-      
-      ##
-      # return a simple, normalized list of AR associations having the :name, :type and association class
-      # @return {Array}
-      #
-      def extjs_associations
-        @extjs_associations ||= self.reflections.inject({}) do |memo, (key, assn)|
-          type = (assn.macro === :has_many || assn.macro === :has_and_belongs_to_many) ? :many : assn.macro
-          memo[key.to_sym] = {
-            :name => key.to_sym, 
-            :type => type, 
-            :class => assn.options[:polymorphic] ? nil : assn.class_name.constantize,
-            :foreign_key => assn.association_foreign_key.to_sym,
-            :is_polymorphic => !!assn.options[:polymorphic]
-          }
-          memo
-        end
-      end
-    end
-  end
-end
-