display_case 0.0.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2012 Avdi Grimm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,4 @@
+display_case
+============
+
+An implementation of the Exhibit pattern, as described in Objects on Rails

data/lib/display_case/enumerable_exhibit.rb

@@ -0,0 +1,53 @@
+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
+
+  # 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
+  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
+
+  def each(*)
+    super do |e|
+      yield exhibit(e)
+    end
+  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
+
+end

data/lib/display_case/exhibit.rb

@@ -0,0 +1,129 @@
+require 'delegate'
+require 'active_support/core_ext'
+
+class Exhibit < SimpleDelegator
+  def self.exhibits
+    [
+     EnumerableExhibit,
+     BlogExhibit,
+     TextPostExhibit,
+     PicturePostExhibit,
+     LinkExhibit,
+     TagListExhibit
+    ]
+  end
+
+  def self.exhibit(object, context)
+    return object if exhibited_object?(object)
+    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
+
+  def self.exhibit_if_applicable(object, context)
+    if applicable_to?(object)
+      new(object, context)
+    else
+      object
+    end
+  end
+
+  def self.applicable_to?(object)
+    false
+  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))
+      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?
+
+  attr_reader :context
+
+  def initialize(model, context)
+    @context = context
+    super(model)
+  end
+
+  alias_method :__class__, :class
+  def class
+    __getobj__.class
+  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)
+    end
+  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 inspect_exhibits
+    exhibit_chain.map(&:to_s).join(':')
+  end
+
+  def inspect
+    "#{inspect_exhibits}(#{__getobj__.inspect})"
+  end
+
+  def exhibited?
+    true
+  end
+
+  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
+
+    def to_model
+      __getobj__
+    end
+  end
+
+  def partialize_name(name)
+    "/#{name.underscore.pluralize}/#{name.demodulize.underscore}"
+  end
+end

data/lib/display_case/exhibits_helper.rb

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

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: display_case
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Avdi Grimm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-17 00:00:00.000000000Z
+dependencies: []
+description: An implementation of the Exhibit pattern, as described in Objects on
+  Rails
+email:
+- sam@codeodor.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/display_case/enumerable_exhibit.rb
+- lib/display_case/exhibit.rb
+- lib/display_case/exhibits_helper.rb
+- lib/display_case.rb
+- LICENSE
+- README.md
+homepage: https://github.com/objects-on-rails/display-case
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: An implementation of the Exhibit pattern, as described in Objects on Rails
+test_files: []