vidl-toolbox 0.0.1

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require File.dirname(__FILE__) << "/lib/toolbox/version"
+
+spec = Gem::Specification.new do |s|
+  s.name = %q{toolbox}
+  s.version = Toolbox::VERSION
+  s.date = %q{2009-01-29}
+  s.authors = ["David Nyffenegger"]
+  s.email = %q{vidl@sunrise.ch}
+  s.summary = %q{Davids toolbox to speedup development with rails (mainly view).}
+  s.homepage = %q{http://github.com/vidl/toolbox}
+  s.description = %q{This toolbox goes in the direction of the django admin interface.}
+  s.files = FileList["[A-Z]*", "{lib,locale,view}/**/*"]
+
+  # rdoc
+  s.has_rdoc         = true
+  #s.extra_rdoc_files = %w(README.rdoc MIT-LICENSE.txt)
+
+  s.add_dependency "activesupport", ">= 2.1.1"
+  s.add_dependency "actionpack", ">= 2.1.1"
+  s.add_dependency "actionpack", ">= 2.1.1"
+  s.add_dependency "gettext", ">= 1.92.0"
+  s.add_dependency "mislav-will_paginate", ">= 2.3.3"
+
+end
+
+desc "Generate a gemspec file for GitHup"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end
+
+desc "Create the gem"
+task :gem => [:makemo, :gemspec] do
+  `gem build #{spec.name}.gemspec`
+end
+
+desc "Generate RDoc"
+task :doc do
+  system "hanna -x Rakefile -x spec --title 'Toolbox #{Toolbox::VERSION} API Documentation'"
+end
+
+desc "Update pot/po files."
+task :updatepo do
+  require 'gettext/utils'  #HERE!
+  GetText.update_pofiles("#{spec.name}", Dir.glob("{lib}/**/*.{rb,erb,rjs}"), "#{spec.name} #{Toolbox::VERSION}")
+end
+
+desc "Create mo-files"
+task :makemo do
+  require 'gettext/utils'  #HERE!
+  GetText.create_mofiles(true, "po", "locale")
+end

data/lib/dirs.rb

@@ -0,0 +1,9 @@
+
+module Toolbox
+  module Dirs
+    GEM_ROOT = File.expand_path("../", File.dirname(__FILE__)) unless defined? GEM_ROOT
+    LOCALE = File.join(GEM_ROOT, '/locale') unless defined? LOCALE
+    VIEW = File.join(GEM_ROOT, '/view') unless defined? VIEW
+
+  end
+end

data/lib/toolbox/config.rb

@@ -0,0 +1,185 @@
+
+module Toolbox
+
+  class WidgetList
+    attr_reader :widgets
+
+    def initialize model_name, widgets, type
+      @widgets = []
+      last = nil
+      h = nil
+      widgets.each do |widget|
+        h = { :name => last, :model_name => model_name}
+        if widget.is_a? Hash
+          raise 'Before an option hash there must be a widget name (string or symbol)' unless last
+          raise 'The item before a option hash must be a string or a symbol' unless last.is_a?(String) || last.is_a?(Symbol)
+          h.merge! widget
+        end
+        @widgets << type.new(h) if last && !last.is_a?(Hash)
+        last = widget
+      end
+      # add the last field, if it's a symbol
+      if last && !last.is_a?(Hash)
+        h = { :name => last, :model_name => model_name}
+        @widgets << type.new(h)
+      end
+    end
+  end
+
+
+  class EditConfig
+    attr_reader :controlsets
+
+    def initialize model_name, config
+      @controlsets = []
+      config.each do |controlset|
+        h = {}
+        h.merge! controlset
+        h[:widget_list] = WidgetList.new(model_name, controlset[:widget_list], ControlConfig)
+        h[:collection_config] = CollectionConfig.new controlset[:collection_config] if controlset[:collection_config]
+        @controlsets << WidgetSetConfig.new(h)
+      end
+    end
+  end
+
+  class ShowConfig
+    attr_reader :fieldsets
+    attr_reader :embedded_lists
+
+    def initialize model_name, config
+      @fieldsets = []
+      config[:fieldsets].each do |fieldset|
+        h = {}
+        h.merge! fieldset
+        h[:widget_list] = WidgetList.new(model_name, fieldset[:widget_list], FieldConfig)
+        h[:collection_config] = CollectionConfig.new fieldset[:collection_config] if fieldset[:collection_config]
+        @fieldsets << WidgetSetConfig.new(h)
+      end
+      @embedded_lists = []
+      prefixes = {}
+      config[:embedded_lists] = config[:embedded_lists] || []
+      config[:embedded_lists].each do |list|
+        h = {}
+        h.merge! list
+        h[:collection_config] = CollectionConfig.new list[:collection_config]
+        h[:widget_list] = WidgetList.new(h[:collection_config].type.name, list[:widget_list], FieldConfig)
+        c = EmbeddedListConfig.new(h)
+        raise "Prefix #{c.prefix} is already used by #{prefixes[c.prefix].label}" if prefixes[c.prefix]
+        prefixes[c.prefix] = c
+        @embedded_lists << c
+      end
+    end
+  end
+
+  # The base class of the configuration classes.
+
+  class Config
+    protected
+    # Use this methods to easily define which options the configuration class supports.
+    # This is done by hash, where each key defines a single option by its name.
+    # The value is a hash that may contain the following keys:
+    # - :required boolean, if true, this option is mandatory, default is false
+    # - :type array of class-names. If set, an exception is raised if the given value is not of the specified type
+    # - :values array of allowed values. If set, an exception is raised if the given value is not withing the specified values.
+    # - :default a default value, that is set, if the option is not given. Otherwise, nil is assgined
+    def self.define_options options
+      # attr_reader for each option
+      options.each_key { |k| attr_reader k }
+      write_inheritable_attribute 'options', options || {}
+    end
+
+    # create the constructor out of the options definition
+    def initialize vars
+      vars.each_pair do |k,v|
+        if respond_to? k.to_sym # set only, if there is an accessor
+          k = '@' + k.to_s
+          instance_variable_set(k.to_sym,v)
+        else
+          raise "Unkown option #{k.to_s} (#{self.class.name.to_s})"
+        end
+      end
+      # check against the definition
+      self.class.read_inheritable_attribute('options').each_pair do |name, opt|
+        val = vars[name]
+        class_name = "(#{self.class.name.to_s}: #{val.inspect})"
+        raise "#{name} is required #{class_name}" if opt[:required] && !val
+        raise "#{name} is #{val.class.to_s} and not of #{opt[:type].join(' or ')} #{class_name}" if opt[:type] && val && !opt[:type].include?(val.class)
+        raise "#{name} is not in #{opt[:values].join(', ')} #{class_name}" if opt[:values] && val && !opt[:values].include?(val)
+        instance_variable_set("@#{name.to_s}".to_sym, opt[:default] || nil) unless val
+      end
+    end
+  end
+
+  # Holds the configuration for a collection. This defines how to render a widget if it's not a simple
+  # type but a collection.
+  class CollectionConfig < Config
+    define_options :type => { :type => [Class], :required => true},
+                   :model_method => { :type => [Symbol], :required => true},
+                   :suppress_table_header => { :default => false},
+                   :hide_empty => { :default => false}
+  end
+
+  # Holds the configuration for a set of widgets. Widgets are either controls of a form
+  # or un-editable fields.
+  class WidgetSetConfig < Config
+    define_options :widget_list => { :type => [WidgetList], :required => true},
+                   :label => { :type => [String], :required => true},
+                   :collection_config => { :type => [CollectionConfig] },
+                   :condition => { :type => [Proc] } # if set, the fieldset is only rendered, if the proc returns true
+  end
+
+  # Holds the configuration for an embedded list
+  class EmbeddedListConfig < Config
+    define_options :widget_list => { :type => [WidgetList], :required => true},
+                   :label => { :type => [String], :required => true},
+                   :collection_config => { :type => [CollectionConfig], :required => true },
+                   :prefix => { :type => [String], :required => true},
+                   :include_assoc => { :type => [Array]}
+  end
+
+  class ActionConfig < Config
+    define_options :label => { :type => [String] },
+                   :name => { :required => true, :type => [Symbol] },
+                   :model_name => { :required => true, :type => [String] }
+  end
+  
+  # Holds the configuration for a from control
+  class ControlConfig < Config
+    define_options :model_method => { :type => [Symbol, Proc]},
+                   :text_method => { :type => [Symbol]}, 
+                   :suppress_label => { :default => false },
+                   :label => { :type => [String] },
+                   :name => { :required => true, :type => [Symbol] },
+                   :model_name => { :required => true, :type => [String] },
+                   :type => { :type => [Symbol], :default => :textfield, :values => [:select, :collection_select, :auto_complete, :textfield, :radio, :date, :check_box]},
+                   :url => { :type => [Symbol]},
+                   :size => { :type => [Fixnum]},
+                   :values => { :type => [Array]}
+  end
+
+  # Holds the configuration for a non-editable field
+  class FieldConfig < Config
+    define_options :model_method => { :type => [Symbol, Proc]},
+                   :hide_empty => { :default => false },
+                   :suppress_label => { :default => false },
+                   :suppress_link => { :default => false },
+                   :suppress_sorting => { :default => false },
+                   :suppress_context_menu => { :default => false},
+                   :order_by => { :type => [String] },
+                   :label => { :type => [String] },
+                   :join => {},
+                   :suffix => {},
+                   :name => { :required => true, :type => [String, Symbol] },
+                   :model_name => { :required => true, :type => [String] },
+                   :trunc => { :type => [Fixnum]}
+
+
+      def ==(s)
+        (s.is_a?(Hash) && s[:name] && @name.to_s == s[:name].to_s) ||
+        (s.is_a?(Symbol) && @name.to_s == s.to_s) ||
+        (s.is_a?(String) && @name.to_s == s) ||
+        (s.is_a?(FieldConfig) && s.name.to_s == @name.to_s)
+      end
+    end
+
+end

data/lib/toolbox/default_controller.rb

@@ -0,0 +1,315 @@
+require File.expand_path("../dirs", File.dirname(__FILE__))
+
+module Toolbox
+
+  #
+  # Defines the default action.
+  #
+  module DefaultController
+
+    def self.setup #:nodoc:      
+      ActionController::Base.send(:extend, ClassMethods)
+      #ActionController::Base.send(:include, InstanceMethods)
+      ActionView::Base.send(:include, HelperMethods)
+    end
+
+    module HelperMethods
+      def get_record
+        instance_variable_get ('@' + controller.model_name).to_sym
+      end
+      
+      def context_menu_link(rec, context = nil)
+        context_records = []
+        # get the record in show-mode
+        context_records << get_record if get_record.is_a? ActiveRecord::Base
+        context_records << context if context
+        p = {}
+        context_records.each { |r| p["#{r.class.name.to_s}_id".to_sym] = r }
+        ctx_url =send("context_menu_#{rec.class.to_s.underscore}_path".to_sym, rec, p)
+        link_to_function('&#9660;', "show_context_menu(event, '#{ctx_url}')")
+      end
+
+      # returns html necessary to load javascript and css to make the toolbox work
+      def toolbox_includes()
+        return "" if @toolbox_already_included
+        @toolbox_already_included = true
+
+
+        js = javascript_include_tag "toolbox-#{Toolbox::VERSION}/toolbox", "toolbox-#{Toolbox::VERSION}/popup"
+        cs = stylesheet_link_tag 'toolbox/context_menu', 'toolbox/popup', 'toolbox/toolbox'
+        js + "\n" + cs + "\n"
+      end
+      
+
+    end
+
+    module ClassMethods
+
+      # The listed associations are included in when using find together with
+      # search fields. Thus if a search field defintion contains "foreign" fields
+      # one may include the corresponding association.
+      def include_assoc *assoc
+        write_inheritable_attribute('include_assoc', assoc)
+      end
+
+    end
+
+    module InstanceMethods #:nodoc:all
+
+      def index
+        obj = paging
+        instance_variable_set :@recs, obj
+
+        respond_to do |format|
+          format.html { render :template => 'toolbox/index' }
+          format.xml  { render :xml => obj }
+        end
+      end
+
+      def show
+        obj = model_class.find(params[:id])
+        set_record obj
+        respond_to do |format|
+          format.html { render :template => 'toolbox/show' }
+          format.xml  { render :xml => obj }
+        end
+      end
+
+      def new
+        # Handle dublicate command
+        param_name = "#{model_name}_id".to_sym
+        attr = {}
+        attr = model_class.find(params[param_name]).attributes if params[param_name]
+        obj = model_class.new attr
+
+        set_record obj
+
+        # context support
+        # set all _id fields, if available from params
+        params.each_pair do | key,value |
+          if key.to_s.ends_with? '_id' and obj.respond_to? key + '='
+            obj.send(key + '=', value)
+          end
+        end
+
+        respond_to do |format|
+          format.html { render :template => 'toolbox/new' }
+          format.xml  { render :xml => obj }
+          format.js do
+            render :update do |page|
+              locals = {:widgetsets => controller.edit_config(obj).controlsets, :dialog => true }
+              page.replace_html  'dialog_id', :partial => "toolbox/form", :object => obj, :locals => locals
+              page << "$('dialog_id').popup.show();"
+            end
+          end
+        end
+      end
+
+      def edit
+        obj = model_class.find(params[:id])
+        set_record obj
+
+        respond_to do |format|
+          format.html { render :template => 'toolbox/edit' }
+          format.js do
+            render :update do |page|
+              locals = {:widgetsets => controller.edit_config(obj).controlsets, :dialog => true }
+              page.replace_html  'dialog_id', :partial => "toolbox/form", :object => obj, :locals => locals
+              page << "$('dialog_id').popup.show();"
+            end
+          end
+        end
+      end
+
+      def create
+        if params[:save] # save or ok clicked
+          p = params[model_name.to_sym]
+          preprocess_autocomplete nil, p
+          obj = model_class.new p
+          set_record obj
+
+          respond_to do |format|
+            if obj.save
+              flash[:notice] = Messages.created % { :object => s_(controller_name.singularize.humanize.downcase)}
+              format.html { redirect_to(obj) }
+              format.js do
+                render :update do
+                  |page| page << 'window.location.reload();'  # TODO improvment?
+                end
+              end
+              format.xml  { render :xml => obj, :status => :created, :location => obj }
+            else
+              format.html { render :template => "toolbox/new" }
+              format.xml  { render :xml => obj.errors, :status => :unprocessable_entity }
+              format.js do
+                render :update do |page|
+                  locals = {:widgetsets => controller.edit_config(obj).controlsets, :dialog => true }
+                  page.replace_html  'dialog_id', :partial => "toolbox/form", :object => obj, :locals => locals
+                end
+              end
+            end
+          end
+        else # cancel clicked
+          redirect_to eval("#{controller_name}_path")
+        end
+      end
+
+
+      def update
+        obj = model_class.find(params[:id])
+        set_record obj
+
+        if params[:save]
+          par = params[model_name.to_sym]
+          preprocess_autocomplete obj, par
+          # Ensure that the the collection attributes exist - create them if not
+          # This is needed, if all collection items have been deleted.
+          edit_config(obj).controlsets.each do |controlset|
+            if controlset.collection_config
+              attr = Toolbox::Helpers.collection_attribute_name(controlset.collection_config, obj)
+              par[attr] ||= {}
+            end
+          end
+
+          respond_to do |format|
+            if obj.update_attributes(par)
+              flash[:notice] = Messages.updated % { :object => s_(controller_name.singularize.humanize.downcase)}
+              format.html { redirect_to(obj) }
+              format.xml  { head :ok }
+              format.js do
+                render :update do |page|
+                  page << 'window.location.reload();'  # TODO improve ?
+                end
+              end
+            else
+              format.html { render :template => "toolbox/edit" }
+              format.xml  { render :xml => obj.errors, :status => :unprocessable_entity }
+              format.js do
+                render :update do |page|
+                  locals = {:widgetsets => controller.edit_config(obj).controlsets, :dialog => true }
+                  page.replace_html  'dialog_id', :partial => "toolbox/form", :object => obj, :locals => locals
+                end
+              end
+            end
+          end
+        else # cancel clicked
+          respond_to do |format|
+            format.html { redirect_to(obj) }
+            format.xml  { head :ok }
+          end
+        end
+      end
+
+      def destroy
+        obj = model_class.find(params[:id])
+        set_record obj
+        obj.destroy
+
+        respond_to do |format|
+          format.html { redirect_to(send(controller_name + '_url')) }
+          format.xml  { head :ok }
+          format.js do
+            render :update do |page|
+              page << 'window.location.reload();' # TODO: improve?
+            end
+          end
+        end
+      end
+
+      def context_menu
+        rec = model_class.find(params[:id])
+        set_record rec
+        context = {}
+        params.select { |k,v| k.ends_with? '_id' }.each {|a| context[a[0]] = a[1] } 
+        locals = { :context => context, :widget_list => menu_config(rec, context)}
+        respond_to do |format|
+          format.html { render :partial => "toolbox/context_menu", :object => rec, :locals => locals  }
+          format.js do
+            render :update do |page|
+              page.replace_html  'context_menu_id', :partial => "toolbox/context_menu", :object => rec, :locals => locals
+            end
+          end
+        end
+      end
+
+      def model_name
+        controller_name.singularize
+      end
+
+      def model_class
+        controller_name.classify.constantize
+      end
+
+      protected
+
+      #def load_config
+      #  @config = "#{controller_name.camelcase}ViewConfig".constantize.get_instance unless defined? @config
+      #end
+
+      # check the consitency between the visible input-field
+      # and the invisible id field
+      def preprocess_autocomplete rec, params
+        edit_config(rec).controlsets.each do |controlset|
+          controlset.widget_list.widgets.each do |widget|
+            if widget.type == :auto_complete
+              value = params.delete widget.name
+              params[widget.name.to_s.foreign_key] = nil if value == '' || value == nil
+            end
+          end
+        end
+        params
+      end
+
+      # do the paging for the index
+      def paging
+        filter = (params[:query] || params[:filter] || '')
+        cond = Toolbox::Searching.create_search_condition filter, search_fields
+        order = Toolbox::Sorting.order_by params, index_config.widgets
+        options = { :page => params[:page], :conditions => cond }
+        options[:order] = order if order
+        options[:include] = include_assoc if include_assoc
+        model_class.paginate options
+      end
+
+      private
+
+      def set_record obj
+        instance_variable_set "@#{model_name}".to_sym, obj
+      end
+
+      def include_assoc
+        self.class.read_inheritable_attribute('include_assoc')
+      end
+    end
+    
+  end
+
+  # needed for not to conflict with the textdomain from the application controller
+  module Messages #:nodoc:all
+    include GetText::Rails
+    bindtextdomain('toolbox', :path => Toolbox::Dirs::LOCALE)
+    def self.created
+      _('%{object} was successfully created.')
+    end
+    def self.updated
+      _('%{object} was successfully updated.')
+    end
+
+    def self.create
+      _('Create')
+    end
+
+    def self.save
+      _('Save')
+    end
+
+    def self.cancel
+      _('Cancel')
+    end
+
+    def self.nothing_found
+      _('Nothing found')
+    end
+  end
+
+end

data/lib/toolbox/helpers.rb

@@ -0,0 +1,11 @@
+
+module Toolbox
+  module Helpers
+
+    def self.collection_attribute_name collection_config, rec
+      new_or_existing = rec.new_record? ? 'new' : 'existing'
+      "#{new_or_existing}_#{collection_config.type.name.to_s.underscore}_attributes"
+    end
+
+  end
+end