keynote 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log
+gemfiles

data/.yardopts

@@ -0,0 +1,4 @@
+--markup markdown
+--no-private
+--exclude lib/generators
+--exclude keynote/testing

data/Appraisals

@@ -0,0 +1,20 @@
+appraise "rails30" do
+  gem "rails", "3.0.15"
+end
+
+appraise "rails31" do
+  gem "rails", "3.1.6"
+end
+
+appraise "rails32" do
+  gem "rails", "3.2.6"
+end
+
+appraise "rails4" do
+  gem "rails",
+    :git => "git@github.com:rails/rails.git"
+  gem "activerecord-deprecated_finders",
+    :git => "git@github.com:rails/activerecord-deprecated_finders"
+  gem "journey",
+    :git => "git@github.com:rails/journey"
+end

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in keynote.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2012 Ryan Fitzgerald
+
+Includes a modified version of Rumble, which is (c) 2011 Magnus Holm.
+
+Some Rails integration code inspired by Draper, which is (c) 2011-2012 Jeff
+Casimir and other contributors.
+
+MIT License
+
+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,8 @@
+## Keynote
+
+Presenters for Rails.
+
+### TODO
+
+* Generators.
+* Documentation.

data/Rakefile

@@ -0,0 +1,17 @@
+#!/usr/bin/env rake
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "appraisal"
+require "yard"
+
+Rake::TestTask.new do |t|
+  t.libs.concat %w(keynote spec)
+  t.pattern = "spec/*_spec.rb"
+end
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb']
+end
+
+task :default => [:test]

data/keynote.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/keynote/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ryan Fitzgerald"]
+  gem.email         = ["rwfitzge@gmail.com"]
+  gem.description   = %q{}
+  gem.summary       = %q{}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "keynote"
+  gem.require_paths = ["lib"]
+  gem.version       = Keynote::VERSION
+
+  gem.add_dependency 'rails', '>= 3.0.0'
+
+  gem.add_development_dependency 'appraisal'
+  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'mocha'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'redcarpet'
+  gem.add_development_dependency 'yard'
+end

data/lib/generators/presenter_generator.rb

@@ -0,0 +1,70 @@
+# encoding: UTF-8
+
+module Rails::Generators
+  class PresenterGenerator < Rails::Generators::NamedBase
+    desc "This generator creates a Keynote::Presenter subclass in " \
+        "app/presenters."
+
+    argument :targets, :type => :array, :default => []
+
+    check_class_collision :suffix => 'Presenter'
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_presenter_file
+      template 'keynote_presenter.rb',
+        File.join('app/presenters', class_path, "#{file_name}_presenter.rb")
+    end
+
+    def create_test_file
+      case Rails.application.config.generators.rails[:test_framework]
+      when :rspec
+        template 'keynote_rspec.rb', rspec_path
+      when :test_unit
+        template 'keynote_test_unit.rb', test_unit_path
+      when :mini_test
+        if Rails.application.config.generators.mini_test[:spec]
+          template 'keynote_mini_test_spec.rb', mini_test_path
+        else
+          template 'keynote_mini_test_unit.rb', mini_test_path
+        end
+      end
+    end
+
+    private
+
+    def rspec_path
+      File.join(
+        'spec/presenters', class_path, "#{file_name}_presenter_spec.rb")
+    end
+
+    def test_unit_path
+      File.join(
+        'test/unit/presenters', class_path, "#{file_name}_presenter_test.rb")
+    end
+
+    def mini_test_path
+      File.join(
+        'test/presenters', class_path, "#{file_name}_presenter_test.rb")
+    end
+
+    def target_list
+      targets.map { |t| ":#{t}" }.join(', ')
+    end
+
+    def view_and_target_list
+      if targets.any?
+        ['view', target_list].join(', ')
+      else
+        'view'
+      end
+    end
+
+    if ::Rails.version.to_f < 3.1
+      protected
+      # This methods doesn't exist in Rails 3.0
+      def module_namespacing
+        yield if block_given?
+      end
+    end
+  end
+end

data/lib/generators/templates/keynote_mini_test_spec.rb

@@ -0,0 +1,11 @@
+require "minitest_helper"
+
+describe <%= class_name %>Presenter do
+  before do
+    @presenter = <%= class_name %>Presenter.new(<%= view_and_target_list %>)
+  end
+
+  # it "must be a real test" do
+  #   flunk "Need real tests"
+  # end
+end

data/lib/generators/templates/keynote_mini_test_unit.rb

@@ -0,0 +1,11 @@
+require 'minitest_helper'
+
+class <%= class_name %>PresenterTest < Keynote::MiniTest::TestCase
+  setup do
+    @presenter = <%= class_name %>Presenter.new(<%= view_and_target_list %>)
+  end
+
+  # test "the truth" do
+  #   assert true
+  # end
+end

data/lib/generators/templates/keynote_presenter.rb

@@ -0,0 +1,7 @@
+<% module_namespacing do -%>
+class <%= class_name %>Presenter < Keynote::Presenter
+<% if targets.any? -%>
+  presents <%= target_list %>
+<% end -%>
+end
+<% end -%>

data/lib/generators/templates/keynote_rspec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe <%= class_name %>Presenter do
+  subject { <%= class_name %>Presenter.new(<%= view_and_target_list %>) }
+end

data/lib/generators/templates/keynote_test_unit.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class <%= class_name %>PresenterTest < Keynote::TestCase
+  setup do
+    @presenter = <%= class_name %>Presenter.new(<%= view_and_target_list %>)
+  end
+
+  # test "the truth" do
+  #   assert true
+  # end
+end

data/lib/keynote.rb

@@ -0,0 +1,65 @@
+# encoding: UTF-8
+
+require "keynote/version"
+require "keynote/rumble"
+require "keynote/presenter"
+require "keynote/controller"
+require "keynote/helper"
+require "keynote/railtie"
+require "keynote/cache"
+
+module Keynote
+  class << self
+    # Create or retrieve a presenter wrapping zero or more objects.
+    #
+    # The first parameter is a Rails view context, but you'll usually access
+    # this method through `Keynote::Helper#present`,
+    # `Keynote::Controller#present`, or `Keynote::Presenter#present`, all of
+    # which handle the view context parameter automatically.
+    #
+    # @see Keynote::Helper#present
+    # @see Keynote::Controller#present
+    # @see Keynote::Presenter#present
+    #
+    # @overload present(*objects)
+    #   Return a presenter wrapping the given objects. The type of the
+    #   presenter will be inferred from the type of the first object.
+    #   @example
+    #     present(view, MyModel.new)           # => #<MyModelPresenter:0x0001>
+    #   @param [ActionView::Base] view
+    #   @param [Array] objects
+    #   @return [Keynote::Presenter]
+    #
+    # @overload present(view, presenter_name, *objects)
+    #   Return a presenter wrapping the given objects. The type of the
+    #   presenter is specified in underscore form by the first parameter.
+    #   @example
+    #     present(view, :foo_bar, MyModel.new) # => #<FooBarPresenter:0x0002>
+    #   @param [ActionView::Base] view
+    #   @param [Symbol] presenter_name
+    #   @param [Array] objects
+    #   @return [Keynote::Presenter]
+    #
+    def present(view, *objects)
+      if objects[0].is_a?(Symbol)
+        name = objects.shift
+      else
+        name = presenter_name_from_object(objects[0])
+      end
+
+      Cache.fetch(name, view, *objects) do
+        presenter_from_name(name).new(view, *objects)
+      end
+    end
+
+    private
+
+    def presenter_name_from_object(object)
+      object.class.to_s.underscore
+    end
+
+    def presenter_from_name(name)
+      "#{name.to_s.camelize}Presenter".constantize
+    end
+  end
+end

data/lib/keynote/cache.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+module Keynote
+  # `Keynote::Cache` memoizes presenter instances, reducing the overhead of
+  # calling `Keynote.present` repeatedly with the same parameters.
+  module Cache
+  end
+
+  class << Cache
+    # Return a cached presenter for the given parameters, or yield and cache
+    # the block's return value for next time.
+    #
+    # The cached presenters are stored in an instance variable on the first of
+    # the given objects, so they'll be garbage-collected when the associated
+    # models go out of scope.
+    #
+    # @param [Symbol] name
+    # @param [ActionView::Base] view
+    # @param [Array] objects
+    # @return [Keynote::Presenter]
+    def fetch(name, view, *objects)
+      first = objects.shift
+
+      # If this is a zero-object presenter, we have to just instantiate it.
+      if first.nil?
+        return(yield)
+      end
+
+      # Otherwise, we can initialize our cache on the first of the presented
+      # objects.
+      if (cache = first.instance_variable_get(:@_keynote_cache)).nil?
+        cache = {}
+        first.instance_variable_set(:@_keynote_cache, cache)
+      end
+
+      # We key each entry by the name of the presenter and the object_id of
+      # each of the other objects involved.
+      key = [name, *objects.map(&:object_id)]
+
+      # If we're using a cached presenter, update the view to match the one the
+      # user passed in (in case the presenter was originally instantiated in
+      # the controller or whatever).
+      if (presenter = cache[key])
+        presenter.view = view
+      else
+        presenter  = yield
+        cache[key] = presenter
+      end
+
+      presenter
+    end
+  end
+end

data/lib/keynote/controller.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+module Keynote
+  # `Keynote::Controller` is mixed into `ActionController::Base` and
+  # `ActionMailer::Base`, providing a `present` method for instantiating
+  # presenters.
+  module Controller
+    # Instantiate a presenter.
+    # @see Keynote.present
+    def present(*objects)
+      Keynote.present(view_context, *objects)
+    end
+  end
+end

data/lib/keynote/helper.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+module Keynote
+  # `Keynote::Helper` is mixed into `ActionView::Base`, providing a `present`
+  # method (aliased to `p`) for instantiating presenters.
+  module Helper
+    # Instantiate a presenter.
+    # @see Keynote.present
+    def present(*objects)
+      Keynote.present(self, *objects)
+    end
+    alias p present
+  end
+end

data/lib/keynote/presenter.rb

@@ -0,0 +1,90 @@
+# encoding: UTF-8
+
+module Keynote
+  class Presenter
+    include Keynote::Rumble
+
+    class << self
+      # Define the names and number of the objects presented by this class.
+      # This replaces the default one-parameter constructor with one that takes
+      # an extra parameter for each presented object.
+      #
+      # @param [Array<Symbol>] objects One symbol for each of the models that
+      #   will be required to instantiate this presenter. Each symbol will be
+      #   used as the accessor and instance variable name for its associated
+      #   parameter, but an object of any class can be given for any parameter.
+      #
+      # @example
+      #   class PostPresenter
+      #     presents :blog_post, :author
+      #   end
+      #
+      #   # In a view
+      #   presenter = p(:post, @some_post, @some_user)
+      #   presenter.blog_post # == @some_post
+      #   presenter.author    # == @some_user
+      #
+      def presents(*objects)
+        objects.unshift :view
+        attr_reader *objects
+
+        param_list = objects.join(', ')
+        ivar_list  = objects.map { |o| "@#{o}" }.join(', ')
+
+        class_eval <<-RUBY
+          def initialize(#{param_list})  # def initialize(view, foo)
+            #{ivar_list} = #{param_list} #   @view, @foo = view, foo
+          end                            # end
+        RUBY
+      end
+    end
+
+    # @private (used by Keynote::Cache to keep the view context up-to-date)
+    attr_writer :view
+
+    # Create a presenter. The default constructor takes one parameter, but
+    # calling `presents` replaces it with a generated constructor.
+    # @param [ActionView::Base] view_context
+    # @see Keynote::Presenter.presents
+    def initialize(view_context)
+      @view = view_context
+    end
+
+    # Instantiate another presenter.
+    # @see Keynote.present
+    def present(*objects)
+      Keynote.present(@view, *objects)
+    end
+    alias p present
+
+    # @private
+    def respond_to_missing?(method_name, include_private = true)
+      @view.respond_to?(method_name, true)
+    end
+
+    # Presenters proxy unknown method calls to the view context, allowing you
+    # to call `h`, `link_to`, and anything else defined in a helper module.
+    #
+    # @example
+    #   def title_link
+    #     link_to blog_post_url(blog_post) do
+    #       "#{h author.name} &mdash; #{h blog_post.title}".html_safe
+    #     end
+    #   end
+    def method_missing(method_name, *args, &block)
+      if @view.respond_to?(method_name, true)
+        @view.send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    private
+
+    # We have to explicitly proxy `#capture` because ActiveSupport creates a
+    # `Kernel#capture` method.
+    def capture(*args, &block)
+      @view.capture(*args, &block)
+    end
+  end
+end