netzke-basepack 0.4.2 → 0.5.1

data/Manifest

@@ -1,86 +0,0 @@
-autotest/discover.rb
-CHANGELOG
-init.rb
-install.rb
-javascripts/basepack.js
-lib/app/models/netzke_hash_record.rb
-lib/app/models/netzke_layout_item.rb
-lib/netzke/accordion_panel.rb
-lib/netzke/ar_ext.rb
-lib/netzke/basic_app.rb
-lib/netzke/border_layout_panel.rb
-lib/netzke/configuration_tool.rb
-lib/netzke/container.rb
-lib/netzke/db_fields.rb
-lib/netzke/field_model.rb
-lib/netzke/fields_configurator.rb
-lib/netzke/fields_configurator_old.rb
-lib/netzke/form_panel.rb
-lib/netzke/form_panel_extras/interface.rb
-lib/netzke/form_panel_extras/javascripts/xcheckbox.js
-lib/netzke/form_panel_extras/js_builder.rb
-lib/netzke/grid_panel.rb
-lib/netzke/grid_panel_extras/interface.rb
-lib/netzke/grid_panel_extras/javascripts/check-column.js
-lib/netzke/grid_panel_extras/javascripts/filters.js
-lib/netzke/grid_panel_extras/js_builder.rb
-lib/netzke/panel.rb
-lib/netzke/property_editor.rb
-lib/netzke/property_editor_extras/helper_model.rb
-lib/netzke/tab_panel.rb
-lib/netzke/table_editor.rb
-lib/netzke/tree_panel.rb
-lib/netzke/wrapper.rb
-lib/netzke-basepack.rb
-LICENSE
-Manifest
-Rakefile
-README.rdoc
-stylesheets/basepack.css
-tasks/netzke_basepack_tasks.rake
-test/app_root/app/controllers/application.rb
-test/app_root/app/models/book.rb
-test/app_root/app/models/category.rb
-test/app_root/app/models/city.rb
-test/app_root/app/models/continent.rb
-test/app_root/app/models/country.rb
-test/app_root/app/models/genre.rb
-test/app_root/config/boot.rb
-test/app_root/config/database.yml
-test/app_root/config/environment.rb
-test/app_root/config/environments/in_memory.rb
-test/app_root/config/environments/mysql.rb
-test/app_root/config/environments/postgresql.rb
-test/app_root/config/environments/sqlite.rb
-test/app_root/config/environments/sqlite3.rb
-test/app_root/config/routes.rb
-test/app_root/db/migrate/20081222033343_create_books.rb
-test/app_root/db/migrate/20081222033440_create_genres.rb
-test/app_root/db/migrate/20081222035855_create_netzke_preferences.rb
-test/app_root/db/migrate/20081223024935_create_categories.rb
-test/app_root/db/migrate/20081223025635_create_countries.rb
-test/app_root/db/migrate/20081223025653_create_continents.rb
-test/app_root/db/migrate/20081223025732_create_cities.rb
-test/app_root/db/migrate/20090102223630_create_netzke_layouts.rb
-test/app_root/script/console
-test/app_root/vendor/plugins/acts_as_list/init.rb
-test/app_root/vendor/plugins/acts_as_list/lib/active_record/acts/list.rb
-test/app_root/vendor/plugins/acts_as_list/README
-test/console_with_fixtures.rb
-test/fixtures/books.yml
-test/fixtures/categories.yml
-test/fixtures/cities.yml
-test/fixtures/continents.yml
-test/fixtures/countries.yml
-test/fixtures/genres.yml
-test/schema.rb
-test/test_helper.rb
-test/unit/accordion_panel_test.rb
-test/unit/ar_ext_test.rb
-test/unit/grid_panel_test.rb
-test/unit/netzke_basepack_test.rb
-test/unit/netzke_hash_record_test.rb
-test/unit/netzke_layout_item_test.rb
-test/unit/tab_panel_test.rb
-TODO
-uninstall.rb

data/TODO

@@ -1,3 +0,0 @@
-* GridPanel. Reordering of grid columns may lead to unpredictable results when data from an "outdated" table (e.g. open in another browser) gets submitted. A mechanism is needed to submit updated data along with the field names - as hash (as done is FormPanel), *not* as array.
-
-* Add status bar to BasicApp

data/lib/app/models/netzke_hash_record.rb

@@ -1,180 +0,0 @@
-class NetzkeHashRecord < Hash
-  include Netzke::ActiveRecordExtensions
-  #
-  # Class methods
-  #
-  def self.widget=(w)
-    @@widget = w
-    reload
-  end
-  
-  def self.widget
-    @@widget ||= nil
-    raise "No widget specified for NetzkeHashRecord" if @@widget.nil?
-    @@widget
-  end
-  
-  def self.data=(data)
-    @@records = data
-    save
-  end
-  
-  def self.raw_data=(data)
-    persistent_config.for_widget(widget) {|p| p[:layout__columns] = data}
-  end
-  
-  def self.columns_hash
-    @@columns_hash ||= build_columns_hash
-  end
-
-  def self.push(instance)
-    records << instance
-  end
-
-  def self.reload
-    @@records = build_records
-  end
-
-  # standard AR operations
-  def self.all(params = {})
-    records
-  end
-  
-  def self.count(params = {})
-    records.size
-  end
-  
-  def self.find(*args)
-    if args.size == 1
-      records[args.first.to_i - 1]
-    else
-    end
-  end
-  
-  def self.first
-    records.first
-  end
-  
-  def self.last
-    records.last
-  end
-  
-  def self.delete(ids)
-    ids.each do |id|
-      records.delete_if{|r| r.id == id.to_i}
-    end
-    recalculate_ids
-    save
-  end
-  
-  def self.delete_all
-    records.clear
-    save
-  end
-  
-  def self.save
-    records_without_ids = records.map{ |r| r.reject{ |k,v| k == :id } }
-    persistent_config.for_widget(widget) {|p| p[:layout__columns] = records_without_ids}
-    true
-  end
-  
-  def self.column_names
-    columns_hash.keys.sort{ |x,y| x == "id" ? -1 : 0} # "id"-column should always come first (required by the GridPanel)
-  end
-  
-  def self.reflect_on_all_associations
-    []
-  end
-  
-  #
-  # Instance methods
-  # 
-  def initialize(params = {})
-    self.replace(params)
-  end
-  
-  def id
-    self[:id] || self["id"]
-  end
-  
-  def id=(id)
-    self[:id] = id
-  end
-  
-  def save
-    if self.id.nil?
-      self.id = self.class.records.size + 1
-      self.class.push(self)
-    else
-      # nothing to do
-    end
-    
-    self.class.save
-  end
-  
-  def errors
-    []
-  end
-  
-  private
-  
-  def self.persistent_config
-    @@persistent_config ||= Netzke::Base.persistent_config
-  end
-
-  def self.records
-    @@records ||= build_records
-  end
-  
-  def self.build_records
-    raw_records = persistent_config.for_widget(widget){|p| p[:layout__columns]} || []
-    records = []
-    raw_records.each_with_index do |r,i|
-      own_instance = self.new(r.convert_keys{|k| k.to_sym})
-      own_instance.merge!(:id => i + 1) # merging with the id
-      records << own_instance
-    end
-    records
-  end
-  
-  def self.recalculate_ids
-    records.each_with_index { |r, i| r.id = i + 1} 
-  end
-  
-  def self.build_columns_hash
-    res = {}
-    records.each do |record|
-      record.keys.each do |k|
-        
-        if res[k.to_s].nil?
-          
-          # calculate column type
-          column_type = case record[k].class.to_s
-            when "TrueClass"
-              :boolean
-            when "FalseClass"
-              :boolean
-            when "String"
-              :string
-            when "Fixnum"
-              :integer
-            else
-              :string
-            end
-          
-          column = {:type => column_type}
-
-          # workaround for the "type" method
-          class << column
-            def type
-              self[:type]
-            end
-          end
-
-          res[k.to_s] = column
-        end
-      end
-    end
-    res
-  end
-end

data/lib/app/models/netzke_layout_item.rb

@@ -1,11 +0,0 @@
-class NetzkeLayoutItem < NetzkeHashRecord
-
-  # Moving item
-  def self.move_item(from, to)
-    r = records.delete_at(from)
-    records.insert(to, r)
-    recalculate_ids
-    save
-  end
-    
-end

data/lib/netzke/ar_ext.rb

@@ -1,269 +0,0 @@
-module Netzke
-  module ActiveRecordExtensions
-    def self.included(base)
-      base.extend ActiveRecordClassMethods
-    end
-
-    #
-    # Allow nested association access (assocs separated by "." or "__"), e.g.: proxy_service.asset__gui_folder__name
-    # Example:
-    # b = Book.first
-    # b.genre__name = 'Fantasy' => b.genre = Genre.find_by_name('Fantasy')
-    # NOT IMPLEMENTED (any real use?): b.genre__catalog__name = 'Best sellers' => b.genre_id = b.genre.find_by_catalog_id(Catalog.find_by_name('Best sellers')).id
-    #
-    
-    def method_missing(method, *args, &block)
-      # if refering to a column, just pass it to the original method_missing
-      return super if self.class.column_names.include?(method.to_s)
-      
-      split = method.to_s.split(/\.|__/)
-      if split.size > 1
-        if split.last =~ /=$/ 
-          if split.size == 2
-            # search for association and assign it to self
-            assoc = self.class.reflect_on_association(split.first.to_sym)
-            assoc_method = split.last.chop
-            if assoc
-              assoc_instance = assoc.klass.send("find_by_#{assoc_method}", *args)
-              raise ArgumentError, "Couldn't find association #{split.first} by #{assoc_method} '#{args.first}'" unless assoc_instance
-              self.send("#{split.first}=", assoc_instance)
-            else
-              super
-            end
-          else
-            super
-          end
-        else
-          res = self
-          split.each do |m|
-            if res.respond_to?(m)
-              res = res.send(m) unless res.nil?
-            else
-              res.nil? ? nil : super
-            end
-          end
-          res
-        end
-      else
-        super
-      end
-    end
-    
-    def to_array(columns)
-      res = []
-      for c in columns
-        method = c.is_a?(Symbol) ? c : c[:name]
-        res << send(method)
-      end
-      res
-    end
-    
-    module ActiveRecordClassMethods
-      # next and previous to id records
-      def next(id)
-        find(:first, :conditions => ["#{primary_key} > ?", id])
-      end
-      def previous(id)
-        find(:first, :conditions => ["#{primary_key} < ?", id], :order => "#{primary_key} DESC")
-      end
-      
-      # Returns all unique values for a column, filtered by the query
-      def choices_for(column, query = nil)
-        if respond_to?("#{column}_choices", query)
-          # AR class provides the choices itself
-          send("#{column}_choices")
-        else
-          if (assoc_name, *assoc_method = column.split('__')).size > 1
-            # column is an association column
-            assoc_method = assoc_method.join('__') # in case we get something like country__continent__name
-            association = reflect_on_association(assoc_name.to_sym) || raise(NameError, "Association #{assoc_name} not known for class #{name}")
-            association.klass.choices_for(assoc_method, query)
-          else
-            column = assoc_name
-            if self.column_names.include?(column)
-              # it's just a column
-              records = query.nil? ? find_by_sql("select distinct #{column} from #{table_name}") : find_by_sql("select distinct #{column} from #{table_name} where #{column} like '#{query}%'")
-              records.map{|r| r.send(column)}
-            else
-              # it's a "virtual" column - the least effective search
-              records = self.find(:all).map{|r| r.send(column)}.uniq
-              query.nil? ? records : records.select{|r| r.index(/^#{query}/)}
-            end
-          end
-        end
-      end
-      
-      # which columns are to be picked up by grids and forms
-      def expose_columns(*column_configs)
-        if column_configs.first == :all
-          write_inheritable_attribute(:exposed_columns, self.column_names.map(&:to_sym))
-        else
-          write_inheritable_attribute(:exposed_columns, column_configs)
-        end
-      end
-      
-      def exposed_columns
-        read_inheritable_attribute(:exposed_columns) || write_inheritable_attribute(:exposed_columns, expose_columns(:all) + virtual_columns)
-      end
-      
-      # virtual "columns" that simply correspond to instance methods of an ActiveRecord class
-      def virtual_column(config)
-        if config.is_a?(Symbol) 
-          config = {:name => config}
-        else
-          config = {:name => config.keys.first}.merge(config.values.first)
-        end
-        write_inheritable_attribute(:virtual_columns, (read_inheritable_attribute(:virtual_columns) || []) << config)
-      end
-      
-      def virtual_columns
-        read_inheritable_attribute(:virtual_columns) || []
-      end
-      
-      def is_virtual_column?(column)
-        read_inheritable_attribute(:virtual_columns).keys.include?(column)
-      end
-      
-      def default_dbfield_config(config, mode = :grid)
-        config = config.is_a?(Symbol) ? {:name => config} : config.dup
-
-        # detect ActiveRecord column type (if the column is "real") or fall back to :virtual
-        type = (columns_hash[config[:name].to_s] && columns_hash[config[:name].to_s].type) || :virtual
-
-        res = {
-          :name => config[:name].to_s || "unnamed",
-          :label => config[:label] || config[:name].to_s.gsub('__', '_').humanize,
-          :read_only => config[:name] == :id, # make "id" column read-only by default
-          :hidden => config[:name] == :id, # hide "id" column by default
-          :width => mode == :grid ? DEFAULT_COLUMN_WIDTH : DEFAULT_FIELD_WIDTH,
-          :editor => ext_editor(type)
-        }
-        
-        # for forms fields also set up the height
-        res.merge!(:height => DEFAULT_FIELD_HEIGHT) if mode == :form
-
-        # detect :assoc__method
-        if config[:name].to_s.index('__')
-          assoc_name, method = config[:name].to_s.split('__').map(&:to_sym)
-          if assoc = reflect_on_association(assoc_name)
-            assoc_column = assoc.klass.columns_hash[method.to_s]
-            assoc_method_type = assoc_column.try(:type)
-            if assoc_method_type
-              res[:editor] = ext_editor(assoc_method_type) == :checkbox ? :checkbox : :combobox
-            end
-          end
-        end
-        
-        # detect association column (e.g. :category_id)
-        if assoc = reflect_on_all_associations.detect{|a| a.primary_key_name.to_sym == config[:name]}
-          res[:editor] = :combobox
-          assoc_method = %w{name title label}.detect{|m| (assoc.klass.instance_methods + assoc.klass.column_names).include?(m) } || assoc.klass.primary_key
-          res[:name] = "#{assoc.name}__#{assoc_method}"
-        end
-
-        res[:width] = 50 if res[:editor] == :checkbox # more narrow column for checkboxes
-        
-        # merge with the given confg, which has the priority
-        config.delete(:name) # because we might have changed the name
-        res.merge(config)
-      end
-      
-      #
-      # Used by Netzke::GridPanel
-      #
-      
-      DEFAULT_COLUMN_WIDTH = 100
-      
-      # identify Ext editor (xtype) for the data type
-      TYPE_EDITOR_MAP = {
-        :integer => :numberfield,
-        :boolean => :checkbox,
-        :date => :datefield,
-        :datetime => :xdatetime,
-        :string => :textfield
-      }
-
-      # Returns default column config understood by Netzke::GridPanel
-      # Argument: column name (as Symbol) or column config
-      def default_column_config(config)
-        default_dbfield_config(config, :grid)
-      end
-      
-      #
-      # Used by Netzke::FormPanel
-      #
-      
-      # default configuration as a function of ActivRecord's column type
-      # DEFAULTS_FOR_FIELD = {
-      #   :integer => {
-      #     :xtype => :numberfield
-      #   },
-      #   :boolean => {
-      #     :xtype => :numberfield
-      #   },
-      #   :date => {
-      #     :xtype => :datefield
-      #   },
-      #   :datetime => {
-      #     :xtype => :xdatetime
-      #     # :date_format => "Y-m-d",
-      #     # :time_format => "H:i",
-      #     # :time_width => 60
-      #   },
-      #   :string => {
-      #     :xtype => :textfield
-      #   }
-      # }
-
-      XTYPE_MAP = {
-        :integer => :numberfield,
-        :boolean => :xcheckbox,
-        :date => :datefield,
-        :datetime => :xdatetime,
-        :string => :textfield
-      }
-
-      def default_field_config(config)
-        # default_dbfield_config(config, :form)
-        config = config.is_a?(Symbol) ? {:name => config} : config.dup
-
-        # detect ActiveRecord column type (if the column is "real") or fall back to :virtual
-        type = (columns_hash[config[:name].to_s] && columns_hash[config[:name].to_s].type) || :virtual
-
-        common = {
-          :field_label => config[:name].to_s.gsub('__', '_').humanize,
-          :hidden      => config[:name] == :id,
-          :xtype       => XTYPE_MAP[type] || XTYPE_MAP[:string]
-        }
-
-        # detect :assoc__method
-        if config[:name].to_s.index('__')
-          assoc_name, method = config[:name].to_s.split('__').map(&:to_sym)
-          if assoc = reflect_on_association(assoc_name)
-            assoc_column = assoc.klass.columns_hash[method.to_s]
-            assoc_method_type = assoc_column.try(:type)
-            if assoc_method_type
-              common[:xtype] = ext_editor(assoc_method_type) == :checkbox ? :checkbox : :combobox
-            end
-          end
-        end
-        
-        common.merge(config)
-
-        # default = DEFAULTS_FOR_FIELD[type] || DEFAULTS_FOR_FIELD[:string] # fallback to plain textfield
-
-        # res = default.merge(common).merge(config)
-      end
-      
-      private
-      def ext_editor(type)
-        TYPE_EDITOR_MAP[type] || :textfield # fall back to :text_field
-      end
-      
-    end
-  end
-end
-
-ActiveRecord::Base.class_eval do
-  include Netzke::ActiveRecordExtensions
-end