lipsiadmin 2.9

data/lib/view/helpers/ext/column_model.rb

@@ -0,0 +1,73 @@
+module Lipsiadmin
+  module Ext
+    # Generate a new Ext.grid.ColumnModel
+    #
+    #   Examples:
+    # 
+    #     var columnModel = new Ext.grid.ColumnModel({
+    #       columns: [{
+    #         header: "Name",
+    #         dataIndex: "name"
+    #       },{
+    #         header: "Category",
+    #         dataIndex: "category_name",
+    #         query: "categories.name LIKE {query}"
+    #       },{
+    #         header: "Date",
+    #         dataIndex: "date"
+    #       },{
+    #         header: "Created At",
+    #         dataIndex: "created_at"
+    #     }]});
+    #     
+    #   ColumnModel.new do |columns|
+    #     columns.add :name,             "Name"
+    #     columns.add :category_name,    "Category",      :dataIndex => "categories.name"
+    #     columns.add :date,             "Date"
+    #     columns.add :created_at,       "Created At"
+    #   end
+    #     
+    class ColumnModel < Component      
+      def initialize(options={}, &block)#:nodoc:
+        super("Ext.grid.ColumnModel", { :columns => [] }.merge(options), &block)
+      end
+      
+      # This add automatically fields from an array
+      def fields(fields)
+        fields.each { |options| add(nil, nil, options)  }
+      end
+      
+      # Add columns to a Ext.grid.ColumnModel
+      #
+      #   # Generates: { header: "Created At", dataIndex: "accounts.datetime", sortable => true }
+      #   add "Created At", "accounts.datetime", :sortable => l(true)
+      # 
+      # You can pass :renderer
+      #   
+      #   # Generates: Ext.util.Format.dateRenderer()
+      #   :renderer => :date
+      #   # Generates: Ext.util.Format.dateTimeRenderer()
+      #   :renderer => :datetime
+      #   # Generates: Ext.util.Format.eurMoney
+      #   :renderer => :eur_money
+      #   # Generates: Ext.util.Format.usMoney
+      #   :renderer => :us_money
+      #   # Generates: Ext.util.Format.boolRenderer
+      #   :renderer => :boolean
+      # 
+      def add(name=nil, data=nil, options={})
+        options[:header] = name if name
+        options[:dataIndex] = data if data
+        case options[:renderer]
+          when :date        then options.merge!(:renderer => l("Ext.util.Format.dateRenderer()"))
+          when :datetime    then options.merge!(:renderer => l("Ext.util.Format.dateTimeRenderer()"))
+          when :eur_money   then options.merge!(:renderer => l("Ext.util.Format.eurMoney"))
+          when :us_money    then options.merge!(:renderer => l("Ext.util.Format.usMoney"))
+          when :boolean     then options.merge!(:renderer => l("Ext.util.Format.boolRenderer"))
+        end
+        raise ComponentError, "You must provide header and dataIndex for generate a column model" if options[:header].blank? || options[:dataIndex].blank?
+        config[:columns] << Configuration.new(options)
+      end
+    end
+  end
+end

data/lib/view/helpers/ext/component.rb

@@ -0,0 +1,163 @@
+module Lipsiadmin#:nodoc:
+  module Ext#:nodoc:
+    
+    class ComponentError < StandardError; end#:nodoc:
+    
+    # This is the base class of ext components
+    # 
+    # You can generate your custom ExtJs objects like:
+    # 
+    #   # Generates: 
+    #   #   var groupingView = Ext.grid.GroupingView({
+    #   #     forceFit: true
+    #   #   });
+    # 
+    #   Component.new("Ext.grid.GroupingView", { :forceFit => true });
+    # 
+    class Component      
+
+      def initialize(klass, options={}, &block)#:nodoc:
+        @klass = klass
+        @config = Configuration.new(options)
+        @before, @after = [], []
+        yield self if block_given?
+      end
+      
+      # The id of the component
+      #
+      def id(new_id)
+        @config[:id] = new_id
+      end
+      
+      # Set var used by the component
+      # 
+      #   Generates: var myVar = new Ext.Grid({...});
+      #   store.var "myVar"
+      #
+      def var(var)
+        @var = var
+      end
+
+      # Get the var used by the component defaults is the id of the component
+      #      
+      def get_var
+        # I will nillify obj if they are blank
+        @var = nil     if @var == ""
+        @config[:var]  if @config[:var] == ""
+        # Return a correct var
+        @var || @config[:var] || (@klass.split(".").last.demodulize.slice(0..0).downcase + @klass.split(".").last.demodulize.slice(1..-1))
+      end
+      
+      # Write the the configuration of object from an hash
+      #
+      def config=(options={})
+        @config = Configuration.new(options)
+      end
+
+      # Read the the configuration of object from an hash
+      #
+      def config
+        @config
+      end
+      
+      def method_missing(method, arg=nil)#:nodoc:
+        if method.to_s.start_with?("get_")
+          @config[method.to_s.gsub("get_", "").to_sym]
+        else
+          @config[method.to_sym] = arg
+        end
+      end
+      
+      # Returns an array of javascripts to add before component is rendered.
+      #      
+      def before
+        @before
+      end
+
+      # Returns the javascript to add before component is rendered.
+      #
+      def before_js
+        @before.uniq.compact.join("\n\n") + "\n\n"
+      end
+      
+      # Returns an array of javascripts to add afters component is rendered.
+      #
+      def after
+        @after
+      end
+      
+      # Returns the javascript to add after component is rendered.
+      #   
+      def after_js
+        "\n\n" + @after.uniq.compact.join("\n\n")
+      end
+      
+      
+      # Generates a new handler for the given component
+      # 
+      #   Examples:
+      #     
+      #     # Generates:
+      #     #     grid.on("dblclick", function() { 
+      #     #       edit();
+      #     #       new();
+      #     #       Ext.Msg.alert("Hello", "world");
+      #     #     });
+      # 
+      #     grid.on :dblclick do |p|
+      #       p.call "edit"
+      #       p.call "new"
+      #       p.ext_alert "Hello", "world"
+      #     end
+      def on(event, function=nil, scope=nil, &block)
+        # Remove old handlers
+        @after.delete_if { |s| s.start_with?("#{get_var}.on(#{event.to_json}") if s.is_a?(String) }
+        scope = ", #{scope}" unless scope.blank?        
+        if function
+          after << "#{get_var}.on(#{event.to_json}, #{function}#{scope});"
+        else
+          generator = ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.new(self, &block)
+          after << "#{get_var}.on(#{event.to_json}, function() { \n  #{generator.to_s.gsub("\n", "\n  ")}\n}#{scope});"
+        end
+      end
+      
+      def with_output_buffer(buf = '')#:nodoc:
+        yield
+      end
+      
+      
+      # Returns the javascript example
+      #
+      #   # Generates: var rowSelectionModel = Ext.grid.RowSelectionModel();
+      #   Component.new("Ext.grid.RowSelectionModel")
+      # 
+      def to_s
+        "var #{get_var} = new #{@klass}(#{config.to_s});"
+      end
+      
+      def raise_error(error)#:nodoc:
+         raise ComponentError, error
+      end
+      
+      # Returns an object whose <tt>to_json</tt> evaluates to +code+. Use this to pass a literal JavaScript 
+      # expression as an argument to another JavaScriptGenerator method.
+      #
+      def literal(code)
+        ActiveSupport::JSON::Variable.new(code.to_s)
+      end
+      alias_method :l, :literal
+
+      private
+        def javascript_object_for(object)
+          object.respond_to?(:to_json) ? object.to_json : object.inspect
+        end
+        alias_method :s, :javascript_object_for
+        
+        def render_javascript(template, assigns)
+          assigns.each { |key, value| instance_variable_set("@#{key}", value) }
+          template = File.read("#{File.dirname(__FILE__)}/templates/#{template}.js.erb")
+          return ERB.new(template).result(binding)
+        end
+    end
+  end
+end

data/lib/view/helpers/ext/configuration.rb

@@ -0,0 +1,36 @@
+module Lipsiadmin
+  module Ext
+    # Ext configuration used by components
+    # 
+    #   Generates: { name: 'name', handler: function(){ alert('Hello World') } }
+    #
+    class Configuration < Hash
+      
+      def initialize(hash)#:nodoc:
+        hash.each { |k,v| self[k] = v }
+      end
+      
+      # Returns the configuration as a string.
+      # Optionally you can specify the indentation spaces.
+      def to_s(indent=1)
+        return if self.empty?
+        i = ("  "*indent)
+        s = self.size > 0 ? "\n" : "  "
+        "{#{s}" + self.collect { |k,v| "#{i*2}#{k}: #{s(v)}" if k != :var }.join(",#{s}") + "#{s}#{i}}"
+      end
+      
+      private
+        def javascript_object_for(object)
+          case object
+            when Configuration
+              object.to_s(2)
+            when Array
+              "[" + object.collect { |o| s(o) }.join(",") + "]"
+            else
+              object.respond_to?(:to_json) ? object.to_json : object.inspect
+          end
+        end
+        alias_method :s, :javascript_object_for
+    end
+  end
+end

data/lib/view/helpers/ext/grid.rb

@@ -0,0 +1,281 @@
+module Lipsiadmin
+  module Ext
+    # Generate a full customizable Ext.GridPanel
+    #
+    # Examples:
+    #
+    #   # Returns:
+    #   #   var grid = new Ext.grid.GridPanel({
+    #   #     clicksToEdit: 1,
+    #   #     border: false,
+    #   #     bodyBorder: false,
+    #   #     store: store,
+    #   #     view: groupingView,
+    #   #     region: "center",
+    #   #     sm: new Ext.grid.CheckboxSelectionModel(),
+    #   #     bbar: pagingToolbar,
+    #   #     plugins: [new Ext.grid.Search()],
+    #   #     viewConfig: { forceFit: true },
+    #   #     id: "grid-posts",
+    #   #     cm: columnModel,
+    #   #     tbar: toolBar
+    #   #   });
+    #
+    #   page.grid do |grid|
+    #     grid.id "grid-posts"
+    #     grid.title "List all Post"
+    #     grid.base_path "/backend/posts"
+    #     grid.forgery_protection_token request_forgery_protection_token
+    #     grid.authenticity_token form_authenticity_token
+    #     grid.tbar  :default
+    #     grid.store do |store|
+    #       store.url "/backend/posts.json"
+    #       store.fields @column_store.store_fields
+    #     end
+    #     grid.columns do |columns|
+    #       columns.fields @column_store.column_fields
+    #     end
+    #     grid.bbar  :store => grid.get_store, :pageSize => params[:limit]
+    #   end
+    # 
+    class Grid < Component
+      def initialize(options={}, &block)#:nodoc:
+        # Call Super Class for initialize configuration
+        super("Ext.grid.GridPanel", options)
+        
+        # Write default configuration if not specified
+        config[:plugins]      ||= []
+        viewConfig            l("{ forceFit: true }")       
+        clicksToEdit          l(1)                          
+        border                l(false)                      
+        bodyBorder            l(false)                      
+        region                "center"                      
+        sm                    :checkbox                     
+        add_plugin            l("new Ext.grid.Search()")    
+        view                  :default                      
+        on(:dblclick, :edit, l("this"))          
+        
+        yield self if block_given?
+      end
+      
+      # Define the selection model of this grid.
+      # You can pass: 
+      #   
+      # * :checkbox || :default
+      # * :row
+      # * custom (eg. Component.new("some"))
+      # 
+      # It generate some like:
+      # 
+      #   new Ext.grid.CheckboxSelectionModel()
+      # 
+      def sm(value)
+        selmodel = case value
+          when :default  then Component.new("Ext.grid.CheckboxSelectionModel")
+          when :checkbox then Component.new("Ext.grid.CheckboxSelectionModel")
+          when :row      then Component.new("Ext.grid.RowSelectionModel")
+          when Component then value
+        end
+        before << selmodel.to_s
+        config[:sm] = l(selmodel.get_var)
+      end
+      
+      # Define the title of the grid
+      def title(title)
+        before << "Backend.app.setTitle(#{title.to_json});"
+      end
+      
+      # Assign plugins for the current grid
+      def plugins(plugins)
+        config[:plugins] = plugins
+      end
+      
+      # Add a single plugin to the grid plugins
+      def add_plugin(plugins)
+        config[:plugins] << plugins
+      end
+          
+      # Generate or set a new Ext.Toolbar
+      # You can pass tbar :default options that will create 
+      # defaults buttons for add, edit and remove records, it's generate also
+      # the javascript for manage them.
+      # for use this you need to set for the grid the: +base_path+, +forgery_protection_token+,
+      # +authenticity_token+ and +store+.
+      #
+      #   Examples:
+      #     var toolBar = new Ext.Toolbar([{
+      #         handler: add,
+      #         disabled: false,
+      #         text: Backend.locale.buttons.add,
+      #         cls: "x-btn-text-icon add",
+      #         id: "add"
+      #      },{
+      #         handler: edit,
+      #         disabled: true,
+      #         text: Backend.locale.buttons.edit,
+      #         cls: "x-btn-text-icon edit",
+      #         id: "edit"
+      #      },{
+      #         handler: remove,
+      #         disabled: true,
+      #         text: Backend.locale.buttons.remove,
+      #         cls: "x-btn-text-icon remove",
+      #         id: "remove"
+      #     }]);
+      #
+      #   tbar  :default
+      # 
+      def tbar(obj=nil, &block)
+        tbar = obj.is_a?(ToolBar) ? obj : ToolBar.new
+        if obj == :default
+          tbar.add l("Backend.locale.buttons.add"),    :id => "add",    :disabled => literal(false), :cls => "x-btn-text-icon add",    :handler => l("add")
+          tbar.add l("Backend.locale.buttons.edit"),   :id => "edit",   :disabled => literal(true),  :cls => "x-btn-text-icon edit",   :handler => l("edit")
+          tbar.add l("Backend.locale.buttons.remove"), :id => "remove", :disabled => literal(true),  :cls => "x-btn-text-icon remove", :handler => l("remove")
+          @default_tbar = true 
+        end
+        yield tbar if block_given?
+        before << tbar.to_s
+        after  << tbar.after
+        config[:tbar] = l(tbar.get_var)
+      end
+      
+      # Generate or set a new Ext.Toolbar
+      # 
+      #   Examples:
+      #     bbar: new Ext.PagingToolbar({
+      #       pageSize: <%= params[:limit] %>,
+      #       store: js,
+      #       displayInfo: true
+      #     })
+      #   bbar :pageSize => params[:limit], :store => store.get_var, displayInfo: true
+      # 
+      def bbar(value=nil, &block)
+        bbar = value.is_a?(Hash) ? Component.new("Ext.PagingToolbar", value) : value
+        before << bbar.to_s
+        after  << bbar.after
+        config[:bbar] = l(bbar.get_var)
+      end
+
+      # Generate or set a new Ext.grid.GroupingView
+      # You can pass tbar :default options that will autocreate a correct GroupingView
+      # 
+      #   Examples:
+      #     view: new Ext.grid.GroupingView({
+      #       forceFit:true,
+      #       groupTextTpl: '{text} ({[values.rs.length]} {[values.rs.length > 1 ? "Foo" : "Bar"]})'
+      #     })
+      #   view :forceFit => true, :groupTextTpl => "{text} ({[values.rs.length]} {[values.rs.length > 1 ? "Foo" : "Bar"]})"
+      # 
+      def view(value=nil, &block)
+        if value.is_a?(Symbol) && (value == :default)
+          view = Component.new("Ext.grid.GroupingView", { :forceFit => true })
+        elsif value.is_a?(Hash)
+          view = Component.new("Ext.grid.GroupingView", { :forceFit => true })
+        else
+          view = value
+        end
+        
+        before << view.to_s
+        after  << view.after
+        config[:view] = l(view.get_var)
+      end
+      
+      # Generate or set a new Ext.data.GroupingStore
+      def store(value=nil, url=nil, &block)
+        datastore = value.is_a?(Store) ? value : Store.new(&block)
+        before << datastore.to_s
+        after  << datastore.after
+        config[:store] = l(datastore.get_var)
+      end
+      
+      # Generate or set new Ext.grid.ColumnModel
+      def columns(value=nil, &block)
+        options = { :columns => [] }
+        if config[:sm] && before.find { |js| js.start_with?("var #{config[:sm]} = new Ext.grid.CheckboxSelectionModel") }
+          options[:columns] << config[:sm]
+        end
+        columnmodel = value.is_a?(ColumnModel) ? value : ColumnModel.new(options, &block)
+        before << columnmodel.to_s
+        after  << columnmodel.after
+        config[:cm] = l(columnmodel.get_var)
+      end
+      
+      # The base_path used for ToolBar, it's used for generate [:new, :edit, :destory] urls
+      def base_path(value)
+        @base_path = value
+      end
+      
+      # The path for ToolBar New Button, if none given we use the base_path
+      def new_path(value)
+        @new_path = value
+      end
+      
+      # The path for ToolBar Edit Button, if none given we use the base_path
+      def edit_path(value)
+        @edit_path = value
+      end
+      
+      # The path for ToolBar Delete Button, if none given we use the base_path
+      def destroy_path(value)
+        @destroy_path = value
+      end
+      
+      # The forgery_protection_token used for ToolBar
+      def forgery_protection_token(value)
+        @forgery_protection_token = value
+      end
+      
+      # The authenticity_token used for ToolBar
+      def authenticity_token(value)
+        @authenticity_token = value
+      end
+      
+      # Returns getSelectionModel().getSelected()
+      # 
+      #   Examples:
+      # 
+      #     # Generates: grid.getSelectionModel().getSelected().id
+      #     grid.get_selected
+      #     
+      #     # Generates: getSelectionModel().getSelected().data['name']
+      #     grid.get_selected(:name)
+      # 
+      def get_selected(data=:id)
+        raise_error "No Column Selection Model Defined" if config[:sm].blank?
+        if data.to_sym == :id
+          l("#{config[:sm]}.getSelected().id")
+        else
+          l("#{config[:sm]}.getSelected().data[#{data.to_json}]")
+        end
+      end
+      
+      # Return the javascript for create a new Ext.grid.GridPanel
+      def to_s
+        if @default_tbar
+          raise_error "You must provide the base_path for autobuild toolbar."                      if @base_path.blank? && @new_path.blank? && @edit_path.blank? && @destroy_path.blank?
+          raise_error "You must provide the new_path for autobuild button new of toolbar."         if @base_path.blank? && @new_path.blank?
+          raise_error "You must provide the edit_path for autobuild button edit of toolbar."       if @base_path.blank? && @edit_path.blank?
+          raise_error "You must provide the destroy_path for autobuild button destroy of toolbar." if @base_path.blank? && @destroy_path.blank?
+          raise_error "You must provide the forgery_protection_token for autobuild toolbar."       if @forgery_protection_token.blank?
+          raise_error "You must provide the authenticity_token for autobuild toolbar."             if @authenticity_token.blank?
+          raise_error "You must provide the grid for autobuild toolbar."                           if get_var.blank?
+          raise_error "You must provide the selection model for autobuild toolbar."                if config[:sm].blank?
+          raise_error "You must provide the store."                                                if config[:store].blank?
+        end
+        
+        if @default_tbar
+          after << render_javascript(:grid_functions, :var => get_var, :store => config[:store], :sm => config[:sm], :tbar => config[:tbar])
+        end
+        
+        if config[:store]
+          after << "#{config[:store]}.on('beforeload', function(){ Backend.app.mask(); });"
+          after << "#{config[:store]}.on('load', function(){ Backend.app.unmask(); });"
+          after << "#{config[:store]}.load();"
+        end
+        
+        after << "Backend.app.addItem(#{get_var})"
+        "#{before_js}var #{get_var} = new Ext.grid.GridPanel(#{config.to_s});#{after_js}"
+      end
+    end
+  end
+end