hammock 0.2.11.2

data/lib/hammock/restful_support.rb

@@ -0,0 +1,186 @@
+module Hammock
+  module RestfulSupport
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+
+      base.class_eval {
+        before_modify :set_editing
+        # TODO Investigate the usefulness of this.
+        # before_destroy :set_editing
+        before_create :set_creator_id_if_appropriate
+        before_create :set_new_or_deleted_before_save
+        before_undestroy :set_new_or_deleted_before_save
+        helper_method :mdl, :mdl_name, :editing?, :nested_within?, :partial_exists?
+      }
+    end
+
+    module ClassMethods
+
+      # The model this controller operates on. Defined as the singularized controller name. For example, for +GelatinousBlobsController+, this will return the +GelatinousBlob+ class.
+      def mdl
+        @hammock_cached_mdl ||= Object.const_get to_s.sub('Controller', '').classify
+      end
+      # The lowercase name of the model this controller operates on. For example, for +GelatinousBlobsController+, this will return "gelatinous_blob".
+      def mdl_name
+        @hammock_cached_mdl_name ||= to_s.sub('Controller', '').singularize.underscore
+      end
+
+    end
+
+    module InstanceMethods
+      private
+
+      # The model this controller operates on. Defined as the singularized controller name. For example, for +GelatinousBlobsController+, this will return the +GelatinousBlob+ class.
+      def mdl
+        self.class.mdl
+      end
+      # The lowercase name of the model this controller operates on. For example, for +GelatinousBlobsController+, this will return "gelatinous_blob".
+      def mdl_name
+        self.class.mdl_name
+      end
+
+      # Returns the node in the Hammock routing map corresponding to the (possibly nested) resource handling the current request.
+      def current_hammock_resource
+        nesting_resources = params.keys.select {|k| /_id$/ =~ k }.map {|k| k.gsub(/_id$/, '').pluralize }
+        ActionController::Routing::Routes.route_map.base_for nesting_resources.push(mdl.resource_name).map(&:to_sym)
+      end
+
+      # Returns true if the current action represents an edit on +record+.
+      #
+      # For example, consider the route <tt>/articles/3/comments/31/edit</tt>, which fires <tt>CommentsController#edit</tt>. The nested route handler would assign <tt>@comment</tt> and <tt>@article</tt> to the appropriate records, and then the following would be observed:
+      #   editing?(@comment) #=> true
+      #   editing?(@article) #=> false
+      def editing? record
+        record == @editing
+      end
+
+      # Returns <tt>params[key]</tt>, defaulting to an empty Hash if <tt>params[key]</tt> can't receive :[].
+      #
+      # This is useful for concise nested parameter access. For example, if <tt>params[:account]</tt> is nil:
+      #   params[:account][:email]      #=> NoMethodError: undefined method `[]' for nil:NilClass
+      #   params_for(:account)[:email]  #=> nil
+      def params_for key
+        params[key] || {}
+      end
+
+      def assign_entity record_or_records
+        @entity = if record_or_records.nil?
+          # Fail
+        elsif record_or_records.is_a? ActiveRecord::Base
+          instance_variable_set "@#{mdl_name}", (@record = record_or_records)
+        elsif record_or_records.is_a? Ambition::Context
+          log "Unkicked query: #{record_or_records.to_hash.inspect}"
+          instance_variable_set "@#{mdl_name.pluralize}", (@records = record_or_records)
+        elsif record_or_records.is_a? Array
+          instance_variable_set "@#{mdl_name.pluralize}", (@records = record_or_records)
+        else
+          raise "Unknown record(s) type #{record_or_records.class}."
+        end
+
+        @entity if assign_nesting_entities
+      end
+
+      private
+
+      def assign_nesting_entities
+        results = nesting_scope_list.map &:kick
+
+        if results.all? {|records| records.length == 1 }
+          results.map {|records|
+            records.first
+          }.all? {|record|
+            log "nested record #{record.concise_inspect} assigned to @#{record.base_model}."
+            add_nested_entity record
+            instance_variable_set "@#{record.base_model}", record
+          }
+        end
+      end
+
+      def make_new_record resource = mdl
+        resource.new_with(params_for(resource.symbolize))
+      end
+
+      def assign_createable
+        assign_entity make_createable
+      end
+
+      def make_createable resource = mdl
+        if !(new_record = make_new_record(resource))
+          log "Couldn't create a new #{resource.base_model} with the given nesting level and parameters."
+        elsif !new_record.createable_by?(current_user)
+          log "#{requester_name} can't create #{new_record.resource_name}."
+        else
+          new_record
+        end
+      end
+
+      def current_nested_records
+        (@current_nested_records || []).dup
+      end
+
+      def current_nested_resources
+        (@current_nested_resources || []).dup
+      end
+
+      def add_nested_entity entity
+        (@current_nested_records ||= []).push entity
+        (@current_nested_resources ||= []).push entity.resource
+      end
+
+      def nested_within? record_or_resource
+        if record_or_resource.is_a? ActiveRecord::Base
+          current_nested_records.include? record_or_resource
+        else
+          current_nested_resources.include? record_or_resource
+        end
+      end
+
+      def safe_verb_and_implication?
+        request.get? && !action_name.to_s.in?(Hammock::Constants::ImpliedUnsafeActions)
+      end
+
+      def set_editing
+        @editing = @record
+      end
+
+      def set_new_or_deleted_before_save
+        @record.set_new_or_deleted_before_save
+      end
+
+      # TODO process /^creating_\w+_id$/ as well
+      def set_creator_id_if_appropriate
+        if @record.respond_to? :creator_id=
+          if current_user.nil?
+            log "Warning: @#{@record.base_model}.creator_id isn't being set, since current_user was nil."
+          else
+            @record.creator_id = current_user.id
+          end
+        end
+      end
+
+      def partial_exists? name, format = nil
+        partial_name, ctrler_name = name.split('/', 2).reverse
+        !Dir.glob(File.join(
+          RAILS_ROOT,
+          'app/views',
+          ctrler_name || '',
+          "_#{partial_name}.#{format || request.format.to_sym.to_s}.*"
+        )).empty?
+      end
+
+      def redirect_back_or opts = {}, *parameters_for_method_reference
+        if request.referer.blank?
+          redirect_to opts, *parameters_for_method_reference
+        else
+          redirect_to request.referer
+        end
+      end
+
+      def rendered_or_redirected?
+        @performed_render || @performed_redirect
+      end
+
+    end
+  end
+end

data/lib/hammock/route_drawing_hooks.rb

@@ -0,0 +1,22 @@
+module Hammock
+  module RouteDrawingHooks
+    MixInto = ActionController::Routing::RouteSet
+
+    def self.included base # :nodoc:
+      base.send :include, Methods
+
+      base.class_eval {
+        alias_method_chain_once :draw, :hammock_route_map_init
+      }
+    end
+
+    module Methods
+
+      def draw_with_hammock_route_map_init &block
+        ActionController::Routing::Routes.send :initialize_hammock_route_map
+        draw_without_hammock_route_map_init &block
+      end
+
+    end
+  end
+end

data/lib/hammock/route_for.rb

@@ -0,0 +1,59 @@
+module Hammock
+  module RouteFor
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+
+      base.class_eval {
+        helper_method :path_for, :nested_path_for, :route_for, :nested_route_for
+      }
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+      private
+
+      def path_for *args
+        route_for(*args).path
+      end
+
+      def nested_path_for *args
+        nested_route_for(*args).path
+      end
+
+      def route_for *args
+        args.compact!
+        opts = args.extract_options!
+        verb = args.shift if args.first.is_a?(Symbol)
+
+        ActionController::Routing::Routes.route_map.for verb_for(verb, args.last), args, opts
+      end
+
+      def verb_for requested_verb, record
+        requested_verb = :show if requested_verb.blank?
+        
+        if (:show == requested_verb) && record.is_a?(Class)
+          :index
+        elsif :modify == requested_verb
+          record.new_record? ? :new : :edit
+        elsif :save == requested_verb
+          record.new_record? ? :create : :update
+        else
+          requested_verb
+        end
+      end
+
+      def nested_route_for *resources
+        resources.delete_if &:nil?
+        requested_verb = resources.shift if resources.first.is_a?(Symbol)
+        args = current_nested_records.concat(resources)
+
+        args.unshift(requested_verb) unless requested_verb.nil?
+        route_for *args
+      end
+
+    end
+  end
+end

data/lib/hammock/route_node.rb

@@ -0,0 +1,159 @@
+module Hammock
+  class RouteNode < ActionController::Resources::Resource
+
+    DefaultRecordVerbs = {
+      :show => :get,
+      :edit => :get,
+      :update => :put,
+      :destroy => :delete
+    }.freeze
+    DefaultResourceVerbs = {
+      :index => :get
+    }.freeze
+    DefaultBuildVerbs = {
+      :new => :get,
+      :create => :post
+    }.freeze
+
+    attr_reader :mdl, :resource, :parent, :children, :routing_parent, :record_routes, :resource_routes, :build_routes
+
+    def initialize entity = nil, options = {}
+      @parent = options[:parent]
+      @children = {}
+      unless root?
+        @mdl = entity if entity.is_a?(Symbol)
+        @routing_parent = determine_routing_parent
+        define_routes options
+      end
+    end
+
+    def resource
+      # TODO performance
+      Object.const_get mdl.to_s.classify rescue nil
+    end
+
+    def root?
+      parent.nil?
+    end
+
+    def ancestry
+      root? ? [] : parent.ancestry.push(self)
+    end
+
+    def for verb, entities, options
+      raise "Hammock::RouteNode#for requires an explicitly specified verb as its first argument." unless verb.is_a?(Symbol)
+      raise "Hammock::RouteNode#for requires an Array of at least one record or resource." if entities.empty? || !entities.is_a?(Array)
+
+      entity = entities.shift
+
+      if entities.empty?
+        steps_for verb, entity
+      else
+        children[entity.resource_sym].for(verb, entities, options).within steps_for(nil, entity)
+      end
+    end
+
+    def base_for resources
+      # puts "base_for<#{mdl}>: resources=#{resources.inspect}."
+      if resources.empty?
+        self
+      else
+        match = nil
+        children.values.detect {|child|
+          # puts "  Trying #{child.ancestry.map(&:mdl).inspect} for #{resources.inspect}"
+          if !resources.include?(child.mdl)
+            # puts "  Can't match #{resources.inspect} against #{child.mdl}."
+            nil
+          else
+            # puts "  Matched #{child.mdl} from #{resources.inspect}."
+            match = child.base_for resources.discard(child.mdl)
+          end
+        } #|| raise("There is no routing path for #{resources.map(&:inspect).inspect}.")
+        match
+      end
+    end
+
+    def nesting_scope_list_for params
+      if root?
+        [ ]
+      else
+        parent.nesting_scope_list_for(params).push nesting_scope_segment_for(params)
+      end
+    end
+
+    def nesting_scope_segment_for params
+      raise "The root of the route map isn't associated with a resource." if root?
+      puts "is this undefined? #{resource.accessible_attributes_on_create.inspect}"
+      value = params.delete resource.param_key
+      puts "resource.select {|r| r.#{resource.routing_attribute} == value }"
+      eval "resource.select {|r| r.#{resource.routing_attribute} == value }"
+    end
+
+    def add entity, options, steps = nil
+      if steps.nil?
+        add entity, options, (options[:name_prefix] || '').chomp('_').split('_').map {|i| i.pluralize.underscore.to_sym }
+      elsif steps.empty?
+        add_child entity, options
+      else
+        children[steps.shift].add entity, options, steps
+      end
+    end
+
+    def routeable_as verb, entity
+      if entity.record? && record_routes[verb || :show]
+        :record
+      elsif entity.resource? && resource_routes[verb || :index]
+        :resource
+      elsif !verb.nil? && build_routes[verb]
+        :build
+      end
+    end
+
+    private
+
+    def define_routes options
+      @record_routes = DefaultRecordVerbs.dup.update(options[:member] || {})
+      @resource_routes = DefaultResourceVerbs.dup.update(options[:collection] || {})
+      @build_routes = DefaultBuildVerbs.dup.update(options[:build] || {})
+    end
+
+    def determine_routing_parent
+      puts "\ndetermine_routing_parent: #{mdl}:"
+      if parent.nil? || parent.resource.nil?
+        puts "Resource for #{mdl} has either no parent or no resource - not nestable."
+        nil
+      else
+        puts "reflections: #{resource.reflections.keys.inspect}"
+        puts "nestable_routing_resources: #{resource.nestable_routing_resources.inspect}"
+        scannable_reflections = resource.nestable_routing_resources.nil? ? resource.reflections : resource.reflections.dragnet(*resource.nestable_routing_resources)
+        puts "scannable reflections: #{scannable_reflections.keys.inspect}"
+        valid_reflections = scannable_reflections.selekt {|k,v| puts "#{v.klass}<#{v.object_id}> == #{parent.resource}<#{parent.resource.object_id}> #=> #{v.klass == parent.resource}"; v.klass == parent.resource }
+        puts "valid reflections: #{valid_reflections.keys.inspect}"
+
+        if valid_reflections.keys.length < 1
+          raise "The routing table specifies that #{mdl} is nested within #{parent.mdl}, but there is no ActiveRecord association linking #{resource} to #{parent.resource}. Example: 'belongs_to :#{parent.resource.base_model}' in the #{resource} model."
+        elsif valid_reflections.keys.length > 1
+          raise "#{resource} defines more than one association to #{parent.resource} (#{valid_reflections.keys.map(&:to_s).join(', ')}). That's fine, but you need to use #{resource}.nest_within to specify the one Hammock should nest scopes through. For example, 'nest_within #{valid_reflections.keys.first.inspect}' in the #{resource} model."
+        end
+
+        valid_reflections.keys.first
+      end
+    end
+
+    def add_child entity, options
+      child = RouteNode.new entity, options.merge(:parent => self)
+      children[child.mdl] = child
+    end
+
+    def steps_for verb, entity
+      child = children[entity.resource_sym]
+
+      if child.nil?
+        raise "No routes are defined for #{entity.resource}#{' within ' + ancestry.map {|r| r.mdl.to_s }.join(', ') unless ancestry.empty?}."
+      else
+        RouteStep.new(child).for(verb, entity)
+      end
+    end
+
+  end
+end

data/lib/hammock/route_step.rb

@@ -0,0 +1,87 @@
+module Hammock
+  class RouteStep
+    attr_reader :resource, :routeable_as, :verb, :entity, :parent
+
+    def initialize resource
+      @resource = resource
+    end
+
+    def for verb, entity
+      routeable_as = resource.routeable_as(verb, entity)
+
+      if !routeable_as
+        raise "The verb '#{verb}' can't be applied to " + (entity.record? ? "#{entity.resource} records" : "the #{entity.resource} resource") + "."
+      elsif (:record == routeable_as) && entity.new_record?
+        raise "The verb '#{verb}' requires a #{entity.resource} with an ID (i.e. not a new record)."
+      elsif (:build == routeable_as) && entity.record? && !entity.new_record?
+        raise "The verb '#{verb}' requires either the #{entity.resource} resource, or a #{entity.resource} without an ID (i.e. a new record)."
+      else
+        @verb, @entity, @routeable_as = verb, entity, routeable_as
+      end
+
+      self
+    end
+
+    def within parent
+      @parent = parent
+      self
+    end
+
+    def setup?
+      !@entity.nil?
+    end
+
+    def path params = nil
+      raise_unless_setup_while_trying_to 'render a path'
+
+      buf = '/'
+      buf << entity.resource_name
+      buf << '/' + entity.to_param if entity.record? && !entity.new_record?
+      buf << '/' + verb.to_s unless verb.nil? or implied_verb?(verb)
+
+      buf = parent.path + buf unless parent.nil?
+      buf << param_str(params)
+
+      buf
+    end
+
+    def http_method
+      raise_unless_setup_while_trying_to 'extract the HTTP method'
+      resource.send("#{routeable_as}_routes")[verb]
+    end
+
+    def fake_http_method
+      http_method.in?(:get, :post) ? http_method : :post
+    end
+
+    def get?;       :get == http_method end
+    def post?;     :post == http_method end
+    def put?;       :put == http_method end
+    def delete?; :delete == http_method end
+
+    def safe?
+      get? && !verb.in?(Hammock::Constants::ImpliedUnsafeActions)
+    end
+
+    private
+
+    def implied_verb? verb
+      verb.in? :index, :create, :show, :update, :destroy
+    end
+
+    def raise_unless_setup_while_trying_to task
+      raise "You have to call for(verb, entity) (and optionally within(parent)) on this RouteStep before you can #{task}." unless setup?
+    end
+
+    def param_str params
+      link_params = entity.record? ? entity.unsaved_attributes.merge(params || {}) : params
+
+      if link_params.blank?
+        ''
+      else
+        '?' + {entity.base_model => link_params}.to_query
+      end
+    end
+
+  end
+end

data/lib/hammock/scope.rb

@@ -0,0 +1,127 @@
+module Hammock
+  module Scope
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+
+      base.class_eval {
+        helper_method :can_verb_entity?
+      }
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+      private
+
+      def can_verb_entity? verb, entity
+        if entity.is_a? ActiveRecord::Base
+          can_verb_record? verb, entity
+        else
+          can_verb_resource? verb, entity
+        end == :ok
+      end
+
+      def can_verb_resource? verb, resource
+        raise "The verb at #{call_point} must be supplied as a Symbol." unless verb.nil? || verb.is_a?(Symbol)
+        route = route_for verb, resource
+        if route.safe? && !resource.indexable_by(current_user)
+          log "#{requester_name} can't index #{resource.name.pluralize}. #{describe_call_point 4}"
+          :not_found
+        elsif !route.safe? && !make_createable(resource)
+          log "#{requester_name} can't #{verb} #{resource.name.pluralize}. #{describe_call_point 4}"
+          :read_only
+        else
+          # log "#{requester_name} can #{verb} #{resource.name.pluralize}."
+          :ok
+        end
+      end
+
+      def can_verb_record? verb, record
+        raise "The verb at #{call_point} must be supplied as a Symbol." unless verb.nil? || verb.is_a?(Symbol)
+        route = route_for verb, record
+        if route.verb.in?(:save, :create) && record.new_record?
+          if !record.createable_by?(current_user)
+            log "#{requester_name} can't create a #{record.class} with #{record.attributes.inspect}. #{describe_call_point 4}"
+            :unauthed
+          else
+            :ok
+          end
+        else
+          if !record.readable_by?(current_user)
+            log "#{requester_name} can't see #{record.class}<#{record.id}>. #{describe_call_point 4}"
+            :not_found
+          elsif !route.safe? && !record.writeable_by?(current_user)
+            log "#{requester_name} can't #{verb} #{record.class}<#{record.id}>. #{describe_call_point 4}"
+            :read_only
+          else
+            # log "#{requester_name} can #{verb} #{record.class}<#{record.id}>."
+            :ok
+          end
+        end
+      end
+
+      def current_verb_scope
+        if current_user && (scope_name = account_verb_scope?)
+          # log "got an account_verb_scope #{scope_name}."
+          mdl.send scope_name, current_user
+        elsif !(scope_name = public_verb_scope?)
+          log "No #{current_user.nil? ? 'public' : 'account'} #{scope_name_for_action} scope available for #{mdl}.#{' May be available after login.' if account_verb_scope?}"
+          nil
+        else
+          # log "got a #{scope_name} public_verb_scope."
+          mdl.send scope_name
+        end
+      end
+
+      def nesting_scope_list
+        @hammock_cached_nesting_scope_list = current_hammock_resource.parent.nesting_scope_list_for params.selekt {|k,v| /_id$/ =~ k }
+      end
+
+      def current_nest_scope
+        nesting_scope_list.reverse.inject {|acc,scope| acc.within scope }
+      end
+
+      def current_scope
+        log "#{current_hammock_resource.mdl}, #{current_hammock_resource.ancestry.map(&:mdl).inspect}"
+        if (verb_scope = current_verb_scope).nil?
+          nil
+        elsif (resultant_scope = verb_scope.within(current_nest_scope, current_hammock_resource.routing_parent)).nil?
+          nil
+        else
+          # puts "nest: #{current_nest_scope.clauses.inspect}"
+          # puts "verb: #{current_verb_scope.clauses.inspect}"
+          puts "chained in (#{resultant_scope.owner}) current_scope: #{resultant_scope.clauses.inspect}"
+          resultant_scope = resultant_scope.chain(custom_scope) unless custom_scope.nil?
+          resultant_scope.sort_by &mdl.sorter
+        end
+      end
+
+
+      private
+
+      def scope_name_for_action
+        if 'index' == action_name
+          'index'
+        elsif safe_verb_and_implication?
+          'read'
+        else
+          'write'
+        end
+      end
+
+      def requester_name
+        current_user.nil? ? 'Anonymous' : "#{current_user.class}<#{current_user.id}>"
+      end
+
+      def account_verb_scope?
+        mdl.has_account_scope? scope_name_for_action
+      end
+      def public_verb_scope?
+        mdl.has_public_scope? scope_name_for_action
+      end
+
+    end
+  end
+end

data/lib/hammock/suggest.rb

@@ -0,0 +1,36 @@
+module Hammock
+  module Suggest
+    MixInto = ActiveRecord::Base
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+
+      def suggest given_fields, queries, limit = 15
+        if (fields = given_fields & columns.map(&:name)).length != given_fields.length
+          log "Invalid columns #{(given_fields - fields).inspect}."
+        else
+          find(:all,
+            :limit => limit,
+            :order => fields.map {|f| "#{f} ASC" }.join(', '),
+            :conditions => [
+              fields.map {|f|
+                ([ "LOWER(#{table_name}.#{f}) LIKE ?" ] * queries.length).join(' AND ')
+              }.map {|clause|
+                "(#{clause})"
+              }.join(' OR ')
+            ].concat(queries.map{|q| "%#{q}%" } * fields.length)
+          )
+        end
+      end
+
+    end
+
+    module InstanceMethods
+
+    end
+  end
+end