benhoskings-hammock 0.2.4

data/lib/hammock/canned_scopes.rb

@@ -0,0 +1,121 @@
+module Hammock
+  # TODO This file is horribly non-DRY.
+  module CannedScopes
+    MixInto = ActiveRecord::Base
+
+    # TODO Put this somewhere better.
+    StandardVerbs = [:read, :write, :index, :create]
+
+    def self.included base
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+
+      protected
+
+      def public_resource
+        public_resource_for *StandardVerbs
+      end
+
+      def authed_resource
+        authed_resource_for *StandardVerbs
+      end
+
+      def creator_resource
+        creator_resource_for *StandardVerbs
+      end
+
+      def partitioned_resource
+        partitioned_resource_for *StandardVerbs
+      end
+
+      def creator_resource_for *verbs
+        metaclass.instance_eval {
+          verbs.each {|verb|
+            send :define_method, "#{verb}_scope_for" do |account|
+              creator_scope account
+            end
+          }
+        }
+        define_createable :creator_scope if verbs.include?(:create)
+        export_scopes *verbs
+      end
+
+      def public_resource_for *verbs
+        metaclass.instance_eval {
+          verbs.each {|verb|
+            send :define_method, "#{verb}_scope" do
+              public_scope nil
+            end
+          }
+        }
+        define_createable :public_scope if verbs.include?(:create)
+        export_scopes *verbs
+      end
+
+      def authed_resource_for *verbs
+        metaclass.instance_eval {
+          verbs.each {|verb|
+            send :define_method, "#{verb}_scope_for" do |account|
+              authed_scope account
+            end
+          }
+        }
+        define_createable :authed_scope if verbs.include?(:create)
+        export_scopes *verbs
+      end
+
+      def partitioned_resource_for *verbs
+        metaclass.instance_eval {
+          verbs.each {|verb|
+            send :define_method, "#{verb}_scope_for" do |account|
+              partitioned_scope account
+            end
+          }
+        }
+        define_createable :partitioned_scope if verbs.include?(:create)
+        export_scopes *verbs
+      end
+
+      def define_createable scope_name
+        instance_eval {
+          send :define_method, :createable_by? do |account|
+            self.class.send scope_name, account
+          end
+        }
+      end
+
+      def public_scope account
+        if sqlite?
+          lambda {|record| 1 }
+        else
+          lambda {|record| true }
+        end
+      end
+
+      def authed_scope account
+        has_account = !account.nil?
+        lambda {|record| has_account }
+      end
+
+      def creator_scope account
+        lambda {|record| record.creator_id == account.id }
+      end
+      
+      def partitioned_scope account
+        lambda {|record| record.id == account.id }
+      end
+
+      def empty_scope
+        lambda {|record| false }
+      end
+
+    end
+
+    module InstanceMethods
+
+    end
+  end
+end

data/lib/hammock/constants.rb

@@ -0,0 +1,7 @@
+module Hammock
+  module Constants
+    
+    ImpliedUnsafeActions = [:new, :edit, :destroy]
+    
+  end
+end

data/lib/hammock/controller_attributes.rb

@@ -0,0 +1,66 @@
+module Hammock
+  module ControllerAttributes
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+
+      # Specifies parent resources that can appear above this one in the route, and will be applied as an extra scope condition whenever present.
+      #
+      # Supplied as a hash of parameter names to attribute names. For example, given the route <tt>/accounts/7/posts/31</tt>,
+      #     nestable_by :account_id => :creator_id
+      # Would add an extra scope condition requiring that <tt>@post.creator_id</tt> == <tt>params[:account_id]</tt>.
+      def nestable_by resources
+        write_inheritable_attribute :nestable_by, resources
+      end
+
+      # When +inline_create+ is specified for a controller, the +index+ page will have the ability to directly create new resources, just as the +new+ page normally can.
+      #
+      # To use +inline_create+, refactor the relevant contents of your +new+ view into a partial and render it in an appropriate place within the +index+ view.
+      #
+      # A successful +create+ will redirect to the +show+ action for the new record, and a failed +create+ will re-render the +index+ action with a populated form, in the same way the +new+ action would normally be rendered in the event of a failed +create+.
+      def inline_create
+        write_inheritable_attribute :inline_create, true
+      end
+
+      # When +find_on_create+ is specified for a controller, attempts to +create+ new records will first check to see if an identical record already exists. If such a record is found, it is returned and the create is never attempted.
+      #
+      # This is useful for the management of administrative records like memberships or friendships, where the user may attempt to create a new record using some unique identifier like an email address. For such a resource, a pre-existing record should not be considered a failure, as would otherwise be triggered by uniqueness checks on the model.
+      def find_on_create
+        write_inheritable_attribute :find_on_create, true
+      end
+
+      # Use +find_column+ to specify the name of an alternate column with which record lookups should be performed.
+      #
+      # This is useful for controllers that are indexed by primary key, but are accessed with URLs containing some other unique attribute of the resource, like a randomly-generated key.
+      #     find_column :key
+      def find_column column_name
+        # TODO define to_param on model.
+        write_inheritable_attribute :find_column, column_name
+      end
+    end
+
+    module InstanceMethods
+
+      private
+
+      def nestable_resources
+        self.class.read_inheritable_attribute(:nestable_by) || {}
+      end
+
+      def inline_createable_resource?
+        self.class.read_inheritable_attribute :inline_create
+      end
+
+      def findable_on_create?
+        self.class.read_inheritable_attribute :find_on_create
+      end
+
+      def find_column_name
+        self.class.read_inheritable_attribute(:find_column) || :id
+      end
+    end
+  end
+end

data/lib/hammock/export_scope.rb

@@ -0,0 +1,74 @@
+module Hammock
+  module ExportScope
+    MixInto = ActiveRecord::Base
+
+    def self.included base
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+
+      def has_public_scope? scope_name
+        "#{scope_name}able" if respond_to? "#{scope_name}_scope"
+      end
+
+      def has_account_scope? scope_name
+        "#{scope_name}able_by" if respond_to? "#{scope_name}_scope_for"
+      end
+
+      def export_scopes *verbs
+        verbs.discard(:create).each {|verb| export_scope verb }
+      end
+
+      def export_scope verb
+        verbable = "#{verb}able"
+
+        metaclass.instance_eval {
+          # Model.verbable_by: returns all records that are verbable by account.
+          define_method "#{verbable}_by" do |account|
+            if !account.nil? && respond_to?("#{verb}_scope_for")
+              select &send("#{verb}_scope_for", account)
+            elsif respond_to?("#{verb}_scope")
+              select &send("#{verb}_scope")
+            else
+              log "No #{verb} scopes available."
+              nil
+            end
+          end
+
+          # Model.verbable: returns all records that are verbable by anonymous users.
+          define_method verbable do
+            send "#{verbable}_by", nil
+          end
+        }
+
+        # Model#verbable_by?: returns whether this record is verbable by account.
+        define_method "#{verbable}_by?" do |account|
+          if !account.nil? && self.class.respond_to?("#{verb}_scope_for")
+            self.class.send("#{verb}_scope_for", account).call(self)
+          elsif self.class.respond_to?("#{verb}_scope")
+            self.class.send("#{verb}_scope").call(self)
+          else
+            log "No #{verb} scopes available, returning false."
+            false
+          end
+        end
+
+        # Model#verbable?: returns whether this record is verbable by anonymous users.
+        define_method "#{verbable}?" do
+          send "#{verbable}_by?", nil
+        end
+      end
+
+    end
+
+    module InstanceMethods
+
+      def createable_by? account
+        false
+      end
+
+    end
+  end
+end

data/lib/hammock/hamlink_to.rb

@@ -0,0 +1,47 @@
+module Hammock
+  module HamlinkTo
+    MixInto = ActionView::Base
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      # Generate a restful link to verb the provided resources if the request would be allowed under the current scope.
+      # If the scope would not allow the specified request, the link is ommitted entirely from the page.
+      #
+      # Use this method to render edit and delete links, and anything else that is only available to certain users or under certain conditions.
+      def hamlink_to *args
+        opts = args.extract_options!
+        verb = args.first if args.first.is_a?(Symbol)
+        entity = args.last
+
+        if can_verb_entity?(verb, entity)
+          route = route_for *args.push(opts.dragnet(:nest, :format))
+
+          # opts[:class] = ['current', opts[:class]].squash.join(' ') if opts[:indicate_current] && (route == controller.current_route)
+          opts[:class] = [link_class_for(route.verb, entity), opts[:class]].squash.join(' ')
+
+          text = opts.delete(:text) || opts.delete(:text_or_else)
+
+          if text.is_a?(Symbol)
+            text = entity.send(text)
+          end
+
+          link_to(text || route.verb,
+            route.path(opts.delete(:params)),
+            opts.merge(:method => (route.http_method unless route.get?))
+          )
+        else
+          opts[:else] || opts[:text_or_else]
+        end
+      end
+
+    end
+  end
+end

data/lib/hammock/javascript_buffer.rb

@@ -0,0 +1,63 @@
+module Hammock
+  module JavascriptBuffer
+    MixInto = ActionView::Base
+    
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      # Add +snippet+ to the request's domready javascript cache.
+      #
+      # The contents of this cache can be rendered into a jQuery <tt>$(function() { ... })</tt> block within a <tt>\<script type="text/javascript"></tt> block by calling <tt>javascript_for_page</tt> within the \<head> of the layout.
+      def append_javascript snippet
+        # TODO This should be an array of strings.
+        @_domready_javascript ||= ''
+        @_domready_javascript << snippet.strip.end_with(';') << "\n\n" unless snippet.nil?
+      end
+
+      # Add +snippet+ to the request's toplevel javascript cache.
+      #
+      # The contents of this cache can be rendered into a <tt>\<script type="text/javascript"></tt> block by calling <tt>javascript_for_page</tt> within the \<head> of the layout.
+      def append_toplevel_javascript snippet
+        @_toplevel_javascript ||= ''
+        @_toplevel_javascript << snippet.strip.end_with(';') << "\n\n" unless snippet.nil?
+      end
+
+      # Render the snippets cached by +append_javascript+ and +append_toplevel_javascript+ within a <tt>\<script type="text/javascript"></tt> tag.
+      #
+      # This should be called somewhere within the \<head> in your layout.
+      def javascript_for_page
+        javascript_tag %Q{
+          #{@_toplevel_javascript}
+
+          (jQuery)(function() {
+            #{@_domready_javascript}
+          });
+        }
+      end
+
+      # If the current request is XHR, render all cached javascript as +javascript_for_page+ would and clear the request's javascript cache.
+      #
+      # The purpose of this method is for rendering javascript into partials that form XHR responses, without causing duplicate javascript to be rendered by nested partials multiply calling this method.
+      def javascript_for_ajax_response
+        # TODO this should be called from outside the partials somewhere, once only
+        if request.xhr?
+          js = javascript_for_page
+          clear_js_caches
+          js
+        end
+      end
+
+      def clear_js_caches
+        @_domready_javascript = @_toplevel_javascript = nil
+      end
+
+    end
+  end
+end

data/lib/hammock/logging.rb

@@ -0,0 +1,98 @@
+module Hammock
+  module Logging
+    MixInto = ActionController::Base
+
+    def self.included base
+      base.send :include, Methods
+      base.send :extend, Methods
+
+      base.class_eval {
+        helper_method :log
+      }
+    end
+
+    module Methods
+
+      def log_hit
+        log_concise [
+          request.remote_ip.colorize('green'),
+          (@current_site.subdomain unless @current_site.nil?),
+          (session.nil? ? 'nil' : ('...' + session.session_id[-8, 8])),
+          (@current_account.nil? ? "unauthed" : "Account<#{@current_account.id}> #{@current_account.name}").colorize('green'),
+          headers['Status'],
+          log_hit_request_info,
+          log_hit_route_info
+        ].squash.join(' | ')
+      end
+
+      def log_hit_request_info
+        (request.xhr? ? 'XHR/' : '') +
+        (params[:_method] || request.method).to_s.upcase +
+        ' ' +
+        request.request_uri.colorize('grey', '?')
+      end
+      
+      def log_hit_route_info
+        params[:controller] +
+        '#' +
+        params[:action] +
+        ' ' +
+        params.discard(:controller, :action).inspect.gsub("\n", '\n').colorize('grey')
+      end
+
+      def log_concise msg, report = false
+        buf = "#{Time.now.strftime('%Y-%m-%d %H:%M:%S %Z')} | #{msg}\n"
+        path = File.join RAILS_ROOT, 'log', rails_env
+
+        File.open("#{path}.concise.log", 'a') {|f| f << buf }
+        File.open("#{path}.report.log", 'a') {|f| f << buf } if report
+
+        nil
+      end
+
+      def report *args
+        opts = args.extract_options!
+        log *(args << opts.merge(:report => true, :skip => (opts[:skip] || 0) + 1))
+        log caller.remove_framework_backtrace.join("\n")
+      end
+
+      def dlog *args
+        unless production?
+          opts = args.extract_options!
+          log *(args << opts.merge(:skip => (opts[:skip] || 0) + 1))
+        end
+      end
+
+      def log_fail *args
+        log *(args << opts.merge(:skip => (opts[:skip] || 0) + 1))
+        false
+      end
+
+      def log *args
+        opts = {
+          :skip => 0
+        }.merge(args.extract_options!)
+
+        msg = if opts[:error]
+          "#{ErrorPrefix}: #{opts[:error]}"
+        elsif args.first.is_a? String
+          args.first
+        elsif args.all? {|i| i.is_a?(ActiveRecord::Base) }
+          @errorModels = args unless opts[:errorModels] == false
+          args.map {|record| "#{record.inspect}: #{record.errors.full_messages.inspect}" }.join(', ')
+        else
+          args.map(&:inspect).join(', ')
+        end
+
+        msg.colorize!('on red') if opts[:error] || opts[:report]
+
+        callpoint = caller[opts[:skip]].sub(rails_root.end_with('/'), '')
+        entry = "#{callpoint}#{msg.blank? ? (opts[:report] ? ' <-- something broke here' : '.') : ' | '}#{msg}"
+
+        logger.send opts[:error].blank? ? :info : :error, entry # Write to the Rails log
+        log_concise entry, opts[:report] # Also write to the concise log
+      end
+
+    end
+  end
+end