netzke-basepack 0.7.7 → 0.8.0

data/TODO.rdoc

@@ -1,8 +0,0 @@
-== Priority
-* Commit persistence migrations in the test app
-* DataAccessor#to_array should not rescue exceptions, but rather check the availability of the attributes; `respond_to_with_basepack?` should be extended to also return true for association columns
-* GridPanel's read_only vs editable (doesn't work now) options
-* Find a way to print the grid nicely (along with the column and rows that don't fit on the screen)
-
-== Foolproof
-* Should not be possible to put the "ID" field on any place but first for grids (otherwise record ID is not correct)

data/lib/generators/netzke/basepack_generator.rb

@@ -1,10 +0,0 @@
-module Netzke
-  class BasepackGenerator < ::Rails::Generators::Base
-    source_root File.expand_path('../templates', __FILE__)
-
-    desc 'Copies necessary assets to public/netzke/basepack'
-    def execute
-      copy_file 'assets/ts-checkbox.gif', "public/netzke/basepack/ts-checkbox.gif"
-    end
-  end
-end

data/lib/generators/netzke/templates/create_netzke_field_lists.rb

@@ -1,18 +0,0 @@
-class CreateNetzkeFieldLists < ActiveRecord::Migration
-  def self.up
-    create_table :netzke_field_lists do |t|
-      t.string  :name
-      t.text    :value
-      t.string  :model_name
-      t.integer :user_id
-      t.integer :role_id
-      t.string  :type
-
-      t.timestamps
-    end
-  end
-
-  def self.down
-    drop_table :netzke_field_lists
-  end
-end

data/lib/netzke/active_record.rb

@@ -1,20 +0,0 @@
-require 'netzke/active_record/attributes'
-require 'netzke/active_record/combobox_options'
-require 'netzke/active_record/relation_extensions'
-
-module Netzke
-  module ActiveRecord
-  end
-end
-
-if defined? ActiveRecord
-  # Extend ActiveRecord
-  ActiveRecord::Base.class_eval do
-    include ::Netzke::ActiveRecord::Attributes
-    include ::Netzke::ActiveRecord::ComboboxOptions
-  end
-
-  ActiveRecord::Relation.class_eval do
-    include ::Netzke::ActiveRecord::RelationExtensions
-  end
-end

data/lib/netzke/active_record/attributes.rb

@@ -1,259 +0,0 @@
-module Netzke
-  module ActiveRecord
-    module Attributes
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :netzke_declared_attr
-        self.netzke_declared_attr = []
-
-        class_attribute :netzke_excluded_attr
-        self.netzke_excluded_attr = []
-
-        class_attribute :netzke_exposed_attr
-      end
-
-      module ClassMethods
-        def data_adapter
-          @data_adapter = Netzke::Basepack::DataAdapters::AbstractAdapter.adapter_class(self).new(self)
-        end
-
-        # Define or configure an attribute.
-        # Example:
-        #   netzke_attribute :recent, :type => :boolean, :read_only => true
-        def netzke_attribute(name, options = {})
-          name = name.to_s
-          options[:attr_type] = options.delete(:type) || options.delete(:attr_type) || :string
-          declared_attrs = self.netzke_declared_attr.dup
-          # if the attr was declared already, simply merge it with the new options
-          existing = declared_attrs.detect{ |va| va[:name] == name }
-          if existing
-            existing.merge!(options)
-          else
-            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
-          self.netzke_declared_attr = declared_attrs
-        end
-
-        # Exclude attributes from being picked up by grids and forms.
-        # Accepts an array of attribute names (as symbols).
-        # Example:
-        #   netzke_expose_attributes :created_at, :updated_at, :crypted_password
-        def netzke_exclude_attributes(*args)
-          self.netzke_excluded_attr = args.map(&:to_s)
-        end
-
-        # Explicitly expose attributes that should be picked up by grids and forms.
-        # Accepts an array of attribute names (as symbols).
-        # Takes precedence over <tt>netzke_exclude_attributes</tt>.
-        # Example:
-        #   netzke_expose_attributes :name, :role__name
-        def netzke_expose_attributes(*args)
-          self.netzke_exposed_attr = args.map(&:to_s)
-        end
-
-        # Returns the attributes that will be picked up by grids and forms.
-        def netzke_attributes
-          exposed = netzke_exposed_attributes
-          exposed ? netzke_attrs_in_forced_order(exposed) : netzke_attrs_in_natural_order
-        end
-
-        def netzke_attribute_hash
-          netzke_attributes.inject({}){ |r,a| r.merge(a[:name].to_sym => a) }
-        end
-
-        def netzke_exposed_attributes
-          exposed = self.netzke_exposed_attr
-          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_attrs_in_forced_order(attrs)
-            attrs.collect do |attr_name|
-              declared = self.netzke_declared_attr.detect { |va| va[:name] == attr_name } || {}
-              in_columns_hash = columns_hash[attr_name] && {:name => attr_name, :attr_type => columns_hash[attr_name].type, :default_value => columns_hash[attr_name].default} || {} # {:virtual => true} # if nothing found in columns, mark it as "virtual" or not?
-              if in_columns_hash.empty?
-                # If not among the model columns, it's either virtual, or an association
-                merged = association_attr?(attr_name) ? declared.merge!(:name => attr_name) : declared.merge(:virtual => true)
-              else
-                # .. otherwise merge with what's declared
-                merged = in_columns_hash.merge(declared)
-              end
-
-              # We didn't find it among declared, nor among the model columns, nor does it seem association attribute
-              merged[:name].nil? && raise(ArgumentError, "Unknown attribute '#{attr_name}' for model #{self.name}", caller)
-
-              merged
-            end
-          end
-
-          # Returns netzke attributes in the order of columns in the table, followed by extra declared attributes
-          # Detects one-to-many association columns and replaces the name of the column with association column name (Netzke style), e.g.:
-          #
-          #   role_id => role__name
-          def netzke_attrs_in_natural_order
-            (
-              declared_attrs = self.netzke_declared_attr
-
-              column_names.map do |name|
-                c = {:name => name, :attr_type => columns_hash[name].type}
-
-                # If it's named as foreign key of some association, then it's an association column
-                assoc = reflect_on_all_associations.detect { |a| foreign_key_for_assoc(a) == c[:name] }
-
-                if assoc && !assoc.options[:polymorphic]
-                  candidates = %w{name title label} << foreign_key_for_assoc(assoc)
-                  assoc_method = candidates.detect{|m| (assoc.klass.instance_methods.map(&:to_s) + assoc.klass.column_names).include?(m) }
-                  c[:name] = "#{assoc.name}__#{assoc_method}"
-                  c[:attr_type] = :integer # when it's an instance method rather than a column, fall back to :string
-                end
-
-                # auto set up the default value from the column settings
-                c.merge!(:default_value => columns_hash[name].default) if columns_hash[name].default
-
-                # if there's a declared attr with the same name, simply merge it with what's taken from the model's columns
-                if declared = declared_attrs.detect{ |va| va[:name] == c[:name] }
-                  c.merge!(declared)
-                  declared_attrs.delete(declared)
-                end
-                c
-              end +
-              declared_attrs
-            ).reject { |attr| self.netzke_excluded_attr.include?(attr[:name]) }
-          end
-
-          # Returns foreign key for given association (Rails >= 3.0)
-          def foreign_key_for_assoc(assoc)
-            assoc.respond_to?(:foreign_key) ? assoc.foreign_key : assoc.primary_key_name
-          end
-
-          def association_attr?(attr_name)
-            !!attr_name.index("__") # probably we can't do much better than this, as we don't know at this moment if the associated model has a specific attribute, and we don't really want to find it out
-          end
-
-      end
-
-      # Transforms a record to array of values according to the passed attributes
-      def netzke_array(attributes = self.class.netzke_attributes)
-        res = []
-        for a in attributes
-          next if a[:included] == false
-          res << value_for_attribute(a, a[:nested_attribute])
-        end
-        res
-      end
-
-      def netzke_json
-        netzke_hash.to_nifty_json
-      end
-
-      # Accepts both hash and array of attributes
-      def netzke_hash(attributes = self.class.netzke_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, a[:nested_attribute])
-        end
-        res
-      end
-
-      # Fetches the value specified by an (association) attribute
-      # If +through_association+ is true, get the value of the association by provided method, *not* the associated record's id
-      # E.g., author__name with through_association set to true may return "Vladimir Nabokov", while with through_association set to false, it'll return author_id for the current record
-      def value_for_attribute(a, through_association = false)
-        v = if a[:getter]
-          a[:getter].call(self)
-        elsif respond_to?("#{a[:name]}")
-          send("#{a[:name]}")
-        elsif is_association_attr?(a)
-          split = a[:name].to_s.split(/\.|__/)
-          assoc = self.class.reflect_on_association(split.first.to_sym)
-          if through_association
-            split.inject(self) do |r,m| # TODO: do we really need to descend deeper than 1 level?
-              if r.respond_to?(m)
-                r.send(m)
-              else
-                logger.debug "Netzke::Basepack: Wrong attribute name: #{a[:name]}" unless r.nil?
-                nil
-              end
-            end
-          else
-            self.send("#{assoc.options[:foreign_key] || assoc.name.to_s.foreign_key}")
-          end
-        end
-
-        # 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 [ActiveSupport::TimeWithZone].include?(v.class)
-
-        v
-      end
-
-      # Assigns new value to an (association) attribute
-      def set_value_for_attribute(a, v)
-        v = v.to_time_in_current_zone if v.is_a?(Date) # convert Date to Time
-
-        if a[:setter]
-          a[:setter].call(self, v)
-        elsif respond_to?("#{a[:name]}=")
-          send("#{a[:name]}=", v)
-        elsif is_association_attr?(a)
-          split = a[:name].to_s.split(/\.|__/)
-          if a[:nested_attribute]
-            # We want:
-            #     set_value_for_attribute({:name => :assoc_1__assoc_2__method, :nested_attribute => true}, 100)
-            # =>
-            #     self.assoc_1.assoc_2.method = 100
-            split.inject(self) { |r,m| m == split.last ? (r && r.send("#{m}=", v) && r.save) : r.send(m) }
-          else
-            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
-              if assoc
-                if assoc.macro == :has_one
-                  assoc_instance = self.send(assoc.name)
-                  if assoc_instance
-                    assoc_instance.send("#{assoc_method}=", v)
-                    assoc_instance.save # what should we do when this fails?..
-                  else
-                    # what should we do in this case?
-                  end
-                else
-
-                  # set the foreign key to the passed value
-                  # not that if a negative value is passed, we reset the association (set it to nil)
-                  self.send("#{assoc.foreign_key}=", v.to_i < 0 ? nil : v)
-                end
-              else
-                logger.debug "Netzke::Basepack: Association #{assoc} is not known for class #{self.class.name}"
-              end
-            else
-              logger.debug "Netzke::Basepack: Wrong attribute name: #{a[:name]}"
-            end
-          end
-        end
-      end
-
-      protected
-
-        # Returns true if passed attribute is an "association attribute"
-        def is_association_attr?(a)
-          # maybe the check is too simplistic, but will do for now
-          !!a[:name].to_s.index("__")
-        end
-
-    end
-  end
-end

data/lib/netzke/active_record/combobox_options.rb

@@ -1,16 +0,0 @@
-module Netzke
-  module ActiveRecord
-    module ComboboxOptions
-      module ClassMethods
-        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)
-        receiver.extend         ClassMethods
-      end
-    end
-  end
-end

data/lib/netzke/active_record/relation_extensions.rb

@@ -1,37 +0,0 @@
-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 "ActiveSupport::HashWithIndifferentAccess" # 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/accordion_panel.rb

@@ -1,39 +0,0 @@
-module Netzke
-  module Basepack
-    # = AccordionPanel
-    #
-    # A panel with the 'accordion' layout. Can lazily load its nested components. For example:
-    #
-    #     netzke :my_accordion, :items => [{
-    #         :html => "I'm a simple Ext.Panel",
-    #         :title => "Panel One"
-    #       },{
-    #         :class_name => "SimplePanel",
-    #         :update_text => "Update for Panel Two",
-    #         :title => "Panel Two",
-    #         :lazy_loading => true
-    #       }]
-    class AccordionPanel < Netzke::Base
-
-      include WrapLazyLoaded
-
-      js_property :layout, 'accordion'
-      js_property :component_load_mask, {:msg => null} # due to a probable bug in Ext's Accordion Layout (mask message is mis-layed-out), disabling mask message
-
-      js_method :init_component, <<-JS
-        function(params){
-          #{js_full_class_name}.superclass.initComponent.call(this);
-          this.items.each(function(item){
-            item.on('expand', function(i){
-              if (i && i.wrappedComponent && !i.items.first() && !i.beingLoaded) {
-                i.beingLoaded = true; // prevent more than one request per panel in case of fast clicking
-                this.loadNetzkeComponent({name: i.wrappedComponent, container: i.id}, function(){i.beingLoaded = false});
-              }
-            }, this);
-          }, this);
-        }
-      JS
-
-    end
-  end
-end

data/lib/netzke/basepack/action_column.rb

@@ -1,68 +0,0 @@
-module Netzke
-  module Basepack
-    module ActionColumn
-      extend ActiveSupport::Concern
-
-      included do |base|
-
-        # Returns registered actions
-        class_attribute :registered_column_actions
-        self.registered_column_actions = []
-
-        js_include :action_column
-      end
-
-      module ClassMethods
-        # Register an action
-        def register_column_action(name)
-          self.registered_column_actions |= [name]
-        end
-
-        # Use this method to define column actions in your component, e.g.:
-        #
-        #     column_action :edit, :icon => "/images/icons/edit.png"
-        #
-        # TODO: List all options.
-        # TODO: think how it'll be possible to override individual column_actions (if need to bother at all)
-        def column_action(name, params = {})
-          params[:name] = name
-          params[:column] ||= "actions"
-          params[:icon] ||= "/extjs/examples/shared/icons/fam/cog.png"
-          params[:tooltip] = params[:tooltip].presence || name.to_s.humanize
-          params[:handler] ||= "on_#{name}"
-          register_column_action(name);
-          define_method "#{name}_column_action" do |record=nil| # TODO: this won't work in Ruby 1.8.7
-            params[:row_config] && record ? params.merge(params[:row_config].call(record, self)) : params
-          end
-        end
-      end
-
-      def initial_columns(with_excluded = false)
-        orig_columns = super
-
-        action_column_names = column_actions.map{ |action| action[:column] }.uniq
-        action_columns = orig_columns.select{ |c| action_column_names.include? c[:name] }
-
-        # Append the column if none found AND no explicit column configuration was provided
-        if action_columns.empty? && !config[:columns]
-          action_columns = [{:name => "actions"}.merge(config[:override_columns].try(:fetch, :actions, nil) || {})]
-          orig_columns += action_columns
-        end
-
-        action_columns.each do |c|
-          c[:xtype] = :netzkeactioncolumn
-          c[:getter] = lambda do |r|
-            self.class.registered_column_actions.select{ |action_name| self.send("#{action_name}_column_action")[:column] == c[:name] }.map{ |action_name| self.send("#{action_name}_column_action", r) }.to_nifty_json
-          end
-        end
-
-        orig_columns
-      end
-
-      def column_actions
-        self.class.registered_column_actions.map{ |action_name| self.send("#{action_name}_column_action")}
-      end
-
-    end
-  end
-end