netzke-basepack 0.7.7 → 0.8.0

data/lib/netzke/basepack/data_adapters/sequel_adapter.rb

@@ -1,260 +0,0 @@
-module Netzke::Basepack::DataAdapters
-  class SequelAdapter < AbstractAdapter
-    def self.for_class?(model_class)
-      model_class <= Sequel::Model
-    end
-
-    def get_records(params, columns=[])
-      get_dataset(params, columns).all
-    end
-
-    def count_records(params, columns=[])
-      # dont pass columns, JOINs will be done as necessary for filters
-      get_dataset(params, [], true).count
-    end
-
-    def map_type type
-      type
-    end
-
-    def get_assoc_property_type assoc_name, prop_name
-      db_schema=class_for(assoc_name.to_sym).db_schema
-      # return nil if prop_name not present in db schema (virtual column)
-      db_schema[prop_name.to_sym] ? db_schema[prop_name.to_sym][:type] : nil
-    end
-
-    # like get_assoc_property_type but for non-association columns
-    def get_property_type column
-      column[:type]
-    end
-
-    def column_virtual? c
-      assoc, method = c[:name].split '__'
-      if method
-        !class_for(assoc.to_sym).columns.include? method.to_sym
-      else
-        !@model_class.columns.include? assoc.to_sym
-      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
-        query ? options.select{ |o| o.index(/^#{query}/) }.map{ |el| [el] } : options
-      else
-        assoc_name, assoc_method = column[:name].split '__'
-
-        if assoc_name
-          # Options for an asssociation attribute
-          dataset = class_for(assoc_name)
-
-          dataset = dataset.extend_with(method_options[:scope]) if method_options[:scope]
-
-          if class_for(assoc_name).column_names.include?(assoc_method)
-            # apply query
-            dataset = dataset.where(assoc_method.to_sym.like("%#{query}%")) if query.present?
-            dataset.all.map{ |r| [r.id, r.send(assoc_method)] }
-          else
-            dataset.all.map{ |r| [r.id, r.send(assoc_method)] }.select{ |id,value| value =~ /^#{query}/ }
-          end
-        else
-          # Options for a non-association attribute
-          res=@model_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
-
-    def foreign_key_for assoc_name
-      @model_class.association_reflection(assoc_name.to_sym)[:key].to_s
-    end
-
-    # Returns the model class for an association
-    def class_for assoc_name
-      @model_class.association_reflection(assoc_name.to_sym)[:class_name].constantize
-    end
-
-    def destroy(ids)
-      @model_class.where(:id => ids).destroy
-    end
-
-    def find_record(id)
-      @model_class[id]
-    end
-
-    # Build a hash of foreign keys and the associated model
-    def hash_fk_model
-      @model_class.all_association_reflections.inject({}) do |res, assoc|
-        res[assoc[:key]] = assoc[:class_name].constantize.model_name.underscore.to_sym
-        res
-      end
-    end
-
-    # TODO: is this possible with Sequel?
-    def move_records(params)
-    end
-
-    # give the data adapter the opportunity the set special options for
-    # saving
-    def save_record(record)
-      # don't raise an error on saving. basepack will evaluate record.errors
-      # to get validation errors
-      record.raise_on_save_failure = false
-      record.save
-    end
-
-    # give the data adapter the opporunity to process error messages
-    # must return an raay of the form ["Title can't be blank", "Foo can't be blank"]
-    def errors_array(record)
-      record.errors.to_a.inject([]) do |errors, error|
-        field, message = error
-        errors << "#{record.class.human_attribute_name(field)} #{message.join ', '}"
-        errors
-      end
-    end
-
-    # Needed for seed and tests
-    def last
-      @model_class.last
-    end
-
-    # Needed for seed and tests
-    def destroy_all
-      @model_class.destroy
-    end
-
-    private
-    def get_dataset params, columns, for_count=false
-      dataset = @model_class
-
-      graphed=[]
-
-      # Parses and applies grid column filters
-      #
-      # Example column grid data:
-      #
-      #     {"0" => {
-      #       "data" => {
-      #         "type" => "numeric",
-      #         "comparison" => "gt",
-      #         "value" => 10 },
-      #       "field" => "id"
-      #     },
-      #     "1" => {
-      #       "data" => {
-      #         "type" => "string",
-      #         "value" => "pizza"
-      #       },
-      #       "field" => "food_name"
-      #     }}
-      #
-
-      if params[:filter]
-        # these are still JSON-encoded due to the migration to Ext.direct
-        column_filter=JSON.parse(params[:filter])
-
-        column_filter.each do |v|
-          field = v["field"]
-          assoc, method = field.split('__')
-          if method
-            # when filtering on association's columns, we need to graph for LEFT OUTER JOIN
-            dataset = dataset.eager_graph assoc.to_sym unless graphed.include? assoc.to_sym
-            graphed << assoc.to_sym
-          end
-
-          value = v["value"]
-          type = v["type"]
-          op = v["comparison"]
-
-          if type == "string"
-            # strings are always LIKEd (case-insensitive)
-            dataset = dataset.filter field.to_sym.ilike("%#{value}%")
-          else
-            if type == "date"
-              # convert value to the DB date
-              value.match /(\d\d)\/(\d\d)\/(\d\d\d\d)/
-              value = "#{$3}-#{$1}-#{$2}"
-            end
-            # if it's NOT an association column, we need to qualify column name with model's table_name
-            qualified_column_name = method ? field.to_sym : field.to_sym.qualify(@model_class.table_name)
-            case op
-            when 'lt'
-              dataset = dataset.filter ":column < '#{value}'", :column => qualified_column_name
-            when 'gt'
-              dataset = dataset.filter ":column > '#{value}'", :column => qualified_column_name
-            else
-              dataset = dataset.filter qualified_column_name => value
-            end
-          end
-        end
-      end
-      # skip sorting, eager joining and paging if dataset is used for count
-      unless for_count
-        if params[:sort] && sort_params = params[:sort]
-          sort_params.each do |sort_param|
-            assoc, method = sort_param["property"].split("__")
-            dir = sort_param["direction"].downcase
-
-            # if a sorting scope is set, call the scope with the given direction
-            column = columns.detect { |c| c[:name] == sort_param["property"] }
-            if column.try(:'has_key?', :sorting_scope)
-              dataset = dataset.send(column[:sorting_scope].to_sym, dir.to_sym)
-            else
-              if method # sorting on associations column
-                # graph the association for LEFT OUTER JOIN
-                dataset = dataset.eager_graph(assoc.to_sym) unless graphed.include? assoc.to_sym
-                graphed << assoc.to_sym
-              end
-              # coincidentally, netzkes convention of specifying association's attributes
-              # i.e. "author__name" on Book matches sequel's convention
-              # so we can just pass symbolized property here
-              dataset = dataset.order(sort_param["property"].to_sym.send(dir))
-            end
-          end
-        end
-
-        # eager load the associations indicated by columns,
-        # but only if we didn't eager_graph them before (for ordering/filtering)
-        # because this saves a ID IN query
-        columns.each do |column|
-          if column[:name].index('__')
-            assoc, _ = column[:name].split('__')
-            dataset = dataset.eager(assoc.to_sym) unless graphed.include? assoc.to_sym
-          end
-        end
-
-        # apply paging
-        if params[:limit]
-          if params[:start]
-            dataset = dataset.limit params[:limit], params[:start]
-          else
-            dataset = dataset.limit params[:limit]
-          end
-        end
-      end
-
-      # apply scope
-      # need to symbolize_keys, because when the request is made from client-side (as opposed
-      # to server-side on inital render), the scope's keys are given as string {"author_id" => 1}
-      # If we give Sequel a filter like this, it will (correctly) do WHERE 'author_id' = 1 - note the quotes
-      # making the database match the string author_id to 1 and to the column.
-      dataset = dataset.extend_with(params[:scope].symbolize_keys) if params[:scope]
-      dataset
-    end
-  end
-
-end

data/lib/netzke/basepack/form_panel.rb

@@ -1,144 +0,0 @@
-require "netzke/basepack/form_panel/fields"
-require "netzke/basepack/form_panel/services"
-# require "netzke/plugins/configuration_tool"
-
-module Netzke
-  module Basepack
-    # Ext.form.Panel-based component
-    #
-    # == Netzke-specific config options
-    #
-    # * +model+ - name of the ActiveRecord model that provides data to this GridPanel.
-    # * +record+ - record to be displayd in the form. Takes precedence over +:record_id+
-    # * +record_id+ - id of the record to be displayd in the form. Also see +:record+
-    # * +items+ - the layout of the fields as an array. See "Layout configuration".
-    # * +mode+ - render mode, accepted options:
-    #   * +lockable+ - makes the form panel load initially in "display mode", then lets "unlock" it, change the values, and "lock" it again, while updating the values on the server
-    # * +updateMask+ - +Ext.LoadMask+ config options for the mask shown while the form is submitting its values
-    #
-    # === Layout configuration
-    #
-    # The layout of the form is configured by supplying the +item+ config option, same way it would be configured in Ext (thus allowing for complex form layouts). FormPanel will expand fields by looking at their names (unless +no_binding+ set to +true+ is specified for a specific field).
-    #
-    # == Endpoints
-    # FormPanel implements the following endpoints:
-    #
-    # * +netzke_load+ - loads a record with a given id from the server, e.g.:
-    #
-    #     someFormPanel.netzkeLoad({id: 100});
-    #
-    # * +netzke_submit+ - gets called when the form gets submitted (e.g. by pressing the Apply button, or by calling onApply)
-    # * +get_combobox_options+ - gets called when a 'remote' combobox field gets expanded
-    class FormPanel < Netzke::Base
-
-      js_base_class "Ext.form.Panel"
-
-      # Class-level configuration
-      class_attribute :config_tool_available
-      self.config_tool_available = true
-
-      include self::Services
-      include self::Fields
-      include Netzke::Basepack::DataAccessor
-
-      delegates_to_dsl :model, :record_id
-
-      action :apply do
-        {
-          :text => I18n.t('netzke.basepack.form_panel.actions.apply'),
-          :tooltip => I18n.t('netzke.basepack.form_panel.actions.apply_tooltip'),
-          :icon => :tick
-        }
-      end
-
-      action :edit do
-        {
-          :text => I18n.t('netzke.basepack.form_panel.actions.edit'),
-          :tooltip => I18n.t('netzke.basepack.form_panel.actions.edit_tooltip'),
-          :icon => :pencil
-        }
-      end
-
-      action :cancel do
-        {
-          :text => I18n.t('netzke.basepack.form_panel.actions.cancel'),
-          :tooltip => I18n.t('netzke.basepack.form_panel.actions.cancel_tooltip'),
-          :icon => :cancel
-        }
-      end
-
-      def configuration
-        super.tap do |sup|
-          configure_locked(sup)
-          configure_bbar(sup)
-
-          sup[:record_id] = sup[:record] = nil if sup[:multi_edit] # never set record_id in multi-edit mode
-        end
-      end
-
-      def configure_locked(c)
-        c[:locked] = c[:locked].nil? ? (c[:mode] == :lockable) : c[:locked]
-      end
-
-      def configure_bbar(c)
-        c[:bbar] = [:apply.action] if c[:bbar].nil? && !c[:read_only]
-      end
-
-      # Extra JavaScripts and stylesheets
-      js_mixin :form_panel
-      js_include :comma_list_cbg
-      js_include :n_radio_group, :readonly_mode
-      css_include :readonly_mode
-
-      # WIP
-      # js_include Netzke::Core.ext_path.join("examples/ux/fileuploadfield/FileUploadField.js")
-      # css_include Netzke::Core.ext_path.join("examples/ux/fileuploadfield/css/fileuploadfield.css")
-
-      # WIP: Needed for FileUploadField
-      # js_include :misc
-
-      def js_config
-        super.tap do |res|
-          res[:pri] = data_class && data_class.primary_key.to_s
-          res[:record] = js_record_data if record
-        end
-      end
-
-      # A hash of record data including the meta field
-      def js_record_data
-        record.netzke_hash(fields).merge(:meta => meta_field).literalize_keys
-      end
-
-      def record
-        @record ||= config[:record] || config[:record_id] && data_class && data_adapter.find_record(config[:record_id])
-      end
-
-      private
-
-        def self.server_side_config_options
-          super + [:record, :scope]
-        end
-
-        def meta_field
-          {}.tap do |res|
-            assoc_values = get_association_values
-            res[:association_values] = assoc_values.literalize_keys if record && !assoc_values.empty?
-          end
-        end
-
-        def get_association_values
-          fields_that_need_associated_values = fields.select{ |k,v| k.to_s.index("__") && !fields[k][:nested_attribute] }
-          # Take care of Ruby 1.8.7
-          if fields_that_need_associated_values.is_a?(Array)
-            fields_that_need_associated_values = fields_that_need_associated_values.inject({}){|r,(k,v)| r.merge(k => v)}
-          end
-
-          fields_that_need_associated_values.each_pair.inject({}) do |r,(k,v)|
-            r.merge(k => record.value_for_attribute(fields_that_need_associated_values[k], true))
-          end
-        end
-
-      # include ::Netzke::Plugins::ConfigurationTool if config_tool_available # it will load ConfigurationPanel into a modal window
-    end
-  end
-end

data/lib/netzke/basepack/form_panel/fields.rb

@@ -1,208 +0,0 @@
-module Netzke
-  module Basepack
-    class FormPanel < Netzke::Base
-      # Because FormPanel allows for arbitrary layout of fields, we need to have all fields configured in one place (the +fields+ method), and then have references to those fields from +items+.
-      module Fields
-        extend ActiveSupport::Concern
-
-        # Items with normalized fields (i.e. containing all the necessary attributes needed by Ext.form.FormPanel to render a field)
-        def items
-          @form_panel_items ||= begin
-            res = normalize_fields(super || data_class && data_class.netzke_attributes || []) # netzke_attributes as default items
-            # if primary key isn't there, insert it as first
-            if data_class && !res.detect{ |f| f[:name] == data_class.primary_key.to_s}
-              primary_key_item = normalize_field(data_class.primary_key.to_sym)
-              @fields_from_config[data_class.primary_key.to_sym] = primary_key_item
-              res.insert(0, primary_key_item)
-            end
-            res
-          end
-        end
-
-        # Hash of fully configured fields, that are referenced in the items. E.g.:
-        #   {
-        #     :role__name => {:xtype => 'netzkeremotecombo', :disabled => true, :value => "admin"},
-        #     :created_at => {:xtype => 'datetime', :disabled => true, :value => "2010-10-10 10:10"}
-        #   }
-        def fields
-          @fields ||= begin
-            if static_layout?
-              # extract incomplete field configs from +config+
-              flds = fields_from_config
-              # and merged them with fields from the model
-              deep_merge_existing_fields(flds, fields_from_model) if data_class
-            else
-              # extract flds configs from the model
-              flds = fields_from_model
-            end
-            flds
-          end
-        end
-
-        # The array of fields as specified on the model level (using +netzke_attribute+ and alike)
-        def fields_array_from_model
-          data_class && data_class.netzke_attributes
-        end
-
-        # Hash of fields as specified on the model level
-        def fields_from_model
-          @fields_from_model ||= fields_array_from_model && fields_array_from_model.inject({}){ |hsh, f| hsh.merge(f[:name].to_sym => f) }
-        end
-
-        # Hash of normalized field configs extracted from :items, e.g.:
-        #
-        #     {:role__name => {:xtype => "netzkeremotecombo"}, :password => {:xtype => "passwordfield"}}
-        def fields_from_config
-          items if @fields_from_config.nil? # by calling +items+ we initiate building of @fields_from_config
-          @fields_from_config ||= {}
-        end
-
-        module ClassMethods
-          # Columns to be displayed by the FieldConfigurator, "meta-columns". Each corresponds to a configuration
-          # option for each field in the form.
-          def meta_columns
-            [
-              {:name => "included", :attr_type => :boolean, :width => 40, :header => "Incl", :default_value => true},
-              {:name => "name", :attr_type => :string, :editor => :netzkeremotecombo, :width => 200},
-              {:name => "label", :attr_type => :string, :header => "Label"},
-              {:name => "default_value", :attr_type => :string}
-            ]
-          end
-        end
-
-        private
-          def load_persistent_fields
-            # NetzkeFieldList.read_list(global_id) if persistent_config_enabled?
-          end
-
-          def load_model_level_attrs
-            # NetzkeModelAttrList.read_list(data_class.name) if persistent_config_enabled? && data_class
-          end
-
-          # This is where we expand our basic field config with all the defaults
-          def normalize_field(field)
-            # field can only be a string, a symbol, or a hash
-            if field.is_a?(Hash)
-              field = field.dup # we don't want to modify original hash
-              return field if field[:no_binding] # stop here if no normalization is needed
-              field[:name] = field[:name].to_s if field[:name] # all names should be strings
-            else
-              field = {:name => field.to_s}
-            end
-
-            field_from_model = fields_from_model && fields_from_model[field[:name].to_sym]
-
-            field_from_model && field.merge!(field_from_model)
-
-            detect_association_with_method(field) # xtype for an association field
-            set_default_field_label(field)
-            set_default_field_xtype(field) if field[:xtype].nil?
-            set_default_read_only(field)
-
-            # temporal datetime setup, while we don't have real datetime field
-            if field[:attr_type] == :date
-              field[:format] ||= "Y-m-d"
-            end
-
-            # provide our special combobox with our id
-            field[:parent_id] = self.global_id if field[:xtype] == :netzkeremotecombo
-
-            field[:hidden] = field[:hide_label] = true if field[:hidden].nil? && primary_key_attr?(field)
-
-            # checkbox setup
-            field[:checked] = field[:value] if field[:attr_type] == :boolean
-            field[:input_value] = true if field[:attr_type] == :boolean
-
-            field
-          end
-
-          # Sets the proper xtype of an asociation field
-          def detect_association_with_method(c)
-            if c[:name].index('__')
-              assoc_name, method = c[:name].split('__').map(&:to_sym)
-              assoc_method_type = data_adapter.get_assoc_property_type(assoc_name, method)
-              if c[:nested_attribute]
-                c[:xtype] ||= xtype_for_attr_type(assoc_method_type)
-              else
-                c[:xtype] ||= assoc_method_type == :boolean ? xtype_for_attr_type(assoc_method_type) : xtype_for_association
-              end
-            end
-          end
-
-          # RECURSIVELY extracts fields configuration from :items
-          def normalize_fields(items)
-            @fields_from_config ||= {}
-            items.map do |item|
-              # at this moment, item is a hash or a symbol
-              if is_field_config?(item)
-                item = normalize_field(item)
-                @fields_from_config[item[:name].to_sym] = item
-                item #.reject{ |k,v| k == :name } # do we really need to remove the :name key?
-              elsif item.is_a?(Hash)
-                item = item.dup # we don't want to modify original hash
-                item[:items].is_a?(Array) ? item.merge(:items => normalize_fields(item[:items])) : item
-              else
-                item
-              end
-            end
-          end
-
-          def is_field_config?(item)
-            item.is_a?(String) || item.is_a?(Symbol) || item[:name] # && !is_component_config?(item)
-          end
-
-          # Deeply merges only those key/values at the top level that are already there
-          def deep_merge_existing_fields(dest, src)
-            dest.each_pair do |k,v|
-              v.deep_merge!(src[k] || {})
-            end
-          end
-
-          def set_default_field_label(c)
-            # multiple spaces (in case of association attrs) get replaced with one
-            c[:field_label] ||= data_class ? data_class.human_attribute_name(c[:name]) : c[:name].humanize
-            c[:field_label].gsub!(/\s+/, " ")
-          end
-
-          def set_default_field_xtype(field)
-            field[:xtype] = xtype_for_attr_type(field[:attr_type]) unless xtype_for_attr_type(field[:attr_type]).nil?
-          end
-
-          def set_default_read_only(field)
-            enabled_if = !data_class || data_class.column_names.include?(field[:name])
-            enabled_if ||= data_class.instance_methods.map(&:to_s).include?("#{field[:name]}=")
-            enabled_if ||= record && record.respond_to?("#{field[:name]}=")
-            enabled_if ||= association_attr?(field[:name])
-
-            field[:read_only] = !enabled_if if field[:read_only].nil?
-          end
-
-          def attr_type_to_xtype_map
-            {
-              :integer => :numberfield,
-              :boolean => config[:multi_edit] ? :tricheckbox : :checkboxfield,
-              :date => :datefield,
-              :datetime => :xdatetime,
-              :text => :textarea,
-              :json => :jsonfield,
-              :string => :textfield
-            }
-          end
-
-          def xtype_for_attr_type(type)
-            attr_type_to_xtype_map[type] || :textfield
-          end
-
-          def xtype_for_association
-            :netzkeremotecombo
-          end
-
-          # Are we provided with a static field layout?
-          def static_layout?
-            !!config[:items]
-          end
-
-      end
-    end
-  end
-end