netzke-basepack 0.3.10 → 0.4.0

data/lib/app/models/netzke_hash_record.rb

@@ -0,0 +1,180 @@
+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.config[:persistent_config_manager].constantize
+  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

@@ -0,0 +1,11 @@
+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

@@ -13,7 +13,7 @@ module Netzke
     #
     
     def method_missing(method, *args, &block)
-      # if refering to a column, just pass it to the originar method_missing
+      # 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(/\.|__/)
@@ -87,7 +87,7 @@ module Netzke
             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.send(column).index(/^#{query}/)}
+              query.nil? ? records : records.select{|r| r.index(/^#{query}/)}
             end
           end
         end
@@ -147,16 +147,16 @@ module Netzke
           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 && assoc_column.type
+            assoc_method_type = assoc_column.try(:type)
             if assoc_method_type
-              res[:editor] = ext_editor(assoc_method_type) == :checkbox ? :checkbox : :combo_box
+              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] = :combo_box
+          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
@@ -174,15 +174,15 @@ module Netzke
       
       DEFAULT_COLUMN_WIDTH = 100
       
-      # identify Ext editor for the data type
+      # identify Ext editor (xtype) for the data type
       TYPE_EDITOR_MAP = {
-        :integer => :number_field,
+        :integer => :numberfield,
         :boolean => :checkbox,
-        :date => :date_field,
-        :datetime => :datetime,
-        :string => :text_field
+        :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)
@@ -194,25 +194,33 @@ module Netzke
       #
       
       # 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
-        }
+      # 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)
@@ -224,17 +232,32 @@ module Netzke
 
         common = {
           :field_label => config[:name].to_s.gsub('__', '_').humanize,
-          :hidden      => config[:name] == :id
+          :hidden      => config[:name] == :id,
+          :xtype       => XTYPE_MAP[type] || XTYPE_MAP[:string]
         }
 
-        default = DEFAULTS_FOR_FIELD[type] || DEFAULTS_FOR_FIELD[:string] # fallback to plain textfield
+        # 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)
+        # res = default.merge(common).merge(config)
       end
       
       private
       def ext_editor(type)
-        TYPE_EDITOR_MAP[type] || :text_field # fall back to :text_field
+        TYPE_EDITOR_MAP[type] || :textfield # fall back to :text_field
       end
       
     end

data/lib/netzke/border_layout_panel.rb

@@ -115,7 +115,6 @@ module Netzke
     end
   
     def resize_region(params)
-      logger.debug "!!! params: #{params.inspect}"
       persistent_config["#{params["region_name"]}_width"] = params["new_width"].to_i if params["new_width"]
       persistent_config["#{params["region_name"]}_height"] = params["new_height"].to_i if params["new_height"]
       {}

data/lib/netzke/db_fields.rb

@@ -1,5 +1,9 @@
 module Netzke
   module DbFields
+    #
+    # Default fields for a widget of class GridPanel or FormPanel
+    # It is a synthesis of 1) columns declared in the model, 2) columns provided in the configuration for the widget
+    #
     def default_db_fields
       config[:data_class_name].nil? && raise(ArgumentError, "No data_class_name specified for widget #{config[:name]}")
       

data/lib/netzke/field_model.rb

@@ -0,0 +1,131 @@
+module Netzke
+  class FieldModel < Hash
+    include ActiveRecordExtensions
+    
+    def self.new_from_hash(hsh)
+      self.new.replace(hsh)
+    end
+    
+    # def self.json=(str)
+    #   @@data = ActiveSupport::JSON.decode(str)
+    #   process_data
+    # end
+
+    def self.widget_name=(w)
+      @@widget_name = w
+    end
+
+    def self.data_storage=(ds)
+      @@storage = ds
+      process_data
+    end
+
+    # def self.data=(data)
+    #   @@raw_data = data
+    #   process_data
+    # end
+    
+    def self.column_names
+      @@data.inject([]){|res, record| (res + record.keys).uniq}
+    end
+    
+    def self.columns
+      column_names
+    end
+    
+    def self.all(params={})
+      @@data
+    end
+    
+    def self.first
+      @@data[0]
+    end
+    
+    def self.find(id)
+      @@data[id-1]
+    end
+    
+    def self.count(params = {})
+      @@data.size
+    end
+    
+    def self.columns_hash
+      @@columns_hash
+    end
+    
+    def self.reflect_on_all_associations
+      []
+    end
+    
+    # instance methods
+    def id
+      self[:id] || self["id"]
+    end
+    
+    def errors
+      []
+    end
+    
+    def save
+      true
+    end
+    
+    private
+    def self.process_data
+      @@columns_hash = {}
+
+      @@data = []
+      
+      # convert array of hashes into array of FieldModel instances
+      @@storage.each do |hsh|
+        @@data << new_from_hash(hsh)
+      end
+
+      @@data.each do |record|
+        record.keys.each do |k|
+          
+          if @@columns_hash[k.to_s].nil?
+            
+            # calculate column type
+            puts record[k].class.to_s
+            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
+
+            @@columns_hash[k.to_s] = column
+          end
+        end
+      end
+    end
+
+    # # Testing
+    # @@data = [
+    #   self.new_from_hash({"id" => 1, "name" => "col1", "column_type" => "text", "read_only" => true}),
+    #   self.new_from_hash({"id" => 2, "name" => "col2", "column_type" => "string", "read_only" => false})
+    # ]
+    # 
+    # process_data
+    # end testing
+
+  end
+  
+  
+end