skozlov-netzke-basepack 0.1.1.2 → 0.5.0

data/generators/netzke_basepack/netzke_basepack_generator.rb

@@ -1,8 +0,0 @@
-class NetzkeBasepackGenerator < Rails::Generator::NamedBase
-  def manifest
-    record do |m|
-      # m.directory "lib"
-      # m.template 'README', "README"
-    end
-  end
-end

data/generators/netzke_basepack/netzke_grid_generator.rb

@@ -1,7 +0,0 @@
-class NetzkeGridGenerator < Rails::Generator::Base
-  def manifest
-    record do |m|
-      m.migration_template 'create_netzke_grid_columns.rb', "db/migrate", {:migration_file_name => "create_netzke_grid_columns"}
-    end
-  end
-end

data/generators/netzke_basepack/templates/create_netzke_grid_columns.rb

@@ -1,21 +0,0 @@
-class CreateNetzkeGridColumns < ActiveRecord::Migration
-  def self.up
-    create_table :netzke_grid_columns do |t|
-      t.string    :name
-      t.string    :label
-      t.boolean   :read_only
-      t.integer   :position
-      t.boolean   :hidden
-      t.integer   :width
-      t.string    :shows_as, :limit => 32
-
-      t.integer   :layout_id
-      
-      t.timestamps
-    end
-  end
-
-  def self.down
-    drop_table :netzke_grid_columns
-  end
-end

data/lib/app/models/netzke_grid_column.rb

@@ -1,23 +0,0 @@
-class NetzkeGridColumn < ActiveRecord::Base
-  belongs_to :layout, :class_name => "NetzkeLayout"
-  
-  acts_as_list :scope => :layout
-
-  # old?
-  # def self.create_with_defaults(column_config, klass)
-  #   create(klass.default_column_config(column_config).stringify_values!)
-  # end
-  
-  def self.create_layout_for_widget(widget)
-    layout = NetzkeLayout.create(:widget_name => widget.id_name, :items_class => self.name, :user_id => NetzkeLayout.user_id)
-
-    columns = Netzke::Column.default_columns_for_widget(widget)
-
-    for c in columns
-      config_for_create = c.merge(:layout_id => layout.id).stringify_values!
-      create(config_for_create)
-    end
-    
-    layout
-  end
-end

data/lib/netzke/accordion.rb

@@ -1,11 +0,0 @@
-module Netzke
-  class Accordion < Container
-
-    def js_default_config
-      super.merge({
-        :layout => 'accordion'
-      })
-    end
-    
-  end
-end

data/lib/netzke/ar_ext.rb

@@ -1,163 +0,0 @@
-module Netzke
-  module ActiveRecordExtensions
-    def self.included(base)
-      base.extend ActiveRecordClassMethods
-    end
-
-    #
-    # Allow nested association acces (assocs separated by "." or "__"), e.g.: proxy_service.send('asset__gui_folder__name')
-    # Example:
-    # b = Book.first
-    # b.genre__name = 'Fantasy' => b.genre = Genre.find_by_name('Fantasy')
-    # NOT IMPLEMENTED: ANY 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 originar 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
-    
-    
-    module ActiveRecordClassMethods
-      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.send(column).index(/^#{query}/)}
-            end
-          end
-        end
-      end
-      
-      # which columns are to be picked up by grids and forms
-      def expose_columns(columns, *args)
-        if columns == :all
-          write_inheritable_attribute(:exposed_columns, self.column_names.map(&:to_sym))
-        else
-          write_inheritable_attribute(:exposed_columns, columns)
-        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
-      
-      #
-      # Used by Netzke::Grid
-      #
-      
-      DEFAULT_COLUMN_WIDTH = 100
-      
-      def default_column_config(config)
-        config = {:name => config} if config.is_a?(Symbol) # optionally we may get only a column name (as Symbol)
-        type = (columns_hash[config[:name].to_s] && columns_hash[config[:name].to_s].type) || :virtual
-
-        # general config
-        res = {
-          :name => config[:name].to_s || "unnamed",
-          :label => config[:label] || config[:name].to_s.humanize,
-          :read_only => config[:name] == :id, # make "id" column read-only by default
-          :hidden => config[:name] == :id, # hide "id" column by default
-          :width => DEFAULT_COLUMN_WIDTH,
-          :shows_as => :text_field
-        }
-
-        case type
-          when :integer
-            res[:shows_as] = :number_field
-          when :boolean
-            res[:shows_as] = :checkbox
-            res[:width] = 50
-          when :date
-            res[:shows_as] = :date_field
-          when :datetime
-            res[:shows_as] = :datetime
-          when :string
-            res[:shows_as] = :text_field
-        end
-
-        res.merge(config) # merge with custom confg (it has the priority)
-      end
-      
-      #
-      # Used by Netzke::Form
-      #
-      
-      DEFAULT_FIELD_WIDTH = 100
-      DEFAULT_FIELD_HEIGHT = 50
-      def default_field_config(config)
-        # TODO
-      end
-      
-    end
-  end
-end
-
-ActiveRecord::Base.class_eval do
-  include Netzke::ActiveRecordExtensions
-end

data/lib/netzke/column.rb

@@ -1,43 +0,0 @@
-module Netzke
-  class Column
-    def self.default_columns_for_widget(widget)
-      raise ArgumentError, "No data_class_name specified for widget #{widget.config[:name]}" if widget.config[:data_class_name].nil?
-
-      # layout = NetzkeLayout.create(:widget_name => widget.id_name, :items_class => self.name, :user_id => NetzkeLayout.user_id)
-
-      data_class = widget.config[:data_class_name].constantize
-
-      exposed_columns = normalize_columns(data_class.exposed_columns) # columns exposed from the data class
-
-      columns_from_config = widget.config[:columns] && normalize_columns(widget.config[:columns]) # columns specified in widget's config
-
-      if columns_from_config
-        # reverse-merge each column hash from config with each column hash from exposed_columns (columns from config have higher priority)
-        for c in columns_from_config
-          corresponding_exposed_column = exposed_columns.find{ |k| k[:name] == c[:name] }
-          c.reverse_merge!(corresponding_exposed_column) if corresponding_exposed_column
-        end
-        columns_for_create = columns_from_config
-      else
-        # we didn't have columns configured in widget's config, so, use the columns from the data class
-        columns_for_create = exposed_columns
-      end
-
-      res = []
-      for c in columns_for_create
-        # finally reverse-merge them with the defaults from the data_class
-        res << data_class.default_column_config(c)
-      end
-      
-      res
-    end
-    
-    protected
-
-    # like this: [:col1, {:name => :col2}, :col3] => [{:name => :col1}, {:name => :col2}, {:name => :col3}]
-    def self.normalize_columns(items)
-      items.map{|c| c.is_a?(Symbol) ? {:name => c} : c}
-    end
-    
-  end
-end

data/lib/netzke/container.rb

@@ -1,81 +0,0 @@
-module Netzke
-  #
-  # Base class for Accordion and TabPanel widgets, it shouldn't be used as a stand-alone class.
-  #
-  class Container < Base
-    def initialize(*args)
-      super
-      for item in initial_items do
-        add_aggregatee item
-        items << item.keys.first
-      end
-    end
-    
-    def initial_dependencies
-      dep = super
-      for item in items
-        candidate_dependency = aggregatees[item][:widget_class_name]
-        dep << candidate_dependency unless dep.include?(candidate_dependency)
-      end
-      dep
-    end
-
-    def js_before_constructor
-      js_widget_items
-    end
-    
-    def items
-      @items ||= []
-    end
-    
-    def initial_items
-      config[:items] || []
-    end
-    
-    def js_widget_items
-      res = ""
-      item_aggregatees.each_pair do |k,v|
-        next if v[:late_aggregation]
-        res << <<-JS
-        var #{k.to_js} = new Ext.componentCache['#{v[:widget_class_name]}'](config.#{k.to_js}Config);
-        JS
-      end
-      res
-    end
-
-    def js_items
-      items.inject([]) do |a,i|
-        a << {
-          :title => i.to_s.humanize,
-          :layout => 'fit',
-          :id => i.to_s,
-          # :id => "#{config[:name]}_#{i.to_s}",
-          :items => ([i.to_s.to_js.l] if !aggregatees[i][:late_aggregation]),
-          # these listeners will be different for tab_panel and accordion
-          :collapsed => !aggregatees[i][:active],
-          :listeners => {
-            # :activate => {:fn => "function(p){this.feedback(p.id)}".l, :scope => this},
-            :expand => {:fn => "this.loadItemWidget".l, :scope => this}
-          }
-        }
-      end
-    end
-    
-    def js_extend_properties
-      {
-        # loads widget into the panel if it's not loaded yet
-        :load_item_widget => <<-JS.l,
-          function(panel) {
-            if (!panel.getWidget()) panel.loadWidget(this.id + "__" + panel.id + "__get_widget");
-            // if (!this.getWidgetByPanel(panel)) this.loadWidget(panel, this.initialConfig[panel.id+'Config'].interface.getWidget);
-          }
-        JS
-      }
-    end
-
-    protected
-    def item_aggregatees
-      aggregatees.delete_if{|k,v| !@items.include?(k)}
-    end
-  end
-end

data/lib/netzke/grid.rb

@@ -1,120 +0,0 @@
-require 'searchlogic'
-module Netzke
-  #
-  # Functionality:
-  # * data operations - get, post, delete, create
-  # * column resize and move
-  # * permissions
-  # * sorting - TODO
-  # * pagination
-  # * validation - TODO
-  # * properties and column configuration
-  #
-  class Grid < Base
-    include GridJsBuilder
-    include GridInterface
-    # define connection points between client side and server side of Grid. See implementation of equally named methods in the GridInterface module.
-    interface :get_data, :post_data, :delete_data, :resize_column, :move_column, :get_cb_choices
-
-    def initial_config
-      {
-        :ext_config => {:properties => true, :column_filters => true},
-        :layout_manager => "NetzkeLayout",
-        :column_resize => true,
-        :column_move => true
-      }
-    end
-
-    def property_widgets
-      [{
-        :columns => {
-          :widget_class_name => "Grid", 
-          :data_class_name => column_manager_class_name, 
-          :ext_config => {:title => false, :properties => false},
-          :active => true
-        }
-      },{
-        :general => {
-          :widget_class_name => "PreferenceGrid", 
-          :host_widget_name => @id_name, 
-          :default_properties => available_permissions.map{ |k| {:name => "permissions.#{k}", :value => @permissions[k.to_sym]}},
-          :ext_config => {:title => false}
-        }
-      }]
-    end
-
-    ## Data for properties grid
-    def properties__columns__get_data(params = {})
-      columns_widget = aggregatee_instance(:properties__columns)
-
-      layout_id = layout_manager_class.by_widget(id_name).id
-      columns_widget.interface_get_data(params.merge(:filters => {:layout_id => layout_id}))
-    end
-    
-    def properties__general__load_source(params = {})
-      w = aggregatee_instance(:properties__general)
-      w.interface_load_source(params)
-    end
-    
-
-
-    protected
-    
-    def layout_manager_class
-      config[:layout_manager] && config[:layout_manager].constantize
-    end
-    
-    def column_manager_class_name
-      "NetzkeGridColumn"
-    end
-    
-    def column_manager_class
-      column_manager_class_name.constantize
-    rescue NameError
-      nil
-    end
-    
-    def available_permissions
-      %w(read update create delete)
-    end
-
-    public
-
-    # get columns from layout manager
-    def get_columns
-      if layout_manager_class
-        layout = layout_manager_class.by_widget(id_name)
-        layout ||= column_manager_class.create_layout_for_widget(self)
-        layout.items_hash  # TODO: bad name!
-      else
-        Netzke::Column.default_columns_for_widget(self)
-      end
-    end
-    
-    def tools
-      [{:id => 'refresh', :on => {:click => 'refreshClick'}}]
-    end
-
-    def actions
-      [{
-        :text => 'Add', :handler => 'add', :disabled => @pref['permissions.create'] == false
-      },{
-        :text => 'Edit', :handler => 'edit', :disabled => @pref['permissions.update'] == false
-      },{
-        :text => 'Delete', :handler => 'delete', :disabled => @pref['permissions.delete'] == false
-      },{
-        :text => 'Apply', :handler => 'submit', :disabled => @pref['permissions.update'] == false && @pref['permissions.create'] == false
-      }]
-    end
-
-    
-
-    # Uncomment to enable a menu duplicating the actions
-    # def js_menus
-    #   [{:text => "config.dataClassName".l, :menu => "config.actions".l}]
-    # end
-    
-    # include ColumnOperations
-    include PropertiesTool # it will load aggregation with name :properties into a modal window
-  end
-end