benhoskings-hammock 0.2.4

data/lib/hammock/restful_support.rb

@@ -0,0 +1,167 @@
+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
+        helper_method :mdl, :mdl_name, :editing?, :nested_within?, :partial_exists?
+      }
+    end
+
+    module ClassMethods
+
+    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
+        @hammock_cached_mdl ||= Object.const_get self.class.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 ||= self.class.to_s.sub('Controller', '').singularize.underscore
+      end
+
+      def current_route
+        @hammock_cached_current_route ||= route_for(action_name.to_sym, *current_nested_records.push(@entity)) unless @entity.nil?
+      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_s}"
+          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
+
+        if assign_nestable_resources
+          @entity
+        else
+          escort :not_found
+        end
+      end
+
+      private
+
+      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_account)
+          log "#{requester_name} can't create #{new_record.resource_name}."
+        else
+          new_record
+        end
+      end
+
+      def assign_nestable_resources
+        @current_nested_records, @current_nested_resources = [], []
+        params.symbolize_keys.dragnet(*nestable_resources.keys).all? {|param_name,column_name|
+          constant_name = param_name.to_s.sub(/_id$/, '').camelize
+          constant = Object.const_get constant_name rescue nil
+
+          if constant.nil?
+            log "'#{constant_name}' is not available for #{param_name}."
+          elsif (record = constant.find_by_id(params[param_name])).nil?
+            log "#{constant}<#{params[param_name]}> not found."
+          else
+            @current_nested_records << record
+            @current_nested_resources << record.class
+            @record.send "#{nestable_resources[param_name]}=", params[param_name] unless @record.nil?
+            # log "Assigning @#{constant.name.underscore} with #{record.inspect}."
+            instance_variable_set "@#{constant_name.underscore}", record
+          end
+        }
+      end
+
+      def current_nested_records
+        @current_nested_records.nil? ? [] : @current_nested_records.dup
+      end
+
+      def current_nested_resources
+        @current_nested_resources.nil? ? [] : @current_nested_resources.dup
+      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_creator_id_if_appropriate
+        @record.creator_id = @current_account.id if @record.respond_to?(:creator_id=)
+      end
+
+      def partial_exists? name, extension = nil
+        partial_name, ctrler_name = name.split('/', 2).reverse
+        !Dir.glob(File.join(
+          RAILS_ROOT,
+          'app/views',
+          ctrler_name || '',
+          "_#{partial_name}.html.#{extension || '*'}"
+        )).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,58 @@
+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
+        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.dup.concat(resources)
+
+        args.unshift(requested_verb) unless requested_verb.nil?
+        route_for *args
+      end
+
+    end
+  end
+end

data/lib/hammock/scope.rb

@@ -0,0 +1,120 @@
+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_account)
+          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_account)
+            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_account)
+            log "#{requester_name} can't see #{record.class}<#{record.id}>. #{describe_call_point 4}"
+            :not_found
+          elsif !route.safe? && !record.writeable_by?(@current_account)
+            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 verb_scope
+        if @current_account && (scope_name = account_verb_scope?)
+          # log "got an account_verb_scope #{scope_name}."
+          mdl.send scope_name, @current_account
+        elsif !(scope_name = public_verb_scope?)
+          log "No #{@current_account.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 nest_scope
+        params.symbolize_keys.dragnet(*nestable_resources.keys).inject(mdl.ambition_context) {|acc,(k,v)|
+          # TODO this would be more ductile if it used AR assocs instead of explicit FK
+          eval "acc.select {|r| r.#{nestable_resources[k]} == v }"
+        }
+      end
+
+      def current_scope
+        if (resultant_scope = nest_scope.chain(verb_scope)).nil?
+          nil
+        else
+          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_account.nil? ? 'Anonymous' : "#{@current_account.class}<#{@current_account.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

data/lib/hammock/utils.rb

@@ -0,0 +1,42 @@
+module Hammock
+  module Utils
+    def self.included base # :nodoc:
+      base.send :include, Methods
+      base.send :extend, Methods
+    end
+
+    module Methods
+      private
+
+      require 'pathname'
+      def rails_root
+        @hammock_cached_rails_root ||= Pathname(RAILS_ROOT).realpath.to_s
+      end
+
+      def rails_env
+        ENV['RAILS_ENV'] || 'development'
+      end
+
+      def development?
+        'development' == rails_env
+      end
+
+      def production?
+        'production' == rails_env
+      end
+
+      def sqlite?
+        'SQLite' == connection.adapter_name
+      end
+
+      def describe_call_point offset = 0
+        "(called from #{call_point offset + 1})"
+      end
+
+      def call_point offset = 0
+        caller[offset + 1].strip.gsub(rails_root, '').gsub(/\:in\ .*$/, '')
+      end
+
+    end
+  end
+end