autoforme 0.5.0

data/lib/autoforme/framework.rb

@@ -0,0 +1,145 @@
+module AutoForme
+  # The Framework class contains forms for a set of models, tied to web
+  # framework controller.
+  class Framework
+    extend OptsAttributes
+
+    # See Autoforme.for.
+    def self.for(type, controller, opts={}, &block)
+      AutoForme.framework_class_for(type).setup(controller, opts, &block)
+    end
+
+    # Setup a new framework class.
+    def self.setup(controller, opts, &block)
+      f = new(controller, opts)
+      f.instance_exec(&block)
+      f
+    end
+
+    # The web framework controller tied to this framework.
+    attr_reader :controller
+
+    # A map of link names to AutoForme::Model classes for this Framework.
+    attr_reader :models
+
+    # A map of underlying model classes to AutoForme::Model classes for this Framework.
+    attr_reader :model_classes
+    
+    # The configuration options related to this framework.
+    attr_reader :opts
+
+    # The path prefix that this framework is mounted at
+    attr_reader :prefix
+
+    opts_attribute :after_create, :after_destroy, :after_update, :association_links,
+      :autocomplete_options, :before_action, :before_create, :before_destroy,
+      :before_edit, :before_new, :before_update, :column_options,
+      :columns, :display_name, :filter, :form_attributes, :form_options,
+      :inline_mtm_associations, :lazy_load_association_links,
+      :model_type, :mtm_associations, :order, :page_footer, :page_header, :per_page,
+      :redirect, :supported_actions, :table_class
+
+    def initialize(controller, opts={})
+      @controller = controller
+      @opts = opts.dup
+      @prefix = @opts[:prefix]
+      @models = {}
+      @model_classes = {}
+    end
+
+    def supported_actions_for(model, request)
+      handle_proc(supported_actions, model, request)
+    end
+
+    def table_class_for(model, type, request)
+      handle_proc(table_class, model, type, request)
+    end
+
+    def limit_for(model, type, request)
+      handle_proc(per_page, model, type, request)
+    end
+
+    def columns_for(model, type, request)
+      handle_proc(columns, model, type, request)
+    end
+
+    def mtm_associations_for(model, request)
+      handle_proc(mtm_associations, model, request)
+    end
+
+    def inline_mtm_associations_for(model, request)
+      handle_proc(inline_mtm_associations, model, request)
+    end
+
+    def order_for(model, type, request)
+      handle_proc(order, model, type, request)
+    end
+
+    def filter_for(model)
+      handle_proc(filter, model)
+    end
+
+    def redirect_for(model)
+      handle_proc(redirect, model)
+    end
+
+    def display_name_for(model)
+      handle_proc(display_name, model)
+    end
+
+    def form_attributes_for(model, type, request)
+      handle_proc(form_attributes, model, type, request) || {}
+    end
+
+    def form_options_for(model, type, request)
+      handle_proc(form_options, model, type, request) || {}
+    end
+
+    def page_footer_for(model, type, request)
+      handle_proc(page_footer, model, type, request)
+    end
+
+    def page_header_for(model, type, request)
+      handle_proc(page_header, model, type, request)
+    end
+
+    def lazy_load_association_links?(model, type, request)
+      handle_proc(lazy_load_association_links, model, type, request)
+    end
+
+    def autocomplete_options_for(model, type, request)
+      handle_proc(autocomplete_options, model, type, request)
+    end
+
+    def association_links_for(model, type, request)
+      handle_proc(association_links, model, type, request)
+    end
+
+    # Add a new model to the existing framework.  
+    def model(model_class, &block)
+      model = Model.for(self, model_type, model_class, &block)
+      @model_classes[model.model] = model
+      @models[model.link] = model
+    end
+
+    # Return the action related to the given request, if such an
+    # action is supported.
+    def action_for(request)
+      if model = @models[request.model]
+        action = Action.new(model, request)
+        action if action.supported?
+      end
+    end
+
+    private
+
+    def handle_proc(v, *a)
+      case v
+      when Proc, Method
+        v.call(*a)
+      else
+        v
+      end
+    end
+  end
+end

data/lib/autoforme/frameworks/rails.rb

@@ -0,0 +1,80 @@
+module AutoForme
+  module Frameworks
+    class Rails < AutoForme::Framework
+      class Request < AutoForme::Request
+        def initialize(request)
+          @controller = request
+          @params = request.params
+          @session = request.session
+          @env = request.env
+          @method = @env['REQUEST_METHOD']
+          @model = @params['autoforme_model']
+          @action_type = @params['autoforme_action']
+          @path = @env['SCRIPT_NAME']
+          @id = @params['id']
+        end
+
+        # Implement redirects in the Rails support using throw/catch, similar to
+        # how they are natively implemented in Sinatra.
+        def redirect(path)
+          throw :redirect, path
+        end
+
+        # Whether the request is an asynchronous request
+        def xhr?
+          @controller.request.xhr?
+        end
+        
+        # Use Rails's form_authenticity_token for CSRF protection.
+        def csrf_token_hash
+          vc = @controller.view_context
+          {vc.request_forgery_protection_token.to_s=>vc.form_authenticity_token} if vc.protect_against_forgery?
+        end
+      end
+
+      # After setting up the framework, add a route for the framework to Rails, so that
+      # requests are correctly routed.
+      def self.setup(controller, opts, &block)
+        f = super
+        f.setup_routes
+        f
+      end
+
+      # Define an autoforme method in the controller which handles the actions.
+      def initialize(*)
+        super
+        framework = self
+        @controller.send(:define_method, :autoforme) do
+          if @autoforme_action = framework.action_for(Request.new(self))
+            if redirect = catch(:redirect){@autoforme_text = @autoforme_action.handle; nil}
+              redirect_to redirect
+            else
+              render :inline=>"<%=raw @autoforme_text %>", :layout=>!@autoforme_action.request.xhr?
+            end
+          else
+            render :text=>'Unhandled Request', :status=>404
+          end
+        end
+      end
+
+      ALL_SUPPORTED_ACTIONS_REGEXP = Regexp.union(AutoForme::Action::ALL_SUPPORTED_ACTIONS.map{|x| /#{Regexp.escape(x)}/})
+
+      # Add a route for the framework to Rails routing.
+      def setup_routes
+        if prefix
+          pre = prefix.to_s[1..-1] + '/'
+        end
+        model_regexp = Regexp.union(models.keys.map{|m| Regexp.escape(m)})
+        controller = @controller.name.sub(/Controller\z/, '').underscore
+        ::Rails.application.routes.prepend do
+          match "#{pre}:autoforme_model/:autoforme_action(/:id)" , :controller=>controller, :action=>'autoforme', :via=>[:get, :post],
+            :constraints=>{:autoforme_model=>model_regexp, :autoforme_action=>ALL_SUPPORTED_ACTIONS_REGEXP}
+        end
+        ::Rails.application.reload_routes!
+      end
+
+    end
+  end
+
+  register_framework(:rails, Frameworks::Rails)
+end

data/lib/autoforme/frameworks/sinatra.rb

@@ -0,0 +1,59 @@
+module AutoForme
+  module Frameworks
+    class Sinatra < AutoForme::Framework
+      class Request < AutoForme::Request
+        def initialize(controller)
+          @controller = controller
+          @request = controller.request
+          @params = controller.params
+          @session = controller.session
+          captures = @params[:captures] || []
+          @env = @request.env
+          @method = @env['REQUEST_METHOD']
+          @model = captures[0]
+          @action_type = captures[1]
+          @path = @env['SCRIPT_NAME']
+          @id = @params[:id] || captures[2]
+        end
+
+        # Redirect to the given path
+        def redirect(path)
+          controller.redirect(path)
+        end
+
+        # Whether the request is an asynchronous request
+        def xhr?
+          @env['HTTP_X_REQUESTED_WITH'] =~ /XMLHttpRequest/i
+        end
+        
+        # Use Rack::Csrf for csrf protection if it is defined.
+        def csrf_token_hash
+          {::Rack::Csrf.field=>::Rack::Csrf.token(@env)} if defined?(::Rack::Csrf)
+        end
+      end
+
+      # Add get and post routes when creating the framework.  These routes can potentially
+      # match other routes, but in that case use pass to try the next route.
+      def initialize(*)
+        super
+        framework = self
+        block = lambda do
+          if @autoforme_action = framework.action_for(Request.new(self))
+            @autoforme_text = @autoforme_action.handle
+            opts = {}
+            opts[:layout] = false if @autoforme_action.request.xhr?
+            erb "<%= @autoforme_text %>", opts
+          else
+            pass
+          end
+        end
+
+        prefix = Regexp.escape(framework.prefix) if framework.prefix
+        @controller.get %r{\A#{prefix}/(\w+)/(\w+)(?:/(\w+))?\z}, &block
+        @controller.post %r{\A#{prefix}/(\w+)/(\w+)(?:/(\w+))?\z}, &block
+      end
+    end
+  end
+
+  register_framework(:sinatra, Frameworks::Sinatra)
+end

data/lib/autoforme/model.rb

@@ -0,0 +1,377 @@
+module AutoForme
+  # Wraps a specific model class
+  class Model
+    # Array of supported autocomplete types 
+    AUTOCOMPLETE_TYPES = [:show, :edit, :delete, :association, :mtm_edit].freeze
+
+    # The default number of records to show on each browse/search results pages
+    DEFAULT_LIMIT = 25
+
+    # The default table class to use for browse/search results pages
+    DEFAULT_TABLE_CLASS = "table table-bordered table-striped"
+
+    # The default supported actions for models.
+    DEFAULT_SUPPORTED_ACTIONS = [:browse, :new, :show, :edit, :delete, :search, :mtm_edit]
+
+    extend OptsAttributes
+
+    # Create a new instance for the given model type and underlying model class
+    # tied to the given framework.
+    def self.for(framework, type, model_class, &block)
+      model = AutoForme.model_class_for(type).new(model_class, framework)
+      model.instance_exec(&block) if block
+      model
+    end
+
+    # The AutoForme::Framework class tied to the current model
+    attr_reader :framework
+    
+    # The underlying model class for the current model
+    attr_reader :model
+    
+    # The options for the given model.
+    attr_reader :opts
+
+    opts_attribute :after_create, :after_destroy, :after_update, :association_links,
+      :autocomplete_options, :before_action, :before_create, :before_destroy,
+      :before_edit, :before_new, :before_update, :class_display_name,
+      :column_options, :columns, :display_name, :eager, :eager_graph,
+      :filter, :form_attributes, :form_options,
+      :inline_mtm_associations, :lazy_load_association_links, :link_name, :mtm_associations,
+      :order, :page_footer, :page_header, :per_page,
+      :redirect, :supported_actions, :table_class
+
+    def initialize(model, framework)
+      @model = model
+      @framework = framework
+      @opts = {}
+    end
+
+    # Whether the given type of action is supported for this model.
+    def supported_action?(type, request)
+      (handle_proc(supported_actions || framework.supported_actions_for(model, request), request) || DEFAULT_SUPPORTED_ACTIONS).include?(type)
+    end
+
+    # An array of many to many association symbols to handle via a separate mtm_edit page.
+    def mtm_association_select_options(request)
+      normalize_mtm_associations(handle_proc(mtm_associations || framework.mtm_associations_for(model, request), request))
+    end
+    
+    # Whether an mtm_edit can be displayed for the given association
+    def supported_mtm_edit?(assoc, request)
+      mtm_association_select_options(request).map{|x| x.to_s}.include?(assoc)
+    end
+
+    # Whether an mtm_update can occur for the given association
+    def supported_mtm_update?(assoc, request)
+      supported_mtm_edit?(assoc, request) || inline_mtm_assocs(request).map{|x| x.to_s}.include?(assoc) 
+    end
+
+    # An array of many to many association symbols to handle inline on the edit forms.
+    def inline_mtm_assocs(request)
+      normalize_mtm_associations(handle_proc(inline_mtm_associations || framework.inline_mtm_associations_for(model, request), request))
+    end
+
+    def columns_for(type, request)
+      handle_proc(columns || framework.columns_for(model, type, request), type, request) || default_columns
+    end
+
+    # The options to use for the given column and request.  Instead of the model options overriding the framework
+    # options, they are merged together.
+    def column_options_for(type, request, column)
+      framework_opts = case framework_opts = framework.column_options
+      when Proc, Method
+        framework_opts.call(model, column, type, request) || {}
+      else
+        extract_column_options(framework_opts, column, type, request)
+      end
+
+      model_opts = case model_opts = column_options
+      when Proc, Method
+        model_opts.call(column, type, request) || {}
+      else
+        extract_column_options(model_opts, column, type, request)
+      end
+
+      opts = framework_opts.merge(model_opts).dup
+
+      if association?(column) && associated_model = associated_model_class(column)
+        if associated_model.autocomplete_options_for(:association, request) && !opts[:as] && association_type(column) == :one
+          opts[:type] = 'text'
+          opts[:class] = 'autoforme_autocomplete'
+          opts[:attr] = {'data-column'=>column, 'data-type'=>type}
+          opts[:name] = form_param_name(column)
+        else
+          unless opts[:name_method]
+            opts[:name_method] = lambda{|obj| associated_model.object_display_name(:association, request, obj)}
+          end
+
+          case type
+          when :edit, :new, :search_form
+            unless opts[:options] || opts[:dataset]
+              opts[:dataset] = lambda{|ds| associated_model.apply_dataset_options(:association, request, ds)}
+            end
+          end
+        end
+      end
+
+      case type
+      when :show, :search_form
+        opts[:required] = false unless opts.has_key?(:required)
+        if type == :search_form && opts[:as] == :textarea
+          opts.delete(:as)
+        end
+      end
+
+      opts
+    end
+
+    def order_for(type, request)
+      handle_proc(order || framework.order_for(model, type, request), type, request)
+    end
+
+    def eager_for(type, request)
+      handle_proc(eager, type, request)
+    end
+
+    def eager_graph_for(type, request)
+      handle_proc(eager_graph, type, request)
+    end
+
+    def filter_for
+      filter || framework.filter_for(model)
+    end
+
+    def redirect_for
+      redirect || framework.redirect_for(model)
+    end
+
+    def form_attributes_for(type, request)
+      framework.form_attributes_for(model, type, request).merge(handle_proc(form_attributes, type, request) || {})
+    end
+
+    def form_options_for(type, request)
+      framework.form_options_for(model, type, request).merge(handle_proc(form_options, type, request) || {})
+    end
+
+    def page_footer_for(type, request)
+      handle_proc(page_footer || framework.page_footer_for(model, type, request), type, request)
+    end
+
+    def page_header_for(type, request)
+      handle_proc(page_header || framework.page_header_for(model, type, request), type, request)
+    end
+
+    def table_class_for(type, request)
+      handle_proc(table_class || framework.table_class_for(model, type, request), type, request) || DEFAULT_TABLE_CLASS
+    end
+
+    def limit_for(type, request)
+      handle_proc(per_page || framework.limit_for(model, type, request), type, request) || DEFAULT_LIMIT
+    end
+
+    def display_name_for
+      display_name || framework.display_name_for(model)
+    end
+
+    def association_links_for(type, request)
+      case v = handle_proc(association_links || framework.association_links_for(model, type, request), type, request)
+      when nil
+        []
+      when Array
+        v
+      when :all
+        association_names
+      when :all_except_mtm
+        association_names - mtm_association_names
+      else
+        [v]
+      end
+    end
+
+    # Whether to lazy load association links for this model.
+    def lazy_load_association_links?(type, request)
+      v = handle_proc(lazy_load_association_links, type, request)
+      v = framework.lazy_load_association_links?(model, type, request) if v.nil?
+      v || false
+    end
+
+    def autocomplete_options_for(type, request)
+      return unless AUTOCOMPLETE_TYPES.include?(type)
+      framework_opts = framework.autocomplete_options_for(model, type, request)
+      model_opts = handle_proc(autocomplete_options, type, request)
+      if model_opts
+        (framework_opts || {}).merge(model_opts)
+      end
+    end
+
+    # The name to display to the user for this model.
+    def class_name
+      class_display_name || model.name
+    end
+
+    # The name to use in links for this model.  Also affects where this model is mounted at.
+    def link
+      link_name || class_name
+    end
+
+    # The AutoForme::Model instance associated to the given association.
+    def associated_model_class(assoc)
+      framework.model_classes[associated_class(assoc)]
+    end
+
+    # The column value to display for the given object and column.
+    def column_value(type, request, obj, column)
+      return unless v = obj.send(column)
+      if association?(column) 
+        opts = column_options_for(type, request, column) 
+        case nm = opts[:name_method]
+        when Symbol, String
+          v = v.send(nm)
+        when nil
+        else
+          v = nm.call(v)
+        end
+      end
+      if v.is_a?(base_class)
+        v = default_object_display_name(v)
+      end
+      v
+    end
+
+    # Destroy the given object, deleting it from the database.
+    def destroy(obj)
+      obj.destroy
+    end
+
+    # Run framework and model before_action hooks with type symbol and request.
+    def before_action_hook(type, request)
+      if v = framework.before_action
+        v.call(type, request)
+      end
+      if v = before_action
+        v.call(type, request)
+      end
+    end
+
+    # Run given hooks with the related object and request.
+    def hook(type, request, obj)
+      if type.to_s =~ /before/
+        if v = framework.send(type)
+          v.call(obj, request)
+        end
+        if v = send(type)
+          v.call(obj, request)
+        end
+      else
+        if v = send(type)
+          v.call(obj, request)
+        end
+        if v = framework.send(type)
+          v.call(obj, request)
+        end
+      end
+    end
+
+    # Create a new instance of the underlying model, setting
+    # defaults based on the params given.
+    def new(params, request)
+      obj = @model.new
+      if params
+        columns_for(:new, request).each do |col|
+          if association?(col)
+            col = association_key(col)
+          end
+          if v = params[col]
+            obj.send("#{col}=", v)
+          end
+        end
+      end
+      obj
+    end
+
+    # An array of pairs for the select options to return for the given type.
+    def select_options(type, request, opts={})
+      case nm = opts[:name_method]
+      when Symbol, String
+        all_rows_for(type, request).map{|obj| [obj.send(nm), primary_key_value(obj)]}
+      when nil
+        all_rows_for(type, request).map{|obj| [object_display_name(type, request, obj), primary_key_value(obj)]}
+      else
+        all_rows_for(type, request).map{|obj| [nm.call(obj), primary_key_value(obj)]}
+      end
+    end
+
+    # A human readable string representing the object.
+    def object_display_name(type, request, obj)
+      apply_name_method(display_name_for, obj, type, request)
+    end
+
+    # A human reable string for the associated object.
+    def associated_object_display_name(assoc, request, obj)
+      apply_name_method(column_options_for(:mtm_edit, request, assoc)[:name_method], obj, :mtm_edit, request)
+    end
+
+    # A fallback for the display name for the object if none is configured.
+    def default_object_display_name(obj)
+      if obj.respond_to?(:forme_name)
+        obj.forme_name
+      elsif obj.respond_to?(:name)
+        obj.name
+      else
+        primary_key_value(obj)
+      end
+    end
+
+    private
+
+    def apply_name_method(nm, obj, type, request)
+      case nm
+      when Symbol
+        obj.send(nm)
+      when Proc, Method
+        case nm.arity
+        when 3
+          nm.call(obj, type, request)
+        when 2
+          nm.call(obj, type)
+        else
+          nm.call(obj)
+        end
+      when nil
+        default_object_display_name(obj)
+      else
+        raise Error, "invalid name method: #{nm.inspect}"
+      end
+    end
+
+    def extract_column_options(opts, column, type, request)
+      return {} unless opts
+      case opts = opts[column]
+      when Proc, Method
+        opts.call(type, request)
+      when nil
+        {}
+      else
+        opts
+      end
+    end
+
+    def handle_proc(v, *a)
+      case v
+      when Proc, Method
+        v.call(*a)
+      else
+        v
+      end
+    end
+    
+    def normalize_mtm_associations(assocs)
+      if assocs == :all
+        mtm_association_names
+      else
+        Array(assocs)
+      end
+    end
+  end
+end