assaf-presenter 0.1.0

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rake/gempackagetask'
+
+
+spec = Gem::Specification.load(File.join(File.dirname(__FILE__), 'presenter.gemspec'))
+
+task 'setup' do
+end
+
+
+package = Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+desc "Install the package locally"
+task 'install'=>['setup', 'package'] do |task|
+  system 'sudo', 'gem', 'install', "pkg/#{spec.name}-#{spec.version}.gem"
+end
+
+desc "Uninstall previously installed packaged"
+task 'uninstall' do |task|
+  system 'sudo', 'gem', 'uninstall', spec.name, '-v', spec.version.to_s
+end

data/lib/presenter.rb

@@ -0,0 +1,9 @@
+require 'presenter/method'
+require 'presenter/base'
+require 'presenter/rspec'
+
+[ActionController::Base, ActionView::Base].each do |mod|
+  mod.class_eval do
+    protected ; include Presenter::PresentingMethod
+  end
+end

data/lib/presenter/base.rb

@@ -0,0 +1,115 @@
+module Presenter
+  class Base
+    
+    class << self
+      # Item name, derived from the class name (e.g. TaskPresenter becomes 'task').
+      # Used for the XML document element name, also name of the accessor method used
+      # to read the presented object.
+      attr_reader :item_name
+
+      # Array name, derived from the class name (e.g. TaskPresenter becomes 'tasks').
+      # Used for the XML document element name, also name of the accessor method used
+      # to read the presented array of objects.
+      attr_reader :array_name
+
+      def inherited(klass)
+        name = klass.name[/(.*?)(Presenter)?$/, 1].underscore
+        klass.instance_variable_set(:@item_name, name)
+        klass.class_eval "def #{klass.item_name} ; @item ; end"
+        klass.instance_variable_set(:@array_name, name.pluralize)
+        klass.class_eval "def #{klass.array_name} ; @array ; end"
+      end
+      
+    end
+
+    # Creates new presenter using the given controller and item/array.
+    def initialize(controller, value)
+      @controller = controller
+      if value.is_a?(Array)
+        @array = value
+      else
+        @item = value
+      end
+    end
+
+    include PresentingMethod
+    
+    # Controller associated with this presenter. Used primarily to create URLs
+    # and access various helper methods.
+    attr_reader :controller
+
+    # Item being presented. This accessor has a value when presenting a single
+    # object, for arrays see #array. Can also be accessed from named attribute,
+    # e.g. the #task method on TaskPresenter.
+    attr_reader :item
+
+    # Array being presented. This accessor has a value when presenting an array
+    # of objects, for single item see #item. Can also be accessed from named attribute,
+    # e.g. the #tasks method on TaskPresenter.
+    attr_reader :array    
+
+    # Converts to JSON document, returns a String.  The default implementation
+    # uses #map to convert the instance or each member of the array, and calls
+    # #to_json on the result.
+    #
+    # For example:
+    #   render :json=>presenting(@item)
+    def to_json(options = {})
+      @array ? @array.map { |i| hash_for(i) }.to_json(options) :
+               hash_for(@item).to_json(options)
+    end
+
+    # Converts to XML document, returns a String.  The default implementation
+    # uses #map to convert the instance or each member of the array, and calls
+    # #to_xml on the result.
+    #
+    # For example:
+    #   render :xml=>presenting(@items)
+    def to_xml(options = {})
+      @array ? @array.map { |i| hash_for(i) }.to_xml({:root=>self.class.array_name}.merge(options)) :
+               hash_for(@item).to_xml({:root=>self.class.item_name}.merge(options))
+    end
+    
+  protected
+  
+    # Shortcut for CGI::escapeHTML.
+    def h(text)
+      CGI::escapeHTML(text)
+    end
+
+    include ActionController::UrlWriter
+    # TODO: do we need this?
+    # default_url_options[:host] = 'test.host' if defined?(RAILS_ENV) && RAILS_ENV == 'test'
+
+    def url_for_with_controller(*args)
+      if controller
+        controller.url_for(*args)
+      else
+        url_for_without_controller(*args)
+      end
+    end
+    alias_method_chain :url_for, :controller
+
+    # Request to which this controller is responding.
+    def request
+      controller && controller.request
+    end
+    
+    # Converts object into a hash.  JSON, XML and other output formats use this
+    # before serializing the result into the respective content type.
+    #
+    # Override to do all sorts of fancy tricks.  The defult implementation calls
+    # the attributes methods (works on ActiveRecord models), lacking that the to_hash
+    # method, and if neither is found return an empty hash.
+    def hash_for(object)
+      object.respond_to?(:attributes) && object.attributes ||
+        object.respond_to?(:to_hash) && object.to_hash || {}
+    end
+    
+    # Returns an ID using the host name, object class and object identifier.
+    def id_for(object)
+      "tag:#{request.host}:#{object.class.underscore}/#{object.id}"
+    end
+  
+  end
+end

data/lib/presenter/method.rb

@@ -0,0 +1,46 @@
+module Presenter 
+  module PresentingMethod
+
+    # Return a new presenter. This method can be called in several configurations to
+    # present both an instance and an array:
+    #
+    # You can call this method in several configurations to present both singular objects
+    # and arrays. Using an explicit type followed by value:
+    #   presenting(class, object_or_array)
+    # The first argument specifies the expected type of the object/array that follows,
+    # and that argument is used to find the presenter class. For example, <tt>presenting(Foo,[])<tt>
+    # uses <tt>FooPresenter</tt>.
+    #   presenting(symbol, object_or_array)
+    # This method is similar but replaces explicit class with symbol, so <tt>foo:<tt> instead
+    # of <tt>Foo</tt>.
+    #   presenting(object)
+    # The third form takes a single argument and finds the presenter class based on the
+    # argument type, for example, <tt>presenting(Foo.new)</tt> will use the presenter class
+    # <tt>FooPresenter</tt>.
+    #   presenting(array)
+    # Since arrays may be empty it is not always possible to use the array content to figure
+    # out the presenter class. Either specify it explicitly as the first argument (see above),
+    # or let the presenting method figure it out from the controller name, for example,
+    # inferring <tt>FooPresenter</tt> from <tt>FooController</tt>.
+    def presenting(*args)
+      controller = ActionController::Base === self ? self : self.controller
+      case args.first
+      when Class    # Presented class followed by instance/array
+        name = args.shift.to_s
+        value = args.shift
+      when Symbol   # Presenter name (symbol) followed by instance/array
+        name = args.shift.to_s.capitalize
+        value = args.shift
+      when Array    # Array of values, pick presenter from item type
+        value = args.shift
+        name = controller.class.to_s.gsub(/Controller$/, '').classify
+      else          # Presenter for single instance.
+        value = args.shift
+        name = value.class.name
+      end
+      raise ArgumentError, "Unexpected arguments #{args.inspect}" unless args.empty?
+      Class.const_get("#{name}Presenter").new(controller, value)
+    end
+
+  end
+end

data/lib/presenter/rspec.rb

@@ -0,0 +1,33 @@
+module Spec
+  module Rails
+    module Matchers
+      
+      class PresentMatcher
+        def initialize(presenter, format)
+          @presenter = presenter
+          @format = format
+        end
+
+        def matches?(response)
+          @expect = response.body
+          @actual = @presenter.send("to_#{@format.to_sym}")
+          @actual == @expect
+        end
+
+        def failure_message
+          "Expected #{@expect.inspect}, found #{@actual.inspect}"
+        end
+
+        def negative_failure_message
+          "Found unexpected #{@actual.inspect}"
+        end
+      end
+      
+      include Presenter::PresentingMethod
+      
+      def present(*args)
+        PresentMatcher.new(presenting(*args), request.format)
+      end
+    end
+  end
+end

data/presenter.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |spec|
+  spec.name           = 'presenter'
+  spec.version        = '0.1.0'
+  spec.author         = 'Rails Presenter'
+  spec.email          = 'assaf@labnotes.org'
+  spec.homepage       = "http://github.com/assaf/#{spec.name}"
+  spec.summary        = "Add later ..." # TODO
+
+  spec.files          = Dir['lib/**/*', 'rails/**/*', 'README', 'CHANGELOG', 'MIT-LICENSE', 
+                            '*.gemspec', 'Rakefile', 'spec/**/*', 'doc/**/*']
+  spec.require_paths  = 'lib'
+
+  spec.has_rdoc           = true
+  spec.extra_rdoc_files   = 'README', 'CHANGELOG', 'MIT-LICENSE'
+  spec.rdoc_options       = '--title', spec.name,
+                            '--main', 'README', '--line-numbers', '--inline-source',
+                            '--webcvs', "#{spec.homepage}/tree/master"
+  spec.rubyforge_project  = spec.name
+
+  # Tested against these dependencies.
+  spec.add_dependency 'rails'
+end

data/rails/init.rb

@@ -0,0 +1,9 @@
+path = "#{Rails.root}/app/presenters"
+# That way we're able to use everything in app/presenters.
+ActiveSupport::Dependencies.load_paths << path
+unless File.exist?(path)
+  puts "Creating #{path}"
+  Dir.mkdir path
+end
+
+require 'presenter'

data/spec/helper.rb

@@ -0,0 +1,15 @@
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path(File.dirname(__FILE__) + "/../../../../config/environment")
+require 'spec/rails'
+
+# Object being presented.
+class Foo
+end
+
+# Presenter for Foo.
+class FooPresenter < Presenter::Base
+end
+
+# Test controller, using similar name so we can deduct presenter from controller.
+class FooController < ApplicationController
+end

data/spec/presenter_spec.rb

@@ -0,0 +1,73 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+
+describe 'Presenter', :type=>:controller do
+  controller_name :foo
+
+  it 'should derive item name from class name' do
+    FooPresenter.item_name.should == 'foo'
+  end
+  
+  it 'should derive array name from element name' do
+    FooPresenter.array_name.should == 'foos'
+  end
+  
+  it 'should have accessor for controller' do
+    presenting(Foo.new).controller.should == controller
+  end
+
+  describe '(instance)' do
+    before { @presenter = presenting(@item = Foo.new) }
+
+    it 'should provide object from #item accessor' do
+      @presenter.item.should == @item
+    end
+    
+    it 'should provide object from (item) accessor' do
+      @presenter.foo.should == @item
+    end
+    
+    it 'should provide nothing from #array accessor' do
+      @presenter.array.should be_nil
+    end
+    
+    it 'should use hash_for(instance) for to_json' do
+      @presenter.should_receive(:hash_for).with(@item).and_return('bar'=>'beer')
+      @presenter.to_json.should == %{{"bar": "beer"}}
+    end
+
+    it 'should use hash_for(instance) for to_xml with model name' do
+      @presenter.should_receive(:hash_for).with(@item).and_return('bar'=>'beer')
+      @presenter.to_xml(:indent=>0).should == %{<?xml version=\"1.0\" encoding=\"UTF-8\"?><foo><bar>beer</bar></foo>}
+    end
+    
+  end
+
+  describe '(array)' do
+    before { @presenter = presenting(@array = [Foo.new, Foo.new]) }
+    
+    it 'should provide array from #array accessor' do
+      @presenter.array.should == @array
+    end
+    
+    it 'should provide array from (array) accessor' do
+      @presenter.foos.should == @array
+    end
+    
+    it 'should provide nothing from #item accessor' do
+      @presenter.item.should be_nil
+    end
+    
+    it 'should use array.map(hash_for) for to_json' do
+      @presenter.should_receive(:hash_for).twice.and_return({'bar'=>1}, {'bar'=>2})
+      @presenter.to_json.should == %{[{"bar": 1}, {"bar": 2}]}
+    end
+
+    it 'should use hash_for(instance) for to_xml with model name' do
+      @presenter.should_receive(:hash_for).twice.and_return({'bar'=>1}, {'bar'=>2})
+      @presenter.to_xml(:indent=>0, :types=>false).should == %{<?xml version=\"1.0\" encoding=\"UTF-8\"?><foos type="array"><foo><bar type="integer">1</bar></foo><foo><bar type="integer">2</bar></foo></foos>}
+    end
+    
+  end
+
+end

data/spec/presenting_method_spec.rb

@@ -0,0 +1,111 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+
+describe 'presenting', :type=>:controller do
+  controller_name :foo
+  
+  it 'should be available on controller' do
+    ApplicationController.instance_method(:presenting).to_s.should =~ /presenting/
+  end
+  
+  it 'should be available on view' do
+    ActionView::Base.instance_method(:presenting).to_s.should =~ /presenting/
+  end
+  
+  it 'should be available on presenter' do
+    FooPresenter.instance_method(:presenting).to_s.should =~ /presenting/
+  end
+  
+  describe '(class,instance)' do
+    it 'should guess presenter type from class' do
+      presenting(Foo, 1).should be_kind_of(FooPresenter)
+    end
+    
+    it 'should return presenter for instance' do
+      presenting(Foo, 1).item.should == 1
+    end
+  end
+
+  describe '(class,array)' do
+    it 'should guess presenter type from class' do
+      presenting(Foo, [1, 2]).should be_kind_of(FooPresenter)
+    end
+    
+    it 'should return presenter for array' do
+      presenting(Foo, [1, 2]).array.should == [1, 2]
+    end
+  end
+
+  describe '(symbol,instance)' do
+    it 'should guess presenter type from symbol' do
+      presenting(:foo, 1).should be_kind_of(FooPresenter)
+    end
+    
+    it 'should return presenter for instance' do
+      presenting(:foo, 1).item.should == 1
+    end
+  end
+
+  describe '(symbol,array)' do
+    it 'should guess presenter type from class' do
+      presenting(:foo, [1, 2]).should be_kind_of(FooPresenter)
+    end
+    
+    it 'should return presenter for array' do
+      presenting(:foo, [1, 2]).array.should == [1, 2]
+    end
+  end
+
+  describe '(instance)' do
+    before { @instance = Foo.new }
+
+    it 'should guess presenter type from value' do
+      presenting(@instance).should be_kind_of(FooPresenter)
+    end
+    
+    it 'should return presenter for instance' do
+      presenting(@instance).item.should == @instance
+    end
+    
+    it 'should fail if value is nil' do
+      lambda { presenting(nil) }.should raise_error(NameError)
+    end
+  end
+
+  describe '(array)' do
+    before { @array = [Foo.new, Foo.new] }
+
+    it 'should guess presenter type from controller' do
+      presenting(@array).should be_kind_of(FooPresenter)
+    end
+    
+    it 'should return presenter for array' do
+      presenting(@array).array.should == @array
+    end
+  end
+
+  describe '(empty array)' do
+    before { @empty = [] }
+
+    it 'should guess presenter type from controller' do
+      presenting(@empty).should be_kind_of(FooPresenter)
+    end
+    
+    it 'should return presenter for empty array' do
+      presenting(@empty).array.should be_empty
+    end
+  end
+
+  it 'should use context as controller if context is controller' do
+    controller.presenting([]).controller.should == controller
+  end
+  
+  it 'should borrow controller from context if context is not controller' do
+    presenting([]).controller.should == controller
+  end
+  
+  it 'should fail if passed too many arguments' do
+    lambda { presenting(:foo, [], :bar) }.should raise_error(ArgumentError)
+  end
+  
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: assaf-presenter
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Rails Presenter
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-13 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: assaf@labnotes.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGELOG
+- MIT-LICENSE
+files: 
+- lib/presenter.rb
+- lib/presenter
+- lib/presenter/rspec.rb
+- lib/presenter/base.rb
+- lib/presenter/method.rb
+- rails/init.rb
+- README
+- CHANGELOG
+- MIT-LICENSE
+- presenter.gemspec
+- Rakefile
+- spec/presenting_method_spec.rb
+- spec/presenter_spec.rb
+- spec/helper.rb
+has_rdoc: true
+homepage: http://github.com/assaf/presenter
+post_install_message: 
+rdoc_options: 
+- --title
+- presenter
+- --main
+- README
+- --line-numbers
+- --inline-source
+- --webcvs
+- http://github.com/assaf/presenter/tree/master
+require_paths: lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: presenter
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Add later ...
+test_files: []
+