netzke-basepack 0.5.14 → 0.6.0

data/lib/netzke-basepack.rb

@@ -1,44 +1,57 @@
 # External dependencies
-require 'active_support'
 require 'netzke-core'
+require 'active_support/dependencies'
+
+# path = File.dirname(__FILE__)
+# $LOAD_PATH << path
+
+# Make components auto-loadable
+ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)
+
+require 'netzke/basepack'
+
+module Netzke
+  autoload :Ext, 'ext'
+  
+  module Basepack
+    class Engine < Rails::Engine
+      config.after_initialize do
+        I18n.load_path << File.dirname(__FILE__) + '/../locale/en.yml'
+      end
+    end
+  end
+  
+end
 
-# ExtJS-related constants
-require 'netzke/ext'
-require 'netzke/active_record'
+Netzke::Basepack.init
 
-# Make widget classes auto-loadable with help of ActiveSupport
-path = File.dirname(__FILE__)
-ActiveSupport::Dependencies.load_paths << path
+# Netzke::Core.javascripts << "#{File.dirname(__FILE__)}/../../javascripts/basepack.js"
+# Netzke::Core.stylesheets << "#{File.dirname(__FILE__)}/../../stylesheets/basepack.css"
 
 # Make this plugin auto-reloadable for easier development
-ActiveSupport::Dependencies.load_once_paths.delete(path)
+# ActiveSupport::Dependencies.autoload_once_paths.delete(path)
 
 # Make gem's models auto-loadable
-%w{ models }.each do |dir|
-  path = File.join(File.dirname(__FILE__), 'app', dir)
-  $LOAD_PATH << path
-  ActiveSupport::Dependencies.load_paths << path
-  ActiveSupport::Dependencies.load_once_paths.delete(path)
-end
-
-# Include javascript & styles required by all basepack widgets. 
+# %w{ models }.each do |dir|
+#   path = File.join(File.dirname(__FILE__), 'app', dir)
+#   $LOAD_PATH << path
+#   ActiveSupport::Dependencies.autoload_paths << path
+#   ActiveSupport::Dependencies.autoload_once_paths.delete(path)
+# end
+
+# Include javascript & styles required by all basepack components. 
 # These files will get loaded at the initial load of the framework (along with Ext and Netzke-core).
-Netzke::Base.config[:javascripts] << "#{File.dirname(__FILE__)}/../javascripts/basepack.js"
-Netzke::Base.config[:stylesheets] << "#{File.dirname(__FILE__)}/../stylesheets/basepack.css"
 
 
-# FIXME: The following stylesheet inclusion doesn't *really* belong here, being widget-specific, 
+# FIXME: The following stylesheet inclusion doesn't *really* belong here, being component-specific, 
 # but I don't see any other solution for now. The problem is that these stylesheets come straight from
 # Ext JS, having *relative* URLs to the images, which doesn't allow us to include them all together as those stylesheets 
 # from Netzke.
 
 # Used by FormPanel (file upload field)
-Netzke::Base.config[:external_css] << "/extjs/examples/ux/fileuploadfield/css/fileuploadfield"
+# Netzke::Base.config[:external_css] << "/extjs/examples/ux/fileuploadfield/css/fileuploadfield"
 
 # Used by GridPanel
-Netzke::Base.config[:external_css] << "/extjs/examples/ux/gridfilters/css/RangeMenu"
-Netzke::Base.config[:external_css] << "/extjs/examples/ux/gridfilters/css/GridFilters"
+# Netzke::Base.config[:external_css] << "/extjs/examples/ux/gridfilters/css/RangeMenu"
+# Netzke::Base.config[:external_css] << "/extjs/examples/ux/gridfilters/css/GridFilters"
 
-if Netzke::Base.config[:with_icons].nil? && defined?(RAILS_ROOT)
-  Netzke::Base.config[:with_icons] = File.exists?("#{RAILS_ROOT}/public#{Netzke::Base.config[:icons_uri]}")
-end

data/lib/netzke/active_record.rb

@@ -1,7 +1,11 @@
-require 'netzke/active_record/association_attributes'
-require 'netzke/active_record/attributes'
-require 'netzke/active_record/combobox_options'
-require 'netzke/active_record/data_accessor'
+# require 'netzke/active_record/association_attributes'
+# require 'netzke/active_record/attributes'
+# require 'netzke/active_record/combobox_options'
+# require 'netzke/active_record/data_accessor'
+
+module Netzke::ActiveRecord
+  
+end
 
 # Extend ActiveRecord
 ActiveRecord::Base.class_eval do
@@ -9,3 +13,7 @@ ActiveRecord::Base.class_eval do
   include ::Netzke::ActiveRecord::Attributes
   include ::Netzke::ActiveRecord::ComboboxOptions
 end
+
+ActiveRecord::Relation.class_eval do
+  include ::Netzke::ActiveRecord::RelationExtensions
+end

data/lib/netzke/active_record/attributes.rb

@@ -1,6 +1,7 @@
 module Netzke::ActiveRecord::Attributes
+  extend ActiveSupport::Concern
+  
   module ClassMethods
-    
     # Define or configure an attribute.
     # Example:
     #   netzke_attribute :recent, :type => :boolean, :read_only => true
@@ -13,7 +14,13 @@ module Netzke::ActiveRecord::Attributes
       if existing
         existing.merge!(options)
       else
-        declared_attrs << {:name => name}.merge(options)
+        attr_config = {:name => name}.merge(options)
+        # if primary_key, insert in front, otherwise append
+        if name == self.primary_key
+          declared_attrs.insert(0, attr_config)
+        else
+          declared_attrs << {:name => name}.merge(options)
+        end
       end
       write_inheritable_attribute(:netzke_declared_attributes, declared_attrs)
     end
@@ -37,10 +44,20 @@ module Netzke::ActiveRecord::Attributes
     
     # Returns the attributes that will be picked up by grids and forms.
     def netzke_attributes
-      exposed = read_inheritable_attribute(:netzke_exposed_attributes)
+      exposed = netzke_exposed_attributes
       exposed ? netzke_attrs_in_forced_order(exposed) : netzke_attrs_in_natural_order
     end
     
+    def netzke_exposed_attributes
+      exposed = read_inheritable_attribute(:netzke_exposed_attributes)
+      if exposed && !exposed.include?(self.primary_key)
+        # automatically declare primary key as a netzke attribute
+        netzke_attribute(self.primary_key)
+        exposed.insert(0, self.primary_key)
+      end
+      exposed
+    end
+    
     private
       def netzke_declared_attributes
         read_inheritable_attribute(:netzke_declared_attributes) || []
@@ -76,6 +93,7 @@ module Netzke::ActiveRecord::Attributes
       def netzke_attrs_in_natural_order
         (
           declared_attrs = netzke_declared_attributes
+          
           column_names.map do |name|
             c = {:name => name, :attr_type => columns_hash[name].type}
             
@@ -108,7 +126,44 @@ module Netzke::ActiveRecord::Attributes
       
   end
   
-  def self.included(receiver)
-    receiver.extend         ClassMethods
+  # Transforms a record to array of values according to the passed attributes
+  def to_array(attributes)
+    res = []
+    for a in attributes
+      begin
+        next if a[:included] == false
+        v = send(a[:name])
+        # a work-around for to_json not taking the current timezone into account when serializing ActiveSupport::TimeWithZone
+        v = v.to_datetime.to_s(:db) if v.is_a?(ActiveSupport::TimeWithZone)
+        res << v
+      rescue NoMethodError
+        # So that we don't crash at a badly configured column
+        res << "UNDEF"
+      end
+    end
+    res
+  end
+  
+  # Accepts both hash and array of attributes
+  def to_hash(attributes)
+    res = {}
+    for a in (attributes.is_a?(Hash) ? attributes.values : attributes)
+      next if a[:included] == false
+      res[a[:name].to_sym] = self.value_for_attribute(a)
+    end
+    res
   end
+  
+  def value_for_attribute(a)
+    begin
+      v = send(a[:name])
+      # a work-around for to_json not taking the current timezone into account when serializing ActiveSupport::TimeWithZone
+      v = v.to_datetime.to_s(:db) if v.is_a?(ActiveSupport::TimeWithZone)
+      v
+    rescue NoMethodError
+      # So that we don't crash at a badly configured column
+      "UNDEF"
+    end
+  end
+  
 end

data/lib/netzke/active_record/combobox_options.rb

@@ -1,10 +1,11 @@
 module Netzke::ActiveRecord::ComboboxOptions
   module ClassMethods
-    # TODO: rename to netzke_options_for (to avoid naming conflicts)
-    def options_for(column, query = "")
+    
+    def netzke_combo_options_for(column, query = "")
       records = query.empty? ? 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)}
     end
+    
   end
   
   def self.included(receiver)

data/lib/netzke/active_record/relation_extensions.rb

@@ -0,0 +1,35 @@
+module Netzke
+  module ActiveRecord
+    module RelationExtensions
+      
+      def extend_with(*params)
+        scope = params.shift
+        case scope.class.name
+        when "Symbol" # model's scope
+          self.send(scope, *params)
+        when "String" # SQL query or SQL query with params (e.g. ["created_at < ?", 1.day.ago])
+          params.empty? ? self.where(scope) : self.where([scope, *params])
+        when "Array"
+          self.extend_with(*scope)
+        when "Hash"   # conditions hash
+          self.where(scope)
+        when "Proc"   # receives a relation, must return a relation
+          scope.call(self)
+        else
+          raise ArgumentError, "Wrong parameter type for ActiveRecord::Relation#extend_with"
+        end
+      end
+      
+      # Non-destructively extends itself whith a hash of double-underscore'd conditions, 
+      # where the last part "__" is MetaWhere operator (which is required), e.g.:
+      #     {:role__name__like => "%admin"}
+      def extend_with_netzke_conditions(cond)
+        cond.each_pair.inject(self) do |r, (k,v)|
+          assoc, method, *operator = k.to_s.split("__")
+          operator.empty? ? r.where(assoc.to_sym.send(method) => v) : r.where(assoc.to_sym => {method.to_sym.send(operator.last) => v}).joins(assoc.to_sym)
+        end
+      end
+      
+    end
+  end
+end

data/lib/netzke/basepack.rb

@@ -0,0 +1,27 @@
+require 'netzke/basepack/version'
+require 'netzke/active_record'
+
+module Netzke
+  module Basepack
+    mattr_accessor :with_icons
+    
+    mattr_accessor :icons_uri
+    
+    class << self
+      # Called from netzke-basepack.rb
+      def init
+        Netzke::Core.javascripts << "#{File.dirname(__FILE__)}/../../javascripts/basepack.js"
+        Netzke::Core.stylesheets << "#{File.dirname(__FILE__)}/../../stylesheets/basepack.css"
+      end
+    
+      # Use it to confirure Basepack in the initializers, e.g.:
+      # 
+      #     Netzke::Basepack.setup do |config|
+      #      config.icons_uri = "/images/famfamfam/icons"
+      #     end
+      def setup
+        yield self
+      end
+    end
+  end
+end

data/lib/netzke/basepack/version.rb

@@ -0,0 +1,11 @@
+module Netzke
+  module Basepack
+    module Version
+      MAJOR = 0
+      MINOR = 6
+      PATCH = 0
+
+      STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+    end
+  end
+end

data/lib/netzke/basepack/wrap_lazy_loaded.rb

@@ -0,0 +1,26 @@
+module Netzke
+  module Basepack
+    # Include this module into your component component class when you want lazy-loaded component in config to be auto-replaced with
+    # a panel with the 'fit' layout, and a property wrappedComponent set to the name of the original component.
+    # Used, for instance, in TabPanel and AccordionPanel to dynamically load components on expanding a panel or clicking
+    # a tab.
+    module WrapLazyLoaded
+      def items
+        orig = super.dup
+        orig.each do |item|
+          wrapped_component = components[item[:component]]
+          # When a nested component with lazy loading is detected, it gets replaced with a 'fit' panel,
+          # into which later the component itself is dynamically loaded on request.
+          if wrapped_component && wrapped_component[:lazy_loading]
+            item.replace({
+              :layout => 'fit',
+              :wrapped_component => wrapped_component[:name],
+              :title => wrapped_component[:title] || wrapped_component[:name]
+            })
+          end
+        end
+        orig
+      end
+    end
+  end
+end

data/lib/netzke/data_accessor.rb

@@ -1,62 +1,67 @@
-require "netzke/active_record/data_accessor"
-require "searchlogic"
+require 'netzke/active_record'
 
 module Netzke
-  # This module is included into such data-driven widgets as GridPanel, FormPanel, etc.
+  # This module is included into such data-driven components as GridPanel, FormPanel, etc.
   module DataAccessor
-    # This method should be called from the constructor of the widget.
-    def apply_helpers
-      # Generic extensions to the data model
-      if data_class # because some widgets, like FormPanel, may have it optional
-        data_class.send(:include, Netzke::ActiveRecord::DataAccessor) if !data_class.include?(Netzke::ActiveRecord::DataAccessor)
-      end
-    end
     
     # Returns options for comboboxes in grids/forms
     def combobox_options_for_column(column, method_options = {})
+      query = method_options[:query]
+      
       # First, check if we have options for this column defined in persistent storage
       options = column[:combobox_options] && column[:combobox_options].split("\n")
       if options
-        (method_options[:query].nil? ? options : options.select{ |o| o.index(/^#{method_options[:query]}/) }).map{ |el| [el] }
+        query ? options.select{ |o| o.index(/^#{query}/) }.map{ |el| [el] } : options
       else      
         assoc, assoc_method = assoc_and_assoc_method_for_column(column)
       
         if assoc
           # Options for an asssociation attribute
-        
-          search = assoc.klass.searchlogic
-      
-          # apply scopes
-          method_options[:scopes] && method_options[:scopes].each do |s|
-            if s.is_a?(Array)
-              scope_name, *args = s
-              search.send(scope_name, *args)
-            else
-              search.send(s, true)
-            end
-          end
+          
+          relation = assoc.klass.where({})
+          
+          relation = relation.extend_with(method_options[:scope]) if method_options[:scope]
         
           if assoc.klass.column_names.include?(assoc_method)
             # apply query
-            search.send("#{assoc_method}_like", "#{method_options[:query]}%") if method_options[:query]
-            search.all.map{ |r| [r.send(assoc_method)] }
+            relation = relation.where(:"#{assoc_method}".like => "#{query}%") if query.present?
+            relation.all.map{ |r| [r.send(assoc_method)] }
           else
-            search.all.map{ |r| r.send(assoc_method) }.select{ |value| value =~ /^#{method_options[:query]}/  }.map{ |v| [v] }
+            relation.all.map{ |r| r.send(assoc_method) }.select{ |value| value =~ /^#{query}/  }.map{ |v| [v] }
           end
         
         else
           # Options for a non-association attribute
-          data_class.options_for(column[:name], method_options[:query]).map{|s| [s]}
+          res=data_class.netzke_combo_options_for(column[:name], method_options)
+					
+					# ensure it is an array-in-array, as Ext will fail otherwise
+					raise RuntimeError, "netzke_combo_options_for should return an Array" unless res.kind_of? Array
+					return [[]] if res.empty?
+					
+					unless res.first.kind_of? Array
+						res=res.map do |v|
+							[v]
+						end
+					end
+					return res
+					
+					
         end
       end
     end
     
+    # Normalize array of attributes
     # [:col1, "col2", {:name => :col3}] =>
     #   [{:name => "col1"}, {:name => "col2"}, {:name => "col3"}]
-    def normalize_attr_config(cols)
-      cols.map do |c|
-        c.is_a?(Symbol) || c.is_a?(String) ? {:name => c.to_s} : c.merge(:name => c[:name].to_s)
-      end
+    def normalize_attrs(attrs)
+      attrs.map{ |a| normalize_attr(a) }
+    end
+    
+    # Normalize an attribute, e.g.:
+    # :first_name => 
+    #   {:name => "first_name"}
+    def normalize_attr(a)
+      a.is_a?(Symbol) || a.is_a?(String) ? {:name => a.to_s} : a.merge(:name => a[:name].to_s)
     end
     
     # Returns association and association method for a column
@@ -69,6 +74,29 @@ module Netzke
     def association_attr?(name)
       !!name.to_s.index("__")
     end
-    
+
+	# Model class
+    # (We can't memoize this method because at some point we extend it, e.g. in Netzke::DataAccessor)
+    def data_class
+      @data_class ||= begin
+        klass = "Netzke::ModelExtensions::#{config[:model]}For#{short_component_class_name}".constantize rescue nil
+        klass || original_data_class
+      end
+    end
+        
+    # Model class before model extensions are taken into account
+    def original_data_class
+      @original_data_class ||= begin
+        ::ActiveSupport::Deprecation.warn("data_class_name option is deprecated. Use model instead", caller) if config[:data_class_name]
+        model_name = config[:model] || config[:data_class_name]
+        model_name.nil? ? raise(ArgumentError, "No model specified for component #{global_id}") : model_name.constantize
+      end
+    end
+
+    # whether a column is bound to the primary_key
+    def primary_key_attr?(a)
+      data_class && a[:name].to_s == data_class.primary_key
+    end
+
   end
 end