display_case 0.0.1 → 0.0.2

data/README.md

@@ -31,7 +31,7 @@ Your exhibits will look something like this:
 ``` ruby
 # app/exhibits/league_exhibit.rb
 
-class LeagueExhibit < Exhibit
+class LeagueExhibit < DisplayCase::Exhibit
   def self.applicable_to?(object)
     object.class.name == 'League'
   end
@@ -46,6 +46,7 @@ Then in your controller, where you're instantiating a League, wrap it in a call
 ``` ruby
 # app/controllers/leagues_controller.rb
 class LeaguesController < ApplicationController
+  include DisplayCase::ExhibitsHelper
   # ...
   def index
     # display_case automatically wraps the individual objects contained in 

data/lib/display_case/enumerable_exhibit.rb

@@ -1,53 +1,55 @@
 require_relative 'exhibit'
 
-class EnumerableExhibit < Exhibit
-  include Enumerable
-
-  def self.applicable_to?(object)
-    # ActiveRecord::Relation, surprisingly, is not Enumerable. But it
-    # behaves sufficiently similarly for our purposes.
-    object_is_any_of?(object, 'Enumerable', 'ActiveRecord::Relation')
-  end
+module DisplayCase
+  class EnumerableExhibit < Exhibit
+    include Enumerable
+
+    def self.applicable_to?(object)
+      # ActiveRecord::Relation, surprisingly, is not Enumerable. But it
+      # behaves sufficiently similarly for our purposes.
+      object_is_any_of?(object, 'Enumerable', 'ActiveRecord::Relation')
+    end
 
-  # Wrap an Enumerable method which returns another collection
-  def self.exhibit_enum(*method_names, &post_process)
-    post_process ||= ->(result){exhibit(result)}
-    method_names.each do |method_name|
-      define_method(method_name) do |*args, &block|
-        result = __getobj__.public_send(method_name, *args, &block)
-        instance_exec(result, &post_process)
+    # Wrap an Enumerable method which returns another collection
+    def self.exhibit_enum(*method_names, &post_process)
+      post_process ||= ->(result){exhibit(result)}
+      method_names.each do |method_name|
+        define_method(method_name) do |*args, &block|
+          result = __getobj__.public_send(method_name, *args, &block)
+          instance_exec(result, &post_process)
+        end
       end
     end
-  end
-  private_class_method :exhibit_enum
+    private_class_method :exhibit_enum
 
-  exhibit_query :[], :fetch, :slice, :values_at, :last
-  exhibit_enum :select, :grep, :reject, :to_enum, :sort, :sort_by, :reverse
-  exhibit_enum :partition do |result|
-    result.map{|group| exhibit(group)}
-  end
-  exhibit_enum :group_by do |result|
-    result.inject({}) { |h,(k,v)|
-      h.merge!(k => exhibit(v))
-    }
-  end
+    exhibit_query :[], :fetch, :slice, :values_at, :last
+    exhibit_enum :select, :grep, :reject, :to_enum, :sort, :sort_by, :reverse
+    exhibit_enum :partition do |result|
+      result.map{|group| exhibit(group)}
+    end
+    exhibit_enum :group_by do |result|
+      result.inject({}) { |h,(k,v)|
+        h.merge!(k => exhibit(v))
+      }
+    end
 
-  def each(*)
-    super do |e|
-      yield exhibit(e)
+    def each(*)
+      super do |e|
+        yield exhibit(e)
+      end
     end
-  end
 
-  # `render '...', :collection => self` will call #to_ary on this
-  # before rendering, so we need to be prepared.
-  def to_ary
-    self
-  end
+    # `render '...', :collection => self` will call #to_ary on this
+    # before rendering, so we need to be prepared.
+    def to_ary
+      self
+    end
 
-  def render(template)
-    inject(ActiveSupport::SafeBuffer.new) { |output,element|
-      output << element.render(template)
-    }
-  end
+    def render(template)
+      inject(ActiveSupport::SafeBuffer.new) { |output,element|
+        output << element.render(template)
+      }
+    end
 
+  end
 end

data/lib/display_case/exhibit.rb

@@ -2,129 +2,131 @@ require 'delegate'
 require 'active_support/core_ext'
 require 'display_case/railtie' if defined?(Rails)
 
-class Exhibit < SimpleDelegator
-  @@exhibits = []
+module DisplayCase
+  class Exhibit < SimpleDelegator
+    @@exhibits = []
   
-  def self.exhibits
-    @@exhibits
-  end
+    def self.exhibits
+      @@exhibits
+    end
   
-  def self.inherited(child)
-    @@exhibits << child
-  end
+    def self.inherited(child)
+      @@exhibits << child
+    end
 
-  def self.exhibit(object, context)
-    return object if exhibited_object?(object)
-    Rails.logger.debug "Registered exhibits: #{@@exhibits}"
-    Rails.logger.debug "Exhibiting #{object.inspect}"
-    Rails.logger.debug "Exhibit context: #{context}"
-    object = Exhibited.new(object, context)
-    exhibits.inject(object) do |object, exhibit_class|
-      exhibit_class.exhibit_if_applicable(object, context)
-    end.tap do |obj|
-      Rails.logger.debug "Exhibits applied: #{obj.inspect_exhibits}"
+    def self.exhibit(object, context)
+      return object if exhibited_object?(object)
+      Rails.logger.debug "Registered exhibits: #{@@exhibits}"
+      Rails.logger.debug "Exhibiting #{object.inspect}"
+      Rails.logger.debug "Exhibit context: #{context}"
+      object = Exhibited.new(object, context)
+      exhibits.inject(object) do |object, exhibit_class|
+        exhibit_class.exhibit_if_applicable(object, context)
+      end.tap do |obj|
+        Rails.logger.debug "Exhibits applied: #{obj.inspect_exhibits}"
+      end
     end
-  end
 
-  def self.exhibit_if_applicable(object, context)
-    if applicable_to?(object)
-      new(object, context)
-    else
-      object
+    def self.exhibit_if_applicable(object, context)
+      if applicable_to?(object)
+        new(object, context)
+      else
+        object
+      end
     end
-  end
 
-  def self.applicable_to?(object)
-    false
-  end
+    def self.applicable_to?(object)
+      false
+    end
 
-  def self.exhibited_object?(object)
-    object.respond_to?(:exhibited?) && object.exhibited?
-  end
+    def self.exhibited_object?(object)
+      object.respond_to?(:exhibited?) && object.exhibited?
+    end
 
-  def self.exhibit_query(*method_names)
-    method_names.each do |name|
-      define_method(name) do |*args, &block|
-        exhibit(super(*args, &block))
+    def self.exhibit_query(*method_names)
+      method_names.each do |name|
+        define_method(name) do |*args, &block|
+          exhibit(super(*args, &block))
+        end
       end
     end
-  end
-  private_class_method :exhibit_query
-
-  # A helper for matching models to classes/modules, intended for use
-  # in .applicable_to?.
-  def self.object_is_any_of?(object, *classes)
-    # What with Rails development mode reloading making class matching
-    # unreliable, plus wanting to avoid adding dependencies to
-    # external class definitions if we can avoid it, we just match
-    # against class/module name strings rather than the actual class
-    # objects.
-
-    # Note that '&' is the set intersection operator for Arrays.
-    (classes.map(&:to_s) & object.class.ancestors.map(&:name)).any?
-  end
-  private_class_method :object_is_any_of?
+    private_class_method :exhibit_query
+
+    # A helper for matching models to classes/modules, intended for use
+    # in .applicable_to?.
+    def self.object_is_any_of?(object, *classes)
+      # What with Rails development mode reloading making class matching
+      # unreliable, plus wanting to avoid adding dependencies to
+      # external class definitions if we can avoid it, we just match
+      # against class/module name strings rather than the actual class
+      # objects.
+
+      # Note that '&' is the set intersection operator for Arrays.
+      (classes.map(&:to_s) & object.class.ancestors.map(&:name)).any?
+    end
+    private_class_method :object_is_any_of?
 
-  attr_reader :context
+    attr_reader :context
 
-  def initialize(model, context)
-    @context = context
-    super(model)
-  end
+    def initialize(model, context)
+      @context = context
+      super(model)
+    end
 
-  alias_method :__class__, :class
-  def class
-    __getobj__.class
-  end
+    alias_method :__class__, :class
+    def class
+      __getobj__.class
+    end
 
-  def exhibit(model)
-    Exhibit.exhibit(model, context)
-  end
+    def exhibit(model)
+      Exhibit.exhibit(model, context)
+    end
 
-  def to_partial_path
-    if __getobj__.respond_to?(:to_partial_path)
-      __getobj__.to_partial_path
-    else
-      partialize_name(__getobj__.class.name)
+    def to_partial_path
+      if __getobj__.respond_to?(:to_partial_path)
+        __getobj__.to_partial_path
+      else
+        partialize_name(__getobj__.class.name)
+      end
     end
-  end
 
-  def render(template)
-    template.render(:partial => to_partial_path, :object => self)
-  end
+    def render(template)
+      template.render(:partial => to_partial_path, :object => self)
+    end
 
-  def exhibit_chain
-    inner_exhibits = defined?(super) ? super : []
-    [__class__] + inner_exhibits
-  end
+    def exhibit_chain
+      inner_exhibits = defined?(super) ? super : []
+      [__class__] + inner_exhibits
+    end
 
-  def inspect_exhibits
-    exhibit_chain.map(&:to_s).join(':')
-  end
+    def inspect_exhibits
+      exhibit_chain.map(&:to_s).join(':')
+    end
 
-  def inspect
-    "#{inspect_exhibits}(#{__getobj__.inspect})"
-  end
+    def inspect
+      "#{inspect_exhibits}(#{__getobj__.inspect})"
+    end
 
-  def exhibited?
-    true
-  end
+    def exhibited?
+      true
+    end
 
-  private
+    private
 
-  # The terminator for the exhibit chain, and a marker that an object
-  # has been through the exhibit process
-  class Exhibited < Exhibit
-    def exhibit_chain
-      []
-    end
+    # The terminator for the exhibit chain, and a marker that an object
+    # has been through the exhibit process
+    class Exhibited < Exhibit
+      def exhibit_chain
+        []
+      end
 
-    def to_model
-      __getobj__
+      def to_model
+        __getobj__
+      end
     end
-  end
 
-  def partialize_name(name)
-    "/#{name.underscore.pluralize}/#{name.demodulize.underscore}"
+    def partialize_name(name)
+      "/#{name.underscore.pluralize}/#{name.demodulize.underscore}"
+    end
   end
-end
+end

data/lib/display_case/exhibits_helper.rb

@@ -1,5 +1,7 @@
-module ExhibitsHelper
-  def exhibit(model, context=self)
-    Exhibit.exhibit(model, context)
+module DisplayCase
+  module ExhibitsHelper
+    def exhibit(model, context=self)
+      Exhibit.exhibit(model, context)
+    end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: display_case
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-23 00:00:00.000000000Z
+date: 2012-05-23 00:00:00.000000000 Z
 dependencies: []
 description: An implementation of the Exhibit pattern, as described in Objects on
   Rails
@@ -47,7 +47,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.8
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: An implementation of the Exhibit pattern, as described in Objects on Rails