scaffolding_extensions 1.0.0 → 1.1.0

data/README

@@ -28,6 +28,7 @@ Scaffolding Extensions currently supports:
 * Object/Relational Mappers
   * ActiveRecord 2.0
   * DataMapper 0.2.5
+  * Sequel 0.5.0
 * Javascript Libaries (used for Ajax/Autocompleting)
   * Prototype 1.6.0.1
   * JQuery 1.2.3

data/doc/sequel.txt

@@ -0,0 +1,4 @@
+Sequel is fully supported by Scaffolding Extensions, but because Sequel provides
+limited reflection abilities for database columns, you should define
+@scaffold_column_types for each model and have entries in it for all columns
+that are not strings.

data/lib/scaffolding_extensions.rb

@@ -85,5 +85,6 @@ require 'scaffolding_extensions/controller/sinatra' if defined? Sinatra
 
 require 'scaffolding_extensions/model/active_record' if defined? ActiveRecord::Base
 require 'scaffolding_extensions/model/data_mapper' if defined? DataMapper::Base
+require 'scaffolding_extensions/model/sequel' if defined? Sequel::Model
 
 ScaffoldingExtensions.javascript_library = 'Prototype'

data/lib/scaffolding_extensions/helper.rb

@@ -29,9 +29,11 @@ module ScaffoldingExtensions
             when :edit
               content << scaffold_check_link('(associate)', true, "edit_#{singular_name}_#{association}", :id=>soid) unless read_only
             when :new
-              associated_params = {}
-              klass.scaffold_new_associated_object_values(association, so).each{|key, value| associated_params["#{class_name}[#{key}]"] = value}
-              content << scaffold_check_link('(create)', true, "new_#{class_name}", associated_params) unless read_only
+              unless read_only
+                associated_params = {}
+                klass.scaffold_new_associated_object_values(association, so).each{|key, value| associated_params["#{class_name}[#{key}]"] = value}
+                content << scaffold_check_link('(create)', true, "new_#{class_name}", associated_params)
+              end
           end
           if (records = klass.scaffold_associated_objects(association, so, :session=>scaffold_session)).length > 0
             content << "<ul>\n"

data/lib/scaffolding_extensions/meta_model.rb

@@ -242,8 +242,8 @@ module ScaffoldingExtensions::MetaModel
   # up via columns_hash[column_name].type.  If no type is provided, :string is used by default.
   def scaffold_column_type(column_name)
     @scaffold_column_types ||= SCAFFOLD_OPTIONS[:column_types].dup
-    if @scaffold_column_types[column_name]
-      @scaffold_column_types[column_name]
+    if type = @scaffold_column_types[column_name]
+      type
     elsif scaffold_association(column_name)
       :association
     elsif type = scaffold_table_column_type(column_name)
@@ -314,7 +314,8 @@ module ScaffoldingExtensions::MetaModel
 
   # Creates a new object, setting the attributes if given.
   def scaffold_new_object(attributes, options)
-    object = new(scaffold_filter_attributes(:new, attributes || {}))
+    object = new
+    scaffold_set_attributes(object, scaffold_filter_attributes(:new, attributes || {}))
     object.send("#{scaffold_session_value}=", options[:session][scaffold_session_value]) if scaffold_session_value
     object
   end
@@ -526,7 +527,7 @@ module ScaffoldingExtensions::MetaModel
     
     # Condition to ensure field equals value
     def scaffold_equal_condition(field, value)
-      ["#{scaffold_table_name}.#{field} = ?", "%#{value}%"]
+      ["#{scaffold_table_name}.#{field} = ?", value]
     end
 
     # Filters the provided attributes to just the ones given by scaffold_attributes for
@@ -558,6 +559,14 @@ module ScaffoldingExtensions::MetaModel
       scaffold_associated_class(association).scaffold_select_order(:association)
     end
     
+    # Set the object's attributes with the given attributes
+    def scaffold_set_attributes(object, attributes)
+      attributes.each do |k,v|
+        v = nil if v.empty? && scaffold_table_column_type(k) == :boolean
+        object.send("#{k}=", v)
+      end 
+    end 
+
     # Condition to ensure value is a substring of field
     def scaffold_substring_condition(field, value)
       ["#{scaffold_table_name}.#{field} #{scaffold_auto_complete_search_operator} ?", "%#{value}%"]

data/lib/scaffolding_extensions/model/ardm.rb

@@ -39,9 +39,4 @@ module ScaffoldingExtensions::MetaARDM
     def scaffold_remove_associated_object(association, object, associated_object)
       object.send(association).delete(associated_object)
     end
-    
-    # Set the object's attributes with the given attributes
-    def scaffold_set_attributes(object, attributes)
-      object.attributes = attributes
-    end
 end

data/lib/scaffolding_extensions/model/sequel.rb

@@ -0,0 +1,224 @@
+ScaffoldingExtensions::MODEL_SUPERCLASSES << Sequel::Model
+
+# Instance methods added to Sequel::Model to allow it to work with Scaffolding Extensions.
+module ScaffoldingExtensions::Sequel
+  # Get value for given attribute
+  def scaffold_attribute_value(field)
+    values[field]
+  end
+
+  # the value of the primary key for this object
+  def scaffold_id
+    pk 
+  end
+end
+
+# Class methods added to Sequel::Model to allow it to work with Scaffolding Extensions.
+module ScaffoldingExtensions::MetaSequel
+  SCAFFOLD_OPTIONS = ::ScaffoldingExtensions::MetaModel::SCAFFOLD_OPTIONS
+  
+  # Add the associated object to the object's association
+  def scaffold_add_associated_object(association, object, associated_object)
+    object.send(association_add_method_name(association.to_s), associated_object)
+  end
+
+  # Array of all association reflections for this model
+  def scaffold_all_associations
+    all_association_reflections
+  end
+  
+  # The class that this model is associated with via the association
+  def scaffold_associated_class(association)
+    associated_class(association_reflection(association))
+  end
+  
+  # All objects that are currently associated with the given object. This method does not
+  # check that the returned associated objects meet the associated class's scaffold_session_value
+  # constraint, as it is assumed that all objects currently assocated with the given object
+  # have already met the criteria.  If that is not the case, you should override this method.
+  def scaffold_associated_objects(association, object, options)
+    assoc = object.send(association)
+    reflection = association_reflection(association)
+    reflection[:cache] || reflection[:type] == :many_to_one ? assoc : assoc.all
+  end
+  
+  # The association reflection for this association
+  def scaffold_association(association)
+    association_reflection(association)
+  end
+
+  # The type of association, either :new for :one_to_many (as you can create new objects
+  # associated with the current object), :edit for :many_to_many (since you
+  # can edit the list of associated objects), or :one for :many_to_one.
+  def scaffold_association_type(association)
+    case scaffold_association(association)[:type]
+      when :one_to_many
+        :new
+      when :many_to_many
+        :edit
+      else
+        :one
+    end
+  end
+  
+  # List of symbols for associations to display on the scaffolded edit page. Defaults to
+  # all associations. Can be set with an instance variable.
+  def scaffold_associations
+    associations.sort_by{|name| name.to_s}
+  end
+
+  # Destroys the object
+  def scaffold_destroy(object)
+    object.destroy
+  end
+
+  # The error to raise, should match other errors raised by the underlying library.
+  def scaffold_error_raised
+    Sequel::Error
+  end
+
+  # Returns the list of fields to display on the scaffolded forms. Defaults
+  # to displaying all columns with the exception of the primary key column.
+  # Also includes :many_to_one associations, replacing
+  # the foriegn keys with the association itself.  Can be set with an instance variable.
+  def scaffold_fields(action = :default)
+    return @scaffold_fields if @scaffold_fields
+    fields = columns - [primary_key]
+    all_association_reflections.each do |reflection|
+      next unless reflection[:type] == :many_to_one
+      fields.delete(reflection[:key].to_sym)
+      fields.push(reflection[:name])
+    end
+    @scaffold_fields = fields.sort_by{|f| f.to_s}
+  end
+  
+  # The foreign key for the given reflection
+  def scaffold_foreign_key(reflection)
+    reflection[:key]
+  end
+  
+  # Retrieve a single model object given an id
+  def scaffold_get_object(id)
+    self[id.to_i] || (raise scaffold_error_raised)
+  end
+
+  # Retrieve multiple objects given a hash of options
+  def scaffold_get_objects(options)
+    records = dataset
+    conditions = options[:conditions]
+    if conditions && Array === conditions && conditions.length > 0
+      if String === conditions[0]
+        records = records.filter(*conditions)
+      else
+        conditions.each do |cond|
+          next if cond.nil?
+          records = case cond
+            when Hash, String then records.filter(cond)
+            when Array then records.filter(*cond)
+            when Proc then records.filter(&cond)
+          end
+        end
+      end
+    end
+    order = options[:order]
+    order = [order] unless Array === order
+    order.each do |o|
+      next if o.nil?
+      records = case o
+        when Proc then records.order(&o)
+        else records.order(o)
+      end
+    end
+    records = records.limit(options[:limit], options[:offset]) if options[:limit]
+    records.all
+  end
+
+  # Return the class, left foreign key, right foreign key, and join table for this habtm association
+  def scaffold_habtm_reflection_options(association)
+    reflection = scaffold_association(association)
+    [reflection[:class], reflection[:left_key], reflection[:right_key], reflection[:join_table]]
+  end
+
+  # Sequel doesn't do eager loading yet, so this is always nil 
+  def scaffold_include(action = :default)
+    nil
+  end
+
+  # Returns a hash of values to be used as url parameters on the link to create a new
+  # :has_many associated object.  Defaults to setting the foreign key field to the
+  # record's primary key.
+  def scaffold_new_associated_object_values(association, record)
+    {scaffold_foreign_key(association_reflection(association))=>record.pk}
+  end
+
+  # The primary key for the given table
+  def scaffold_primary_key
+    primary_key
+  end
+  
+  # Saves the object.
+  def scaffold_save(action, object)
+    object.save
+  end
+  
+  # Sequel doesn't keep enough reflection information, so assume string unless
+  # specified by @scaffold_column_types.
+  def scaffold_table_column_type(column)
+    # column is provided by the user, so we can't just .to_sym it
+    @scaffold_column_types_strings ||= Hash.new do |h,k1| 
+      @scaffold_column_types.each{|k2,v| h[k2] = v; h[k2.to_s] = v}
+      h[k1] if h.include?(k1)
+    end
+    @scaffold_column_types_strings[column] || :string
+  end
+
+  # The name of the underlying table
+  def scaffold_table_name
+    table_name
+  end
+
+  # Sequel doesn't allow you to use transaction on a model (only on a database),
+  # so add a transaction method that starts a transaction on the associated database.
+  def transaction(&block)
+    db.transaction(&block)
+  end
+
+  private
+    # Sequel doesn't do eager loading yet
+    def scaffold_include_association(association)
+      nil
+    end
+    
+    # Updates associated records for a given reflection and from record to point to the
+    # to record
+    def scaffold_reflection_merge(reflection, from, to)
+      case reflection[:type]
+        when :one_to_many
+          foreign_key = reflection[:key]
+          db << "UPDATE #{reflection[:class].table_name} SET #{foreign_key} = #{to} WHERE #{foreign_key} = #{from}"
+        when :many_to_many
+          foreign_key = reflection[:left_key]
+          db << "UPDATE #{reflection[:join_table]} SET #{foreign_key} = #{to} WHERE #{foreign_key} = #{from}" 
+      end
+    end
+    
+    # Remove the associated object from object's association
+    def scaffold_remove_associated_object(association, object, associated_object)
+      object.send(association_remove_method_name(association.to_s), associated_object)
+    end
+end
+
+# Add the class methods and instance methods from Scaffolding Extensions
+class Sequel::Model
+  SCAFFOLD_OPTIONS = ::ScaffoldingExtensions::MetaModel::SCAFFOLD_OPTIONS
+  include ScaffoldingExtensions::Model
+  include ScaffoldingExtensions::Sequel
+  extend ScaffoldingExtensions::MetaModel
+  extend ScaffoldingExtensions::MetaSequel
+  extend ScaffoldingExtensions::Overridable
+  class << self
+    extend ScaffoldingExtensions::MetaOverridable
+    scaffold_override_methods(:add_associated_objects, :associated_objects, :association_find_object, :association_find_objects, :find_object, :find_objects, :new_associated_object_values, :remove_associated_objects, :save, :unassociated_objects, :filter_attributes)
+    scaffold_override_iv_methods(:associated_human_name, :association_use_auto_complete, :fields, :select_order, :attributes, :select_order_association)
+  end
+end

metadata

@@ -3,9 +3,9 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: scaffolding_extensions
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2008-03-05 00:00:00 -08:00
-summary: Administrative database front-end for web-frameworks and ORMs
+  version: 1.1.0
+date: 2008-03-15 00:00:00 -07:00
+summary: Administrative database front-end for multiple web-frameworks and ORMs
 require_paths: 
 - lib
 email: code@jeremyevans.net
@@ -46,6 +46,7 @@ files:
 - lib/scaffolding_extensions/model/active_record.rb
 - lib/scaffolding_extensions/model/data_mapper.rb
 - lib/scaffolding_extensions/model/ardm.rb
+- lib/scaffolding_extensions/model/sequel.rb
 - lib/scaffolding_extensions/controller/ramaze.rb
 - lib/scaffolding_extensions/controller/action_controller.rb
 - lib/scaffolding_extensions/controller/camping.rb
@@ -58,6 +59,7 @@ files:
 - doc/ramaze.txt
 - doc/camping.txt
 - doc/sinatra.txt
+- doc/sequel.txt
 - contrib/scaffold_associations_tree
 - contrib/scaffold_jquery_autocomplete
 - contrib/scaffold_auto_complete_style