langalex-components 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Lance Ivy
+
+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

@@ -0,0 +1,134 @@
+= Components
+
+This plugin attempts to implement components in the simplest, cleanest, fastest way possible. Inspired by the Cells plugin (http://cells.rubyforge.org) by Nick Sutterer and Peter Bex.
+
+A component can be thought of as a very lightweight controller with supporting view templates. The difference between a component "controller" and a Rails controller is that the component controller's methods are very much normal methods - they accept arguments, and they return a string. There is no magical auto-rendering, and there is no access to data that is not a) in the arguments or b) in the database. For example, there is no access to the request, the request parameters, or the session. This is designed to encourage good design and reuse of components, and to ensure that they don't take over the request/response job of your Rails controllers.
+
+Speaking imprecisely, components prepare for and then render templates.
+
+== Usage
+
+Note that these examples are very simplistic and would be better implemented using Rails partials.
+
+=== Generator
+
+Running `script/generator users details` will create a UsersComponent with a "details" view. You might then flesh out the templates like this:
+
+  class UsersComponent < Components::Base
+    def details(user_or_id)
+      @user = user_or_id.is_a?(User) ? user_or_id : User.find(user_or_id)
+      render
+    end
+  end
+
+=== From ActionController
+
+  class UsersController < ApplicationController
+    def show
+      return :text => component("users/detail", params[:id])
+    end
+  end
+
+=== From ActionView
+
+  <%= component "users/detail", @user %>
+
+== More Features
+
+=== Caching
+
+Any component action may be cached using the fragment caching you've configured on ActionController::Base. The command to cache a component action must come after the definition of the action itself. This is because the caching method wraps the action, which makes the caching work even if you call the action directly.
+
+Example:
+
+  class UsersComponent < Components::Base
+    def details(user_id)
+      @user = User.find(user_id)
+      render
+    end
+    cache :details, :expires_in => 15.minutes
+  end
+
+This will cache the returns from UsersComponent#details using a cache key like "users/details/5", where 5 is the user_id. The cache will only be good for fifteen minutes. See Components::Caching for more information.
+
+=== Helpers
+
+All of the standard helper functionality exists for components. You may define a method on your component controller and use :helper_method to make it available in your views, or you may use :helper to add entire modules of extra methods to your views.
+
+Be careful importing existing helpers, though, as some of them may try and break encapsulation by reading from the session, the request, or the params. You may need to rewrite these helpers so they accept the necessary information as arguments.
+
+=== Inherited Views
+
+Assume two components:
+
+  class ParentComponent < Components::Base
+    def one
+      render
+    end
+
+    def two
+      render
+    end
+  end
+
+  class ChildComponent < ParentComponent
+    def one
+      render
+    end
+
+    def three
+      render "one"
+    end
+  end
+
+Both methods on the ChildComponent class would first try and render "/app/components/child/one.erb", and if that file did not exist, would render "/app/components/parent/one.erb".
+
+=== Standard Argument Options
+
+You may find yourself constantly needing to pass a standard set of options to each component. If so, you can define a method on your controller that returns a hash of standard options that will be merged with the component arguments and passed to every component.
+
+Suppose a given component:
+
+  class GroupsComponent < Components::Base
+    def details(group_id, options = {})
+      @user = options[:user]
+      @group = Group.find(group_id)
+      render
+    end
+  end
+
+Then the following setup:
+
+  class GroupsController < ApplicationController
+    def show
+      render :text => component("groups/details", params[:id])
+    end
+
+    protected
+
+    def standard_component_options
+      {:user => current_user}
+    end
+  end
+
+Would expand to:
+
+  component("groups/details", params[:id], :user => current_user)
+
+== Components Philosophy
+
+I wrote this components plugin after evaluating a couple of existing ones, reflecting a bit, and either stealing or composing the following principles. I welcome all debate on the subject.
+
+=== Components <em>should not</em> simply embed existing controller actions.
+
+Re-using existing controller actions introduces intractable performance problems related to redundant controller filters and duplicate request-cached variables.
+
+=== Components <em>should not</em> have the concept of a "request" or "current user".
+
+Everything should be provided as an argument to the component - it should not have direct access to the session, the params, or any other aspect of the request. This means that components will never intelligently respond_to :html, :js, :xml, etc.
+
+=== Components _should_ complement RESTful controller design.
+
+The path of least resistance in Rails includes RESTful controller design to reduce code redundancy. Components should only be designed for use cases where RESTful controller design is either awkward or impossible. This compatibility will reduce the maintenance effort for components and help them grow with Rails itself.
+
+Copyright (c) 2008 Lance Ivy, released under the MIT license

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "components"
+    gem.summary = %Q{TODO}
+    gem.email = "alex@upstream-berlin.com"
+    gem.homepage = "http://github.com/langalex/components"
+    gem.authors = ["Lance Ivy", "Alexander Lang"]
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "components #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 0
+:patch: 1

data/components.gemspec

@@ -0,0 +1,78 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{components}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Lance Ivy", "Alexander Lang"]
+  s.date = %q{2009-06-19}
+  s.email = %q{alex@upstream-berlin.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "MIT-LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION.yml",
+     "components.gemspec",
+     "generators/component/component_generator.rb",
+     "generators/component/templates/component_template.rb",
+     "generators/component/templates/view_template.rb",
+     "init.rb",
+     "lib/components.rb",
+     "lib/components/base.rb",
+     "lib/components/caching.rb",
+     "lib/components/helpers.rb",
+     "lib/components/view.rb",
+     "test/action_controller_test.rb",
+     "test/app/components/child/one.erb",
+     "test/app/components/child_component.rb",
+     "test/app/components/hello_world/bolded.erb",
+     "test/app/components/hello_world/say_it_with_help.erb",
+     "test/app/components/hello_world_component.rb",
+     "test/app/components/parent/one.erb",
+     "test/app/components/parent/two.erb",
+     "test/app/components/parent_component.rb",
+     "test/app/components/rich_view/form.erb",
+     "test/app/components/rich_view/linker.erb",
+     "test/app/components/rich_view/urler.erb",
+     "test/app/components/rich_view_component.rb",
+     "test/app/controllers/application_controller.rb",
+     "test/app/controllers/hello_world_controller.rb",
+     "test/caching_test.rb",
+     "test/components_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/langalex/components}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{TODO}
+  s.test_files = [
+    "test/action_controller_test.rb",
+     "test/app/components/child_component.rb",
+     "test/app/components/hello_world_component.rb",
+     "test/app/components/parent_component.rb",
+     "test/app/components/rich_view_component.rb",
+     "test/app/controllers/application_controller.rb",
+     "test/app/controllers/hello_world_controller.rb",
+     "test/caching_test.rb",
+     "test/components_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/generators/component/component_generator.rb

@@ -0,0 +1,13 @@
+class ComponentGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      m.class_collisions "#{class_name}Component"
+      m.directory "app/components/#{file_name}"
+      m.template "component_template.rb", "app/components/#{file_name}_component.rb"
+
+      actions.each do |action|
+        m.template "view_template.rb", "app/components/#{file_name}/#{action}.erb"
+      end
+    end
+  end
+end

data/generators/component/templates/component_template.rb

@@ -0,0 +1,7 @@
+class <%= class_name %>Component < Components::Base
+  <% actions.each do |action| %>
+  def <%= action %>
+    render
+  end
+  <% end %>
+end

data/init.rb

@@ -0,0 +1,3 @@
+ActiveSupport::Dependencies.load_paths << RAILS_ROOT + '/app/components'
+
+Components # trigger load

data/lib/components/base.rb

@@ -0,0 +1,114 @@
+module Components
+  class Base
+    include ::ActionController::UrlWriter
+    include ::ActionController::Helpers
+    include ::Components::Caching
+
+    # for request forgery protection compatibility
+    attr_accessor :form_authenticity_token #:nodoc:
+    delegate :request_forgery_protection_token, :allow_forgery_protection, :to => "ActionController::Base"
+    def protect_against_forgery? #:nodoc:
+      allow_forgery_protection && request_forgery_protection_token
+    end
+
+    class << self
+      # The view paths to search for templates. Typically this will only be "app/components", but
+      # if you have a plugin that uses Components, it may add its own directory (e.g.
+      # "vendor/plugins/scaffolding/components/" to this array.
+      def view_paths
+        if read_inheritable_attribute(:view_paths).nil?
+          default_path = File.join(RAILS_ROOT, 'app', 'components')
+          write_inheritable_attribute(:view_paths, [default_path])
+        end
+        read_inheritable_attribute(:view_paths)
+      end
+
+      def path #:nodoc:
+        @path ||= self.to_s.sub("Component", "").underscore
+      end
+      alias_method :controller_path, :path
+    end
+
+    # must be public for access from ActionView
+    def logger #:nodoc:
+      RAILS_DEFAULT_LOGGER
+    end
+
+    protected
+
+    # See Components::ActionController#standard_component_options
+    def standard_component_options; end
+
+    # When the string your component must return is complex enough to warrant a template file,
+    # this will render that file and return the result. Any template engine (erb, haml, etc.)
+    # that ActionView is capable of using can be used for templating.
+    #
+    # All instance variables that you create in the component action will be available from
+    # the view. There is currently no other way to provide variables to the views.
+    #
+    # === Inferred Template Name
+    #
+    # If you call render without a file name, it will:
+    #  * assume that the name of the calling method is also the name of the template file
+    #  * search for the named template file in the directory of this component's views, then the directories of all parent components
+    #
+    # This means that if you have:
+    #
+    #   class UsersComponent < Components::Base
+    #     def details(user_id)
+    #       render
+    #     end
+    #   end
+    #
+    # Then render will essentially assume that you meant to render "users/details", which may
+    # be found at "app/components/users/details.erb".
+    def render(file = nil)
+      # infer the render file basename from the caller method.
+      unless file
+        caller.first =~ /`([^']*)'/
+        file = $1.sub("_without_caching", '')
+      end
+
+      # pick the closest parent component with the file
+      component = self.class
+      unless file.include?("/")
+        until exists?("#{component.path}/#{file}") or component.superclass == Components::Base
+          component = component.superclass
+        end
+      end
+
+      template.render(:file => "#{component.path}/#{file}")
+    end
+
+    # creates and returns a view object for rendering the current action.
+    # note that this freezes knowledge of view_paths and assigns.
+    def template #:nodoc:
+      if @template.nil?
+        @template = Components::View.new(self.class.view_paths, assigns_for_view, self)
+        @template.extend self.class.master_helper_module
+      end
+      @template
+    end
+
+    # should return a hash of all instance variables to assign to the view
+    def assigns_for_view #:nodoc:
+      @assigns_for_view ||= (instance_variables - unassignable_instance_variables).inject({}) do |hash, var|
+        hash[var[1..-1]] = instance_variable_get(var)
+        hash
+      end
+    end
+
+    # should name all of the instance variables used by Components::Base that should _not_ be accessible from the view.
+    def unassignable_instance_variables #:nodoc:
+      %w(@template @assigns_for_view)
+    end
+    
+    private
+    
+    def exists?(name)
+      template.render(:file => name)
+    rescue ::ActionView::MissingTemplate
+      false
+    end
+  end
+end

data/lib/components/caching.rb

@@ -0,0 +1,185 @@
+# Component caching is very fine-grained - a component is cached based on all
+# of its arguments. Any more or less would result in inaccurate cache hits.
+#
+# === Howto
+#
+# First, configure fragment caching on ActionController. That cache store will be used
+# for components as well.
+#
+# Second, decide which component actions should be cached. Some components cache better
+# than others due to the nature of the arguments passed.
+#
+# For each component you wish to cache, add `cache :my_action` _after_ you define the
+# action itself. This is necessary because your action will be wrapped with another
+# method - :my_action_with_caching. This enables component actions to be cached no matter
+# how they are called.
+#
+# === Example
+#
+#   class UserComponent < Components::Base
+#     def show(user_id)
+#       @user = User.find(user_id)
+#       render
+#     end
+#     cache :show
+#   end
+#
+# === Expiration
+#
+# I know of three general methods to expire caches:
+#
+# * TTL: expires a cache after some number of seconds. This works well for content that
+#   is hit frequently but can stand to be a bit stale at times.
+# * Versioning: caches are never actually expired, rather, they are eventually ignored
+#   when all new cache requests are for a new version. This only works with cache stores
+#   that have some kind of limited cache space, otherwise cache consumption will go
+#   through the metaphorical roof.
+# * Direct Expiration: caches are expired by name. This does not work when cache keys
+#   have variable elements, or when the complete list of cache keys is not available
+#   or a brute-force regular expression approach.
+#
+# Of those three, direct expiration is not a viable option due to the variable nature of
+# component cache keys. And since both of the remaining methods are best supported by some
+# variation of memcache, that is the officially recommended cache store.
+#
+# ==== TTL Expiration
+#
+# If you are using Rails' :mem_cache_store for fragments, then you can set up TTL-style
+# expiration by specifying an :expires_in option, like so:
+#
+#   class UserComponent < Components::Base
+#     def show(user_id)
+#       @user = User.find(user_id)
+#       render
+#     end
+#     cache :show, :expires_in => 15.minutes
+#   end
+#
+# ==== Versioned Expiration
+#
+# Maintaining and incrementing version numbers may be implemented any number of ways. To
+# use the version numbers, though, you can specify a :version option, which may either name
+# a method (use a Symbol) or provide a proc. In either case, the method or proc should
+# receive all of the same arguments as the action itself, and should return the version
+# string.
+#
+#   class UserComponent < Components::Base
+#     def show(user_id)
+#       @user = User.find(user_id)
+#       render
+#     end
+#     cache :show, :version => :show_cache_version
+#
+#     protected
+#
+#     def show_cache_version(user_id)
+#       # you may want to find your version from a model object, from memcache, or whereever.
+#       Version.for("users/show", user_id)
+#     end
+#   end
+#
+module Components::Caching
+  def self.included(base) #:nodoc:
+    base.class_eval do
+      extend ClassMethods
+    end
+  end
+
+  module ClassMethods
+    # Caches the named actions by wrapping them via alias_method_chain. May only
+    # be called on actions (methods) that have already been defined.
+    #
+    # Cache options will be passed through to the cache store's read/write methods.
+    def cache(action, cache_options = nil)
+      return unless ActionController::Base.cache_configured?
+
+      class_eval <<-EOL, __FILE__, __LINE__
+        cattr_accessor :#{action}_cache_options
+
+        def #{action}_with_caching(*args)
+          with_caching(:#{action}, args) do
+            #{action}_without_caching(*args)
+          end
+        end
+        alias_method_chain :#{action}, :caching
+      EOL
+      self.send("#{action}_cache_options=", cache_options)
+    end
+
+    def cache_store #:nodoc:
+      @cache_store ||= ActionController::Base.cache_store
+    end
+  end
+
+  protected
+
+  def with_caching(action, args, &block) #:nodoc:
+    key = cache_key(action, args)
+    cache_options = self.send("#{action}_cache_options") || {}
+    passthrough_cache_options = cache_options.reject{|k, v| reserved_cache_option_keys.include? k}
+    passthrough_cache_options = nil if cache_options.empty?
+
+    # conditional caching: the prohibited case
+    if cache_options[:if] and not call(cache_options[:if], args)
+      fragment = block.call
+    else
+      fragment = read_fragment(key, passthrough_cache_options)
+      unless fragment
+        fragment = block.call
+        write_fragment(key, fragment, passthrough_cache_options)
+      end
+    end
+
+    return fragment
+  end
+
+  def read_fragment(key, cache_options = nil) #:nodoc:
+    returning self.class.cache_store.read(key, cache_options) do |content|
+      logger.debug "Component Cache hit: #{key}" unless content.blank?
+    end
+  end
+
+  def write_fragment(key, content, cache_options = nil) #:nodoc:
+    logger.debug "Component Cache miss: #{key}"
+    self.class.cache_store.write(key, content, cache_options)
+  end
+
+  # generates the cache key for the given action/args
+  def cache_key(action, args = []) #:nodoc:
+    key_pieces = [self.class.path, action] + args
+
+    if v = call(versioning(action), args)
+      key_pieces << "v#{v}"
+    end
+    key = key_pieces.collect do |arg|
+      case arg
+        when ActiveRecord::Base
+          "#{arg.class.to_s.underscore}#{arg.id}" # note: doesn't apply to record sets
+        else
+          arg.to_param
+      end
+    end.join('/')
+
+    ActiveSupport::Cache.expand_cache_key(key, :components)
+  end
+
+  # returns the versioning configuration for the given action, if any
+  def versioning(action) #:nodoc:
+    (self.send("#{action}_cache_options") || {})[:version]
+  end
+
+  private
+
+  def call(method, args)
+    case method
+      when Proc
+        method.call(*args)
+      when Symbol
+        send(method, *args)
+    end
+  end
+
+  def reserved_cache_option_keys
+    @reserved_cache_option_keys ||= [:if, :version]
+  end
+end

data/lib/components/view.rb

@@ -0,0 +1,5 @@
+class Components::View < ActionView::Base
+  delegate :protect_against_forgery?, :form_authenticity_token, :to => :controller
+
+  # TODO: rendering from a component view should be restricted to *just* rendering other components.
+end

data/lib/components.rb

@@ -0,0 +1,88 @@
+module Components #:nodoc:
+  def self.render(name, component_args = [], options = {})
+    klass, method = name.split('/')
+    component = (klass + "_component").camelcase.constantize.new
+    component.form_authenticity_token = options[:form_authenticity_token]
+    merge_standard_component_options!(component_args, options[:standard_component_options], component.method(method).arity)
+    component.logger.debug "Rendering component #{name}"
+    component.send(method, *component_args).to_s
+  end
+
+  def self.merge_standard_component_options!(args, standard_options, arity)
+    if standard_options
+      # when the method's arity is positive, it only accepts a fixed list of arguments, so we can't add another.
+      args << {} unless args.last.is_a?(Hash) or not arity < 0
+      args.last.reverse_merge!(standard_options) if args.last.is_a?(Hash)
+    end
+  end
+
+  module ActionController
+    protected
+
+    # Renders the named component with the given arguments. The component name must indicate both
+    # the component class and the class' action.
+    #
+    # Example:
+    #
+    #   class UsersController < ApplicationController
+    #     def show
+    #       render :text => component("users/details", params[:id])
+    #     end
+    #   end
+    #
+    # would render:
+    #
+    #   class UsersComponent < Components::Base
+    #     def details(user_id)
+    #       "all the important details about the user, nicely marked up"
+    #     end
+    #   end
+    def component(name, *args)
+      Components.render(name, args,
+        :form_authenticity_token => (form_authenticity_token if protect_against_forgery?),
+        :standard_component_options => standard_component_options
+      )
+    end
+
+    # Override this method on your controller (probably your ApplicationController)
+    # to define common arguments for your components. For example, you may always
+    # want to provide the current user, in which case you could return {:user =>
+    # current_user} from this method.
+    #
+    # In order to use this, your component actions should accept an options hash
+    # as their last argument.
+    #
+    # I feel like this is a better solution than simply making request and
+    # session details directly available to the components.
+    def standard_component_options; end
+  end
+
+  module ActionView
+    # Renders the named component with the given arguments. The component name must indicate both
+    # the component class and the class' action.
+    #
+    # Example:
+    #
+    #   /app/views/users/show.html.erb
+    #
+    #     <%= component "users/details", @user.id %>
+    #
+    # would render:
+    #
+    #   class UsersComponent < Components::Base
+    #     def details(user_id)
+    #       "all the important details about the user, nicely marked up"
+    #     end
+    #   end
+    def component(name, *args)
+      Components.render(name, args,
+        :form_authenticity_token => (form_authenticity_token if protect_against_forgery?),
+        :standard_component_options => controller.send(:standard_component_options)
+      )
+    end
+  end
+end
+
+ActionController::Base.class_eval do include Components::ActionController end
+ActionView::Base.class_eval       do include Components::ActionView       end
+

data/test/action_controller_test.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ActionControllerTest < ActionController::TestCase
+  ::ActionController::Routing::Routes.draw do |map|
+    map.connect "/:controller/:action/:id"
+  end
+
+  def setup
+    @controller = HelloWorldController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+
+  def test_rendering_component_from_controller
+    get :say_it, :string => "onomatopoeia"
+    assert_equal "onomatopoeia", @response.body
+  end
+
+  def test_standard_component_options
+    HelloWorldController.any_instance.stubs(:standard_component_options).returns(:user => "snuffalumpagus")
+    HelloWorldComponent.any_instance.expects(:say_it).with("wawoowifnik", :user => "snuffalumpagus")
+    get :say_it, :string => "wawoowifnik"
+  end
+end

data/test/app/components/child/one.erb

@@ -0,0 +1 @@
+child/one

data/test/app/components/child_component.rb

@@ -0,0 +1,5 @@
+class ChildComponent < ParentComponent
+  def one
+    render
+  end
+end

data/test/app/components/hello_world/bolded.erb

@@ -0,0 +1 @@
+<b><%= @string %></b>

data/test/app/components/hello_world/say_it_with_help.erb

@@ -0,0 +1 @@
+<%= get_string %>

data/test/app/components/hello_world_component.rb

@@ -0,0 +1,27 @@
+class HelloWorldComponent < Components::Base
+  helper_method :get_string
+
+  def say_it(string)
+    string
+  end
+
+  def say_it_with_style(string)
+    bolded(string)
+  end
+
+  def say_it_with_help(string)
+    @string = string
+    render
+  end
+
+  def bolded(string)
+    @string = string
+    render
+  end
+
+  protected
+
+  def get_string
+    @string
+  end
+end

data/test/app/components/parent/one.erb

@@ -0,0 +1 @@
+parent/one

data/test/app/components/parent/two.erb

@@ -0,0 +1 @@
+parent/two

data/test/app/components/parent_component.rb

@@ -0,0 +1,9 @@
+class ParentComponent < Components::Base
+  def one
+    render
+  end
+
+  def two
+    render
+  end
+end

data/test/app/components/rich_view/form.erb

@@ -0,0 +1,3 @@
+<% form_tag "foo" do %>
+  It's important to test request forgery protection.
+<% end %>

data/test/app/components/rich_view/linker.erb

@@ -0,0 +1 @@
+<%= link_to "linking is essential", @url %>

data/test/app/components/rich_view/urler.erb

@@ -0,0 +1 @@
+<%= url_for(:controller => "foo", :action => "bar") %>

data/test/app/components/rich_view_component.rb

@@ -0,0 +1,14 @@
+class RichViewComponent < Components::Base
+  def urler
+    render
+  end
+
+  def form
+    render
+  end
+
+  def linker(url)
+    @url = url
+    render
+  end
+end

data/test/app/controllers/hello_world_controller.rb

@@ -0,0 +1,5 @@
+class HelloWorldController < ActionController::Base
+  def say_it
+    render :text => component("hello_world/say_it", params[:string])
+  end
+end

data/test/caching_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class CachingTest < Test::Unit::TestCase
+  def setup
+    ActionController::Base.stubs(:cache_configured?).returns(true)
+    klass = HelloWorldComponent.dup
+    klass.stubs(:path).returns("hello_world")
+    klass.send(:cache, :say_it)
+    @component = klass.new
+  end
+
+  def test_cache_method_chaining
+    @component.expects(:with_caching).with(:say_it, ["janadumplet"]).returns("janadoomplet")
+    assert_equal "janadoomplet", @component.say_it("janadumplet")
+  end
+
+  def test_cache_key_generation
+    assert_equal "components/hello_world/say_it", @component.send(:cache_key, :say_it), "simplest cache key"
+    assert_equal "components/hello_world/say_it/trumpapum", @component.send(:cache_key, :say_it, ["trumpapum"]), "uses arguments"
+    assert_equal "components/hello_world/say_it/a/1/2/3/foo=bar", @component.send(:cache_key, :say_it, ["a", [1,2,3], {:foo => :bar}]), "handles mixed types"
+    assert_equal "components/hello_world/say_it/a=1&b=2", @component.send(:cache_key, :say_it, [{:b => 2, :a => 1}]), "hash keys are ordered"
+  end
+
+  def test_conditional_caching
+    @component.say_it_cache_options = {:if => proc{false}}
+    @component.expects(:read_fragment).never
+    assert_equal "trimpanta", @component.say_it("trimpanta")
+  end
+
+  def test_cache_hit
+    @component.expects(:read_fragment).with("components/hello_world/say_it/loudly", nil).returns("LOUDLY!")
+    @component.expects(:say_it_without_caching).never
+    @component.say_it("loudly")
+  end
+
+  def test_cache_miss
+    @component.expects(:read_fragment).returns(nil)
+    @component.expects(:write_fragment).with("components/hello_world/say_it/frumpamumpa", "frumpamumpa", nil)
+    assert_equal "frumpamumpa", @component.say_it("frumpamumpa")
+  end
+
+  def test_expires_in_passthrough
+    @component.say_it_cache_options = {:expires_in => 15.minutes}
+    @component.expects(:write_fragment).with("components/hello_world/say_it/ninnanana", "ninnanana", {:expires_in => 15.minutes})
+    assert_equal "ninnanana", @component.say_it("ninnanana")
+  end
+
+  def test_versioned_keys
+    @component.say_it_cache_options = {:version => :some_named_method}
+    @component.expects(:some_named_method).with("rangleratta").returns(314)
+    assert_equal "components/hello_world/say_it/rangleratta/v314", @component.send(:cache_key, :say_it, ["rangleratta"])
+  end
+end

data/test/components_test.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ComponentsTest < ActionController::TestCase
+  def test_component_response
+    HelloWorldComponent.any_instance.expects(:say_it).returns("mukadoogle")
+    assert_equal "mukadoogle", Components.render("hello_world/say_it", ["gigglemuppit"])
+  end
+
+  def test_rendering_a_component_view
+    assert_equal "<b>pifferspangle</b>", Components.render("hello_world/say_it_with_style", ["pifferspangle"])
+  end
+
+  def test_implied_render_file
+    assert_equal "<b>foofididdums</b>", Components.render("hello_world/bolded", ["foofididdums"])
+  end
+
+  def test_inherited_views
+    assert_equal "parent/one", Components.render("parent/one")
+    assert_equal "parent/two", Components.render("parent/two")
+    assert_equal "child/one",  Components.render("child/one")
+    assert_equal "parent/two", Components.render("child/two")
+  end
+
+  def test_links_in_views
+    rendered = Components.render("rich_view/linker", ["http://example.com"])
+    assert_select rendered, "a[href=http://example.com]"
+  end
+
+  def test_form_in_views
+    ActionController::Base.request_forgery_protection_token = :authenticity_token
+    rendered = Components.render("rich_view/form", [], :form_authenticity_token => "bluetlecrashit")
+    assert_select rendered, "form"
+    assert_select rendered, "input[type=hidden][name=authenticity_token][value=bluetlecrashit]"
+  end
+
+  def test_url_for_in_views
+    assert_nothing_raised do
+      ActionController::Routing::RouteSet.any_instance.stubs(:generate).returns("some_url")
+      Components.render("rich_view/urler")
+    end
+  end
+
+  def test_helper_methods
+    assert_equal "jingleheimer", Components.render("hello_world/say_it_with_help", ["jingleheimer"])
+  end
+
+  protected
+
+  def assert_select(content, *args)
+    super(HTML::Document.new(content).root, *args)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,24 @@
+# fake the rails root
+RAILS_ROOT = File.dirname(__FILE__)
+
+# require support libraries
+require 'test/unit'
+require 'rubygems'
+gem 'rails', '2.3.2'
+require 'active_support'
+require 'action_controller'
+require 'action_controller/test_process' # for the assertions
+require 'action_view'
+require 'active_record'
+require 'logger'
+require 'mocha'
+
+RAILS_DEFAULT_LOGGER = Logger.new(File.dirname(__FILE__) + '/debug.log')
+
+%w(../lib app/controllers).each do |load_path|
+  ActiveSupport::Dependencies.load_paths << File.dirname(__FILE__) + "/" + load_path
+end
+
+require File.dirname(__FILE__) + '/../init'
+
+ActionController::Base.cache_store = :memory_store

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: langalex-components
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Lance Ivy
+- Alexander Lang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-19 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: alex@upstream-berlin.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .document
+- .gitignore
+- MIT-LICENSE
+- README
+- Rakefile
+- VERSION.yml
+- components.gemspec
+- generators/component/component_generator.rb
+- generators/component/templates/component_template.rb
+- generators/component/templates/view_template.rb
+- init.rb
+- lib/components.rb
+- lib/components/base.rb
+- lib/components/caching.rb
+- lib/components/helpers.rb
+- lib/components/view.rb
+- test/action_controller_test.rb
+- test/app/components/child/one.erb
+- test/app/components/child_component.rb
+- test/app/components/hello_world/bolded.erb
+- test/app/components/hello_world/say_it_with_help.erb
+- test/app/components/hello_world_component.rb
+- test/app/components/parent/one.erb
+- test/app/components/parent/two.erb
+- test/app/components/parent_component.rb
+- test/app/components/rich_view/form.erb
+- test/app/components/rich_view/linker.erb
+- test/app/components/rich_view/urler.erb
+- test/app/components/rich_view_component.rb
+- test/app/controllers/application_controller.rb
+- test/app/controllers/hello_world_controller.rb
+- test/caching_test.rb
+- test/components_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/langalex/components
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: 
+- test/action_controller_test.rb
+- test/app/components/child_component.rb
+- test/app/components/hello_world_component.rb
+- test/app/components/parent_component.rb
+- test/app/components/rich_view_component.rb
+- test/app/controllers/application_controller.rb
+- test/app/controllers/hello_world_controller.rb
+- test/caching_test.rb
+- test/components_test.rb
+- test/test_helper.rb