active_presenters 1.0.0

data/init.rb

@@ -0,0 +1 @@
+# require 'active_presenters'

data/lib/ac_hooks.rb

@@ -0,0 +1,33 @@
+# module ActionController
+#   class Base
+#     alias_method :ac_render, :render
+#     
+#     def render(options = nil, deprecated_status = nil, &block)
+#       puts "in active_presenter render"
+#       self.instance_variables.each do |v|
+#         puts "v = #{v}"
+#         var = self.instance_variable_get(v)
+#         puts "var = #{var.class}"
+#         puts "var.is_presentable? = #{var.is_presentable?}"
+#         if var.is_presentable?
+#           if var.is_a? Array
+#             presenters = []
+#             var.each do |a|
+#               if a.is_presentable?
+#                 presenter = a.build_presenter(self)
+#                 presenters << presenter
+#               end
+#             end
+#             self.instance_variable_set("#{v.singularize}_presenters".to_sym, presenters)
+#           else
+#             presenter = var.build_presenter(self)
+#             # puts "presenter = #{presenter.inspect}"
+#             self.instance_variable_set("#{v.singularize}_presenter".to_sym, presenter)
+#           end
+#         end
+#       end
+#       ac_render(options, deprecated_status, &block)
+#     end
+#     
+#   end
+# end

data/lib/active_presenters.rb

@@ -0,0 +1,30 @@
+require 'fileutils'
+require 'find'
+path = File.expand_path(RAILS_ROOT + "/app/presenters")
+puts path
+
+FileUtils.mkdir_p(path) unless File.exists?(path)
+
+require 'presentable'
+require 'proxy'
+require 'base'
+
+Find.find(path) do |f|
+  if FileTest.directory?(f) and f =~ /\.svn/
+    Find.prune
+  else
+    if FileTest.file?(f)
+      f.gsub!(path, "")
+      m = f.match(/\/[a-zA\-Z-_]*.rb/)
+      if m
+        model = m.to_s
+        x = model.gsub('/', '').gsub('.rb', '')
+        begin
+          require "#{path}/#{x}"
+        rescue => ex
+          puts ex
+        end
+      end
+    end
+  end
+end

data/lib/ar_hooks.rb

@@ -0,0 +1,13 @@
+# class << ActiveRecord::Base
+#   
+#   alias_method :ar_find, :find
+#   
+#   def find(*args)
+#     res = ar_find(*args)
+#     if res.is_a? Array
+#       res.is_presentable = true
+#     end
+#     res
+#   end
+#   
+# end

data/lib/base.rb

@@ -0,0 +1,142 @@
+module ActivePresenter
+  
+  REST_VERBS = {
+    :index    => :get,
+    :show     => :get,
+    :new      => :get,
+    :create   => :post,
+    :edit     => :get,
+    :update   => :put,
+    :destroy  => :delete
+  }
+  
+  class Base
+
+    include ActionView::Helpers::TagHelper # link_to
+    include ActionView::Helpers::UrlHelper # url_for
+    include ActionController::UrlWriter # named routes
+    include ActionView::Helpers::TextHelper # link_to
+    include ActionView::Helpers::FormHelper
+    include ActionView::Helpers::FormTagHelper
+    include ActionView::Helpers::FormOptionsHelper
+    attr_accessor :options
+    attr_accessor :model_underscore # => debate_side
+    attr_accessor :model_camelcase  # => DebateSide
+
+    def initialize(source, options = {})
+      self.model_underscore = source.class.to_s.underscore
+      self.model_camelcase = source.class.to_s
+      eval %{alias :#{self.model_underscore} :model}
+      @model = source
+      self.options = options || {}
+      if source.is_a? ActiveRecord::Base
+        if source.is_restful?
+          build_common_ar_resource_methods
+          build_ar_resource_methods
+        else
+          #build_ar_non_resource_methods
+        end
+      end
+    end
+    
+    def model
+      @model
+    end
+    
+    protected
+    
+    def build_common_ar_resource_methods
+
+      instance_eval do
+        unless method_defined?(:destroy_link_options)
+          def destroy_link_options
+            {:confirm => 'Are you sure?', :method => :delete}
+          end
+        end
+      end
+
+      REST_VERBS.each_pair do |verb, meth|
+        instance_eval %{
+          unless method_defined?(:#{verb}_link_text)
+            def #{verb}_link_text
+              "#{verb}"
+            end
+          end
+        
+          unless method_defined?(:#{verb}_link_options)
+            def #{verb}_link_options
+              {:method => :#{meth}}
+            end
+          end
+        
+          unless method_defined?(:#{verb}_link)
+            def #{verb}_link(name = #{verb}_link_text, options = {}, html_options = nil, *args)
+              options = #{verb}_link_options.merge(options)
+              link_to(h(name), #{verb}_path, options, html_options, *args)
+            end
+          end
+        }
+      end
+    end
+    
+    def build_ar_resource_methods
+      instance_eval %{
+        unless method_defined?(:index_path)
+          def index_path
+            #{self.plural}_path#{self.model.nested_resource.nil? ? '' : "(self.model.nested_resource)"}
+          end
+        end
+      
+        unless method_defined?(:show_path)
+          def show_path
+            #{self.singular}_path(#{self.model.nested_resource.nil? ? '' : "self.model.nested_resource, "}self.model)
+          end
+        end
+
+        unless method_defined?(:new_path)
+          def new_path
+            new_#{self.singular}_path#{self.model.nested_resource.nil? ? '' : "(self.model.nested_resource)"}
+          end
+        end
+
+        unless method_defined?(:create_path)
+          def create_path
+            #{self.plural}_path#{self.model.nested_resource.nil? ? '' : "(self.model.nested_resource)"}
+          end
+        end
+
+        unless method_defined?(:edit_path)
+          def edit_path
+            edit_#{self.singular}_path(#{self.model.nested_resource.nil? ? '' : "self.model.nested_resource, "}self.model)
+          end
+        end
+
+        unless method_defined?(:update_path)
+          def update_path
+            #{self.singular}_path(#{self.model.nested_resource.nil? ? '' : "self.model.nested_resource, "}self.model)
+          end
+        end
+
+        unless method_defined?(:destroy_path)
+          def destroy_path
+            #{self.singular}_path(#{self.model.nested_resource.nil? ? '' : "self.model.nested_resource, "}self.model)
+          end
+        end
+      }
+    end
+    
+    def plural
+      self.model_underscore.pluralize
+    end
+    
+    def singular
+      self.model_underscore.singularize
+    end
+    
+    def method_defined?(meth)
+      self.methods.include?("#{meth}")
+    end
+    
+  end
+  
+end

data/lib/presentable.rb

@@ -0,0 +1,83 @@
+class Object
+  
+  def is_presentable?
+    false
+  end
+  
+end
+
+module ActivePresenter
+
+  module Presentable
+    
+    module ClassMethods
+      
+      def use_presenter(name = self.class.to_s)
+        name = name.to_s.underscore
+        name << "_presenter" unless name.match(/_presenter/)
+        # puts "name = #{name}"
+        instance_eval do
+          define_method("presenter_name") do
+            name
+          end
+        end
+      end
+      
+    end
+    
+    def self.included(base) # :nodoc:
+      # puts "base = #{base.inspect}"
+      # puts "self = #{self.inspect}"
+      base.extend ClassMethods
+    end
+    
+    def is_presentable?
+      true
+    end
+    
+    def is_restful?
+      return self.is_a? ActiveRecord::Base
+    end
+    
+    attr_accessor :nested_resource
+    
+    def presenter_name
+      unless @presenter_name
+        @presenter_name = self.class.to_s.underscore + "_presenter"
+      end
+      @presenter_name
+    end
+
+    def presenter
+      unless @presenter
+        @presenter = build_presenter(presenter_options)
+      end
+      @presenter
+    end
+
+    def presenter_options
+      {}
+    end
+
+    private
+    def build_presenter(options = {})
+      # puts "build: #{self}, #{options.inspect}"
+      name = self.presenter_name.camelcase
+      begin
+        @presenter = name.constantize.new(self, options)
+      rescue => ex
+        @presenter = ActivePresenter::Base.new(self, options)
+      end
+      puts "built: #{presenter.class.name} for #{self.class.name}"
+      self.presenter
+    end
+    
+  end
+  
+end
+
+begin
+  ActiveRecord::Base.send(:include, ActivePresenter::Presentable)
+rescue Exception => e
+  # Just in case you're using this in a non-ActiveRecord way.
+end

data/lib/proxy.rb

@@ -0,0 +1,52 @@
+module ActivePresenter
+  class Proxy
+    
+    def initialize(options = {}, &block)
+      if options.is_a? Hash
+        unless options.empty?
+          options.each_pair {|k,v| self.send("#{k}=", v)}
+        end
+      end
+      yield self if block_given?
+    end
+    
+    def method_missing(sym, *args)
+      syms = sym.to_s
+      if syms.match(/.=$/)
+        key = syms.chop
+        gen_methods(key)
+        self.send("#{key}=", args.from_args)
+      else
+        key = sym.to_s
+        gen_methods(key)
+        self.send("#{key}", args.from_args)
+      end
+
+    end
+    
+    def create_method(name, &block)
+      self.class.send(:define_method, name, &block)
+    end
+    
+    private
+    def gen_methods(key)
+      eval %{
+        
+        def #{key}=(x)
+          @#{key} = x
+        end
+
+        def #{key}(x = nil, &block)
+          if @#{key}.nil?
+            val = x
+          else
+            val = @#{key}
+          end
+          yield val if block_given?
+          val
+        end
+      }
+    end
+    
+  end
+end

data/lib/tasks/rubyforge_config.yml

@@ -0,0 +1,5 @@
+--- !ruby/object:RubyForgeConfig 
+gem_name: active_presenters
+package: active_presenters
+project: magrathea
+version: 1.0.0

data/test/active_presenters_test.rb

@@ -0,0 +1,93 @@
+require 'test/unit'
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../../../../config/environment")
+require File.expand_path(File.dirname(__FILE__) + "/../init")
+require File.expand_path(File.dirname(__FILE__) + "/models")
+require File.expand_path(File.dirname(__FILE__) + "/presenters")
+
+ActionController::Routing::Routes.draw do |map|
+  map.resources :blog_posts
+  map.resources :blog_users
+  map.resources :blog_comments
+end
+
+class ActivePresentersTest < Test::Unit::TestCase
+  include ActionView::Helpers::TagHelper # link_to
+  include ActionView::Helpers::UrlHelper # url_for
+  include ActionController::UrlWriter # named routes
+  include ActionView::Helpers::TextHelper # link_to
+  include ActionView::Helpers::FormHelper
+  include ActionView::Helpers::FormTagHelper
+  include ActionView::Helpers::FormOptionsHelper
+
+  def test_base_presenter_built
+    bp = BlogPost.build_new
+    p = bp.presenter
+    assert_presenter_basics(bp, p)
+  end
+  
+  def test_default_presenter_built
+    bc = BlogComment.build_new
+    p = bc.presenter
+    assert_presenter_basics(bc, p)
+    assert p.is_a?(BlogCommentPresenter)
+  end
+  
+  def test_custom_presenter_built
+    bu = BlogUser.build_new
+    p = bu.presenter
+    assert_presenter_basics(bu, p, "special_foo_presenter")
+    assert p.is_a?(SpecialFooPresenter)
+    assert_equal "Hello World!", p.show_link_text
+  end
+  
+  def test_poro_presenter_built
+    poro = Poro.new
+    p = poro.presenter
+    assert_presenter_basics(poro, p)
+  end
+  
+  def test_ar_resource_methods_built
+    bp = BlogPost.build_new
+    p = bp.presenter
+    assert bp.is_restful?
+    assert_nil bp.nested_resource
+    rest_verbs.each_pair do |verb, meth|
+      assert p.respond_to?("#{verb}_link_text")
+      assert_equal verb.to_s, p.send("#{verb}_link_text")
+      assert p.respond_to?("#{verb}_link_options")
+      assert_equal({:method => meth.to_sym}, p.send("#{verb}_link_options")) unless verb == :destroy
+      assert_equal({:method => meth.to_sym, :confirm => 'Are you sure?', :method => :delete}, p.send("#{verb}_link_options")) if verb == :destroy
+      assert p.respond_to?("#{verb}_link")
+      assert_equal link_to(h("#{verb}"), p.send("#{verb}_path"), p.send("#{verb}_link_options")), p.send("#{verb}_link")
+      assert p.respond_to?("#{verb}_path")
+    end
+  end
+  
+  def test_ar_resource_methods_not_built
+    bp = Poro.new
+    p = bp.presenter
+    rest_verbs.each_pair do |verb, meth|
+      assert !p.respond_to?("#{verb}_link_text")
+      assert !p.respond_to?("#{verb}_link_options")
+      assert !p.respond_to?("#{verb}_link")
+      assert !p.respond_to?("#{verb}_path")
+    end
+  end
+
+  def rest_verbs
+    ActivePresenter::REST_VERBS
+  end
+  
+  def assert_presenter_basics(model, presenter, presenter_name = "#{model.class.to_s.underscore.to_sym}_presenter")
+    m_underscore_sym = model.class.to_s.underscore.to_sym
+    assert model.is_presentable?
+    assert_equal presenter_name, model.presenter_name
+    assert_not_nil presenter
+    assert presenter.is_a?(ActivePresenter::Base)
+    assert_equal model, presenter.model
+    assert presenter.respond_to?(m_underscore_sym)
+    assert_equal presenter.model, presenter.send(m_underscore_sym)
+  end
+  
+end

data/test/models.rb

@@ -0,0 +1,59 @@
+class BlogPost < ActiveRecord::Base
+  
+  attr_accessor :title
+  attr_accessor :body
+  attr_accessor :created_at
+  attr_accessor :updated_at
+  attr_accessor :id
+  
+  def initialize(hsh = {}) 
+    hsh.each { |k, v| send("#{k}=", v) } 
+  end 
+  
+  def self.build_new(options = {})
+    BlogPost.new({:id => 1, :title => "Hello!", :body => "This is my body", :created_at => 1.day.ago, :updated_at => Time.now}.merge(options))
+  end
+  
+end
+
+class BlogComment < ActiveRecord::Base
+  
+  attr_accessor :blog_id
+  attr_accessor :body
+  attr_accessor :created_at
+  attr_accessor :updated_at
+  attr_accessor :id
+  
+  def initialize(hsh = {}) 
+    hsh.each { |k, v| send("#{k}=", v) } 
+  end 
+  
+  def self.build_new(options = {})
+    BlogComment.new({:id => 1, :blog_id => 1, :body => "This is my body", :created_at => 1.day.ago, :updated_at => Time.now}.merge(options))
+  end
+  
+end
+
+class BlogUser < ActiveRecord::Base
+  
+  use_presenter :special_foo
+  
+  attr_accessor :username
+  attr_accessor :email
+  attr_accessor :created_at
+  attr_accessor :updated_at
+  attr_accessor :id
+  
+  def initialize(hsh = {}) 
+    hsh.each { |k, v| send("#{k}=", v) } 
+  end 
+  
+  def self.build_new(options = {})
+    BlogUser.new({:id => 1, :username => "markbates", :email => "foo@foo.com", :created_at => 1.day.ago, :updated_at => Time.now}.merge(options))
+  end
+  
+end
+
+class Poro
+  include ActivePresenter::Presentable
+end

data/test/presenters.rb

@@ -0,0 +1,11 @@
+class BlogCommentPresenter < ActivePresenter::Base
+  
+end
+
+class SpecialFooPresenter < ActivePresenter::Base
+  
+  def show_link_text
+    "Hello World!"
+  end
+  
+end

data/test/proxy_test.rb

@@ -0,0 +1,75 @@
+require 'test/unit'
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../../../../config/environment")
+require File.expand_path(File.dirname(__FILE__) + "/../init")
+require File.expand_path(File.dirname(__FILE__) + "/models")
+require File.expand_path(File.dirname(__FILE__) + "/presenters")
+
+class ProxyTest < Test::Unit::TestCase
+  
+  def test_empty_constructor
+    p = ActivePresenter::Proxy.new
+    puts "p = #{p.inspect}"
+  end
+  
+  def test_hash_constructor
+    p = ActivePresenter::Proxy.new(:foo => :bar)
+    assert p.methods.include?("foo")
+    assert p.methods.include?("foo=")
+    assert_equal :bar, p.foo
+    p.foo = :foo_bar
+    assert_equal :foo_bar, p.foo
+  end
+  
+  def test_array_constructor
+    @hello = "Hello There World!"
+    p = ActivePresenter::Proxy.new([:mark, :bates, @hello])
+    assert !p.methods.include?("mark")
+    assert !p.methods.include?("bates")
+    assert !p.methods.include?("hello")
+  end
+  
+  def test_methods_genned
+    p = ActivePresenter::Proxy.new
+    assert !p.methods.include?("foo_bar")
+    assert !p.methods.include?("foo_bar=")
+    p.foo_bar = :bar
+    assert_equal :bar, p.foo_bar
+    assert p.methods.include?("foo_bar")
+    assert p.methods.include?("foo_bar=")
+  end
+  
+  def test_block
+    p = ActivePresenter::Proxy.new(:cool => :mark)
+    assert_equal :mark, p.cool
+    x = p.cool do |v|
+      assert_equal :mark, v
+      assert_equal 2, 1 + 1
+      v = "mark is cool"
+      assert_equal "mark is cool", v
+    end
+    assert_equal :mark, x
+  end
+  
+  def test_define_method
+    p = ActivePresenter::Proxy.new
+    assert !p.methods.include?("my_crazy_method")
+    p.create_method("my_crazy_method") do |k, v|
+      return [1, 2, k, v]
+    end
+    assert p.methods.include?("my_crazy_method")
+    assert_equal [1,2,3,4], p.my_crazy_method(3,4)
+  end
+  
+  def test_block_constructor
+    p = ActivePresenter::Proxy.new(:partner => :mark) do |p|
+      assert_equal :mark, p.partner
+      p.baby = :dylan
+      assert_equal p.baby, :dylan
+    end
+    assert_equal :mark, p.partner
+    assert_equal p.baby, :dylan
+  end
+  
+  
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: active_presenters
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-09-11 00:00:00 -04:00
+summary: active_presenters
+require_paths: 
+- lib
+- lib
+- lib
+- lib/tasks
+email: 
+homepage: 
+rubyforge_project: magrathea
+description: "active_presenters was developed by: markbates"
+autorequire: 
+- proxy
+- presentable
+- base
+- ar_hooks
+- active_presenters
+- ac_hooks
+- proxy
+- presentable
+- base
+- ar_hooks
+- active_presenters
+- ac_hooks
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- markbates
+files: 
+- init.rb
+- lib/ac_hooks.rb
+- lib/active_presenters.rb
+- lib/ar_hooks.rb
+- lib/base.rb
+- lib/presentable.rb
+- lib/proxy.rb
+- lib/tasks/rubyforge_config.yml
+- test/active_presenters_test.rb
+- test/models.rb
+- test/presenters.rb
+- test/proxy_test.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+