autoforme 0.5.0

data/lib/autoforme/models/sequel.rb

@@ -0,0 +1,344 @@
+module AutoForme
+  module Models
+    # Sequel specific model class for AutoForme
+    class Sequel < Model
+      # Short reference to top level Sequel module, for easily calling methods
+      S = ::Sequel
+
+      # What association types to recognize.  Other association types are ignored.
+      SUPPORTED_ASSOCIATION_TYPES = [:many_to_one, :one_to_one, :one_to_many, :many_to_many]
+
+      # Make sure the forme plugin is loaded into the model.
+      def initialize(*)
+        super
+        @model.plugin :forme
+      end
+
+      # The base class for the underlying model, ::Sequel::Model.
+      def base_class
+        S::Model
+      end
+
+      # A completely empty search object, with no defaults.
+      def new_search
+        @model.call({})
+      end
+
+      # The name of the form param for the given association.
+      def form_param_name(assoc)
+        "#{model.send(:underscore, model.name)}[#{association_key(assoc)}]"
+      end
+
+      # Set the fields for the given action type to the object based on the request params.
+      def set_fields(obj, type, request, params)
+        columns_for(type, request).each do |col|
+          column = col
+
+          if association?(col)
+            ref = model.association_reflection(col)
+            ds = ref.associated_dataset
+            if model_class = associated_model_class(col)
+              ds = model_class.apply_filter(:association, request, ds)
+            end
+
+            if v = params[ref[:key]]
+              v = ds.first!(S.qualify(ds.model.table_name, ref.primary_key)=>v)
+            end
+          else
+            v = params[col]
+          end
+
+          obj.send("#{column}=", v)
+        end
+      end
+
+      # Whether the column represents an association.
+      def association?(column)
+        case column
+        when String
+          model.associations.map{|x| x.to_s}.include?(column)
+        else
+          model.association_reflection(column)
+        end
+      end
+
+      # The associated class for the given association
+      def associated_class(assoc)
+        model.association_reflection(assoc).associated_class
+      end
+
+      # A short type for the association, either :one for a
+      # singular association, :new for an association where
+      # you can create new objects, or :edit for association
+      # where you can add/remove members from the association.
+      def association_type(assoc)
+        case model.association_reflection(assoc)[:type]
+        when :many_to_one, :one_to_one
+          :one
+        when :one_to_many
+          :new
+        when :many_to_many
+          :edit
+        end
+      end
+
+      # The foreign key column for the given many to one association.
+      def association_key(assoc)
+        model.association_reflection(assoc)[:key]
+      end
+
+      # An array of pairs mapping foreign keys in associated class
+      # to primary key value of current object
+      def associated_new_column_values(obj, assoc)
+        ref = model.association_reflection(assoc)
+        ref[:keys].zip(ref[:primary_keys].map{|k| obj.send(k)})
+      end
+
+      # Array of many to many association name strings.
+      def mtm_association_names
+        association_names([:many_to_many])
+      end
+
+      # Array of association name strings for given association types
+      def association_names(types=SUPPORTED_ASSOCIATION_TYPES)
+        model.all_association_reflections.select{|r| types.include?(r[:type])}.map{|r| r[:name]}.sort_by{|n| n.to_s}
+      end
+
+      # Save the object, returning the object if successful, or nil if not.
+      def save(obj)
+        obj.raise_on_save_failure = false
+        obj.save
+      end
+
+      # The primary key value for the given object.
+      def primary_key_value(obj)
+        obj.pk
+      end
+
+      # The namespace for form parameter names for this model, needs to match
+      # the ones automatically used by Forme.
+      def params_name
+        @model.send(:underscore, @model.name)
+      end
+
+      # Retrieve underlying model instance with matching primary key
+      def with_pk(type, request, pk)
+        dataset_for(type, request).with_pk!(pk)
+      end
+
+      # Retrieve all matching rows for this model.
+      def all_rows_for(type, request)
+        all_dataset_for(type, request).all
+      end
+
+      # Return the default columns for this model
+      def default_columns
+        columns = model.columns - Array(model.primary_key)
+        model.all_association_reflections.each do |reflection|
+          next unless reflection[:type] == :many_to_one
+          if i = columns.index(reflection[:key])
+            columns[i] = reflection[:name]
+          end
+        end
+        columns.sort_by{|s| s.to_s}
+      end
+
+      # Add a filter restricting access to only rows where the column name
+      # matching the session value.  Also add a before_create hook that sets
+      # the column value to the session value.
+      def session_value(column)
+        filter do |ds, type, req|
+          ds.where(S.qualify(model.table_name, column)=>req.session[column])
+        end
+        before_create do |obj, req|
+          obj.send("#{column}=", req.session[column])
+        end
+      end
+
+      # Returning array of matching objects for the current search page using the given parameters.
+      def search_results(type, request)
+        params = request.params
+        ds = apply_associated_eager(:search, request, all_dataset_for(type, request))
+        columns_for(:search_form, request).each do |c|
+          if (v = params[c]) && !v.empty?
+            if association?(c)
+              ref = model.association_reflection(c)
+              ads = ref.associated_dataset
+              if model_class = associated_model_class(c)
+                ads = model_class.apply_filter(:association, request, ads)
+              end
+              primary_key = S.qualify(ref.associated_class.table_name, ref.primary_key)
+              ds = ds.where(ref[:key]=>ads.where(primary_key=>v).select(primary_key))
+            elsif column_type(c) == :string
+              ds = ds.where(S.ilike(c, "%#{ds.escape_like(v.to_s)}%"))
+            else
+              ds = ds.where(c=>v.to_s)
+            end
+          end
+        end
+        paginate(type, request, ds)
+      end
+
+      # Return array of matching objects for the current page.
+      def browse(type, request)
+        paginate(type, request, apply_associated_eager(:browse, request, all_dataset_for(type, request)))
+      end
+
+      # Do very simple pagination, by selecting one more object than necessary,
+      # and noting if there is a next page by seeing if more objects are returned than the limit.
+      def paginate(type, request, ds)
+        limit = limit_for(type, request)
+        offset = ((request.id.to_i||1)-1) * limit
+        objs = ds.limit(limit+1, (offset if offset > 0)).all
+        next_page = false
+        if objs.length > limit
+          next_page = true
+          objs.pop
+        end
+        [next_page, objs]
+      end
+
+      # On the browse/search results pages, in addition to eager loading based on the current model's eager
+      # loading config, also eager load based on the associated models config.
+      def apply_associated_eager(type, request, ds)
+        columns_for(type, request).each do |col|
+          if association?(col)
+            if model = associated_model_class(col)
+              eager = model.eager_for(:association, request) || model.eager_graph_for(:association, request)
+              ds = ds.eager(col=>eager)
+            else
+              ds = ds.eager(col)
+            end
+          end
+        end
+        ds
+      end
+
+      # The schema type for the column
+      def column_type(column)
+        (sch = model.db_schema[column]) && sch[:type]
+      end
+
+      # Apply the model's filter to the given dataset
+      def apply_filter(type, request, ds)
+        if filter = filter_for
+          ds = filter.call(ds, type, request)
+        end
+        ds
+      end
+
+      # Apply the model's filter, eager, and order to the given dataset
+      def apply_dataset_options(type, request, ds)
+        ds = apply_filter(type, request, ds)
+        if order = order_for(type, request)
+          ds = ds.order(*order)
+        end
+        if eager = eager_for(type, request)
+          ds = ds.eager(eager)
+        end
+        if eager_graph = eager_graph_for(type, request)
+          ds = ds.eager_graph(eager_graph)
+        end
+        ds
+      end
+
+      # Whether to autocomplete for the given association.
+      def association_autocomplete?(assoc, request)
+        (c = associated_model_class(assoc)) && c.autocomplete_options_for(:association, request)
+      end
+
+      # Return array of autocompletion strings for the request.  Options:
+      # :type :: Action type symbol
+      # :request :: AutoForme::Request instance
+      # :association :: Association symbol 
+      # :query :: Query string submitted by the user
+      # :exclude :: Primary key value of current model, excluding already associated values (used when
+      #             editing many to many associations)
+      def autocomplete(opts={})
+        type, request, assoc, query, exclude = opts.values_at(:type, :request, :association, :query, :exclude)
+        if assoc
+          if exclude && association_type(assoc) == :edit
+            ref = model.association_reflection(assoc)
+            block = lambda do |ds|
+              ds.exclude(S.qualify(ref.associated_class.table_name, ref.right_primary_key)=>model.db.from(ref[:join_table]).where(ref[:left_key]=>exclude).select(ref[:right_key]))
+            end
+          end
+          return associated_model_class(assoc).autocomplete(opts.merge(:type=>:association, :association=>nil), &block)
+        end
+        opts = autocomplete_options_for(type, request)
+        callback_opts = {:type=>type, :request=>request, :query=>query}
+        ds = all_dataset_for(type, request)
+        ds = opts[:callback].call(ds, callback_opts) if opts[:callback]
+        display = opts[:display] || S.qualify(model.table_name, :name)
+        display = display.call(callback_opts) if display.respond_to?(:call)
+        limit = opts[:limit] || 10
+        limit = limit.call(callback_opts) if limit.respond_to?(:call)
+        opts[:filter] ||= lambda{|ds, opts| ds.where(S.ilike(display, "%#{ds.escape_like(query)}%"))}
+        ds = opts[:filter].call(ds, callback_opts)
+        ds = ds.select(S.join([S.qualify(model.table_name, model.primary_key), display], ' - ').as(:v)).
+          limit(limit)
+        ds = yield ds if block_given?
+        ds.map(:v)
+      end
+
+      # Update the many to many association.  add and remove should be arrays of primary key values
+      # of associated objects to add to the association.
+      def mtm_update(request, assoc, obj, add, remove)
+        ref = model.association_reflection(assoc)
+        assoc_class = associated_model_class(assoc)
+        ret = nil
+        model.db.transaction do
+          [[add, ref.add_method], [remove, ref.remove_method]].each do |ids, meth|
+            if ids
+              ids.each do |id|
+                next if id.to_s.empty?
+                ret = assoc_class ? assoc_class.with_pk(:association, request, id) : ref.associated_dataset.with_pk!(id)
+                obj.send(meth, ret)
+              end
+            end
+          end
+        end
+        ret
+      end
+
+      # The currently associated many to many objects for the association
+      def associated_mtm_objects(request, assoc, obj)
+        ds = obj.send("#{assoc}_dataset")
+        if assoc_class = associated_model_class(assoc)
+          ds = assoc_class.apply_dataset_options(:association, request, ds)
+        end
+        ds
+      end
+
+      # All objects in the associated table that are not currently associated to the given object.
+      def unassociated_mtm_objects(request, assoc, obj)
+        ref = model.association_reflection(assoc)
+        assoc_class = associated_model_class(assoc)
+        lambda do |ds|
+          subquery = model.db.from(ref[:join_table]).
+            select(ref.qualified_right_key).
+            where(ref.qualified_left_key=>obj.pk)
+          ds = ds.exclude(S.qualify(ref.associated_class.table_name, model.primary_key)=>subquery)
+          ds = assoc_class.apply_dataset_options(:association, request, ds) if assoc_class
+          ds
+        end
+      end
+
+      private
+
+      def dataset_for(type, request)
+        ds = @model.dataset
+        if filter = filter_for
+          ds = filter.call(ds, type, request)
+        end
+        ds
+      end
+
+      def all_dataset_for(type, request)
+        apply_dataset_options(type, request, @model.dataset)
+      end
+    end
+  end
+
+  register_model(:sequel, Models::Sequel)
+end

data/lib/autoforme/opts_attributes.rb

@@ -0,0 +1,29 @@
+module AutoForme
+  module OptsAttributes
+    # Setup methods for each given argument such that if the method is called with an argument or
+    # block, it sets the value of the related option to that argument or block.  If called without
+    # an argument or block, it returns the stored option value.
+    def opts_attribute(*meths)
+      meths.each do |meth|
+        define_method(meth) do |*args, &block|
+          if block
+            if args.empty?
+              opts[meth] = block
+            else
+              raise ArgumentError, "No arguments allowed if passing a block"
+            end
+          end
+
+          case args.length
+          when 0
+            opts[meth]
+          when 1
+            opts[meth] = args.first
+          else
+            raise ArgumentError, "Only 0-1 arguments allowed"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/autoforme/request.rb

@@ -0,0 +1,53 @@
+module AutoForme
+  # Request wraps a specific web request for a given framework.
+  class Request
+    # The underlying web framework request instance for the request
+    attr_reader :controller
+
+    # The request method (GET or POST) for the request
+    attr_reader :method
+
+    # A string representing the model for the request
+    attr_reader :model
+
+    # A string representing the action type for the request
+    attr_reader :action_type
+
+    # A string representing the path that the root of
+    # the application is mounted at
+    attr_reader :path
+
+    # The id related to the request, which is usually the primary
+    # key of the related model instance, but for browse/search
+    # pages is used as the page
+    attr_reader :id
+
+    # The params for the current request
+    attr_reader :params
+
+    # The session variables for the current request
+    attr_reader :session
+
+    # Whether the current request used the POST HTTP method.
+    def post?
+      method == 'POST'
+    end 
+
+    # The query string for the current request
+    def query_string
+      @env['QUERY_STRING']
+    end
+
+    # Set the flash at notice level when redirecting, so it shows
+    # up on the redirected page.
+    def set_flash_notice(message)
+      @controller.flash[:notice] = message
+    end
+
+    # Set the current flash at error level, used when displaying
+    # pages when there is an error.
+    def set_flash_now_error(message)
+      @controller.flash.now[:error] = message
+    end
+  end
+end

data/lib/autoforme/table.rb

@@ -0,0 +1,70 @@
+module AutoForme
+  # Helper class for formating HTML tables used for the browse/search results pages.
+  class Table
+    # The AutoForme::Action for the current table
+    attr_reader :action
+
+    # The AutoForme::Model for the current table
+    attr_reader :model
+
+    # The AutoForme::Request for the current table
+    attr_reader :request
+
+    # The action type for the current table
+    attr_reader :type
+
+    # The data columns for the current table
+    attr_reader :columns
+
+    # An array of objects to show in the table
+    attr_reader :objs
+
+    # Any options for the table
+    attr_reader :opts
+
+    def initialize(action, objs, opts={})
+      @action = action
+      @request = action.request
+      @model = action.model
+      @type = action.normalized_type
+      @columns = model.columns_for(type, request)
+      @objs = objs
+      @opts = opts
+    end
+    
+    def h(s)
+      action.h(s)
+    end
+
+    # Return an HTML string for the table.
+    def to_s
+      html = "<table class=\"#{model.table_class_for(type, request)}\">"
+      if caption = opts[:caption]
+        html << "<caption>#{h caption}</caption>"
+      end
+
+      html << "<thead><tr>"
+      columns.each do |column|
+        html << "<th>#{h action.column_label_for(type, request, model, column)}</th>"
+      end
+      html << "<th>Show</th>" if show = model.supported_action?(:show, request)
+      html << "<th>Edit</th>" if edit = model.supported_action?(:edit, request)
+      html << "<th>Delete</th>" if delete = model.supported_action?(:delete, request)
+      html << "</tr></thead>"
+
+      html << "<tbody>"
+      objs.each do |obj|
+        html << "<tr>"
+        columns.each do |column|
+          html << "<td>#{h model.column_value(type, request, obj, column)}</td>"
+        end
+        html << "<td><a href=\"#{action.url_for("show/#{model.primary_key_value(obj)}")}\" class=\"btn btn-mini btn-info\">Show</a></td>" if show
+        html << "<td><a href=\"#{action.url_for("edit/#{model.primary_key_value(obj)}")}\" class=\"btn btn-mini btn-primary\">Edit</a></td>" if edit
+        html << "<td><a href=\"#{action.url_for("delete/#{model.primary_key_value(obj)}")}\" class=\"btn btn-mini btn-danger\">Delete</a></td>" if delete
+        html << "</tr>"
+      end
+      html << "</tbody></table>"
+      html
+    end
+  end
+end

data/lib/autoforme/version.rb

@@ -0,0 +1,9 @@
+module AutoForme
+  # Version constant, use <tt>AutoForme.version</tt> instead.
+  VERSION = '0.5.0'.freeze
+
+  # Returns the version as a frozen string (e.g. '0.1.0')
+  def self.version
+    VERSION
+  end
+end

data/lib/autoforme.rb

@@ -0,0 +1,57 @@
+require 'forme'
+require 'thread'
+require 'rack/utils'
+
+module AutoForme
+  # Map of framework type symbols to framework classes
+  FRAMEWORKS = {}
+
+  # Map of model type symbols to model classes 
+  MODELS = {}
+  @mutex = Mutex.new
+
+  # AutoForme specific error class
+  class Error < StandardError
+  end
+
+  [[:framework, FRAMEWORKS], [:model, MODELS]].each do |map_type, map|
+    singleton_class = class << self; self; end
+
+    singleton_class.send(:define_method, :"register_#{map_type}") do |type, klass|
+      @mutex.synchronize{map[type] = klass}
+    end
+
+    singleton_class.send(:define_method, :"#{map_type}_class_for") do |type|
+      unless klass = @mutex.synchronize{map[type]}
+        require "autoforme/#{map_type}s/#{type}"
+        unless klass = @mutex.synchronize{map[type]}
+          raise Error, "unsupported framework: #{type.inspect}"
+        end
+      end
+      klass
+    end
+  end
+
+  # Create a new set of model forms.  Arguments:
+  # type :: A type symbol for the type of framework in use (:sinatra or :rails)
+  # controller :: The controller class in which to load the forms
+  # opts :: Options hash.  Current supports a :prefix option if you want to mount
+  #         the forms in a different prefix.
+  #
+  # Example:
+  #
+  #   AutoForme.for(:sinatra, Sinatra::Application, :prefix=>'/path') do
+  #     model Artist
+  #   end
+  def self.for(type, controller, opts={}, &block)
+    Framework.for(type, controller, opts, &block)
+  end
+end
+
+require 'autoforme/opts_attributes'
+require 'autoforme/model'
+require 'autoforme/framework'
+require 'autoforme/request'
+require 'autoforme/action'
+require 'autoforme/table'
+require 'autoforme/version'