partializer 0.1.1

data/.document

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+
+# gem 'active_support', '>= 3.0.0'
+gem 'hashie'
+gem 'rails', '>= 3.0.0'
+
+group :development do
+  gem "rspec",      ">= 2.8.0"
+  gem "rdoc",       ">= 3.12"
+  gem "bundler",    ">= 1.0.0"
+  gem "jeweler",    "~> 1.8.4"
+  gem "simplecov",  ">= 0.5"
+end

data/Gemfile.lock

@@ -0,0 +1,111 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.2.8)
+      actionpack (= 3.2.8)
+      mail (~> 2.4.4)
+    actionpack (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.3)
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+    activerecord (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    git (1.2.5)
+    hashie (1.2.0)
+    hike (1.2.1)
+    i18n (0.6.0)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    journey (1.0.4)
+    json (1.7.5)
+    mail (2.4.4)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.19)
+    multi_json (1.3.6)
+    polyglot (0.3.3)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (3.2.8)
+      actionmailer (= 3.2.8)
+      actionpack (= 3.2.8)
+      activerecord (= 3.2.8)
+      activeresource (= 3.2.8)
+      activesupport (= 3.2.8)
+      bundler (~> 1.0)
+      railties (= 3.2.8)
+    railties (3.2.8)
+      actionpack (= 3.2.8)
+      activesupport (= 3.2.8)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.2)
+    simplecov (0.6.4)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    sprockets (2.1.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.16.0)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  hashie
+  jeweler (~> 1.8.4)
+  rails (>= 3.0.0)
+  rdoc (>= 3.12)
+  rspec (>= 2.8.0)
+  simplecov (>= 0.5)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Kristian Mandrup
+
+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,204 @@
+## Partializer
+
+Structure your partials in Rails 3+
+
+## Installation
+
+```ruby
+# Gemfile
+gem 'partializer'
+```
+
+Console, run:
+
+`$ bundle`
+
+## Requirements
+
+Only tested on Ruby 1.9.3 and Rails 3.2.
+
+## Why?
+
+In a Rails project I notices this reoccuring pattern and thought it would be nice to encapsulate it better ;)
+
+```haml
+#communication.column
+  - [:upper :lower].each do |name|
+    = render partial: "properties/show/main/#{name}"
+```
+
+```haml
+#lower.column
+  - [:communication :description].each do |name|
+    = render partial: "properties/show/main/lower/#{name}"
+```
+
+```haml
+#communication.column
+  - [:profile, :contact_requests, :social, :favorite, :comments].each do |name|
+    = render partial: "properties/show/main/lower/communication/#{name}"
+```
+
+Note also that all the partial paths are hardcoded here. If I move a folder, all the partials withing this folder have to be reconfigured to the new location! Argh!
+
+## With partialized partials :)
+
+Imagine you have a `properties/show/_main` partial. Then you can render all its subpartials like this:
+
+```haml
+#main.column
+  = render_partials partialize('properties#show', 'main')
+```
+
+For the `properties/show/main/_lower` partial, simply:
+
+```haml
+#lower.column
+  = render_partials partialize(partializer, 'lower')
+```
+
+And for the `properties/show/main/lower/_communication` partial, simply:
+
+```haml
+#communication.column
+  = render_partials partialize(partializer, 'communication')
+```
+
+Since the partializer (with previous context) will be passed down as a local and used by `partialize` to resolve the context (partial path). Sleek :)
+
+### The REAL power!
+
+Since the Partializer is class based, you can use simple inheritance and include to mixin partial configurations for other contexts, override, call `super` etc.
+
+Another great advantage is, that if you pass the "context" down the partial hierarchy, changing the top level context will take effect on all the partials in the call hierarchy. One change fix!
+
+## Configuration
+
+Note: This should be improved with even better DSL and perhaps loading from YAML file or similar? Maybe even supplying a hash directly and using Hashie::Mash?
+
+Structure your partial groupings like this:
+
+```ruby
+module Partializers
+  class Properties < Partializer
+    class Show < Partializer
+      partials_for :main, [{upper: :gallery}, :lower]
+        
+      partials_for :side, [:basic_info, :cost, :more_info, :period]
+
+      partializer :lower do
+        partializer :communication do
+          partialize :profile, :contact_requests, :social, :favorite, :priority_subscription, :free_subscription, :comments
+        end
+
+        partialize :_communication, :description
+      end
+
+      partials_for :my_main,  [{upper: :gallery}, :_lower]      
+    end
+  end
+end
+```
+
+Alternatively using Classes and methods (sth like):
+
+```ruby
+module Partializers
+  class Properties < Partializer
+    class Show < Partializer
+      def main
+        partials_for :main, [{upper: :gallery}, :lower]
+      end
+        
+      def side
+        partials_for :side, [:basic_info, :cost, :more_info, :period]
+      end
+
+      class Lower < Partializer
+        class Communication < Partializer
+          def partials 
+            partials_for [
+              :profile, :contact_requests, :social, 
+              :favorite, :priority_subscription, 
+              :free_subscription, :comments
+            ]
+          end
+        end
+
+        def partials
+          partials_for [:_communication, :description]
+        end
+      end
+
+      def my_main
+        partials_for [{upper: :gallery}, :_lower]
+      end
+    end
+  end
+end
+```
+
+This will likely be optimized in the near future. No need for the `partials_for` method call in the instance methods. Can be auto-resolved when the Partializer resolves itself into a nested `Partializer::Collections` structure.
+
+## Special Conventions
+
+A Symbol prefixed with underscore will nest down the hierarchy, see fx `:_lower`vs `:lower`. In this case, the class must have been defined, since it uses a constant lookup on the class and instantiates it.
+
+It might make sense to drop this `_` convention and simply always attempt nested resolution?
+
+## Usage in Views and Partials
+
+Now you can use the Partializers in your views!
+
+```haml
+#communication.column
+  = render_partials partialize('properties#show', 'main')
+```
+
+This will render fx `properties/show/main/upper` and `properties/show/main/lower`.
+The partial called will have the partializer passed in as a local.
+
+This allows you to continue calling like this, which will effectively be a shorthand for calling: 
+
+`= render_partials partialize('properties#show', 'main.lower')`
+
+```haml
+#main.column
+  = render_partials partialize(partializer, 'lower')
+```
+
+## Hidden Rails feature
+
+I'm taking advantage of this little hidden 'gem' in Rails :)
+
+[hidden-features-in-rails-3-2](http://blog.plataformatec.com.br/2012/01/my-five-favorite-hidden-features-in-rails-3-2/)
+
+Now, you can solve this problem by defining `to_partial_path` (part of the ActiveModel API) and can be implemented in any object. 
+
+```ruby
+class Activity
+  def to_partial_path
+    "activities/#{kind}" 
+  end
+end
+```
+
+And then invoking:
+
+`render :partial => @activities, :as => :activity`
+
+## Contributing to partializer
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2012 Kristian Mandrup. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "partializer"
+  gem.homepage = "http://github.com/kristianmandrup/partializer"
+  gem.license = "MIT"
+  gem.summary = %Q{Partialize your Rails partials for easy management and rendering}
+  gem.description = %Q{Makes it easy to render the subpartials of any partial}
+  gem.email = "kmandrup@gmail.com"
+  gem.authors = ["Kristian Mandrup"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "partializer #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/partializer.rb

@@ -0,0 +1,91 @@
+# require 'active_support/core_ext/string'
+# require 'active_support/inflector'
+require 'rails'
+require 'hashie'
+
+require 'partializer/view_helper'
+require 'partializer/engine' if defined?(::Rails::Engine)
+
+class Partializer
+  autoload :Collection,   'partializer/collection'
+  autoload :Resolver,     'partializer/resolver'
+  autoload :Partials,     'partializer/partials'
+
+
+  def partials_for name, *args
+    hash = args.flatten.inject({}) do |res, arg|
+      key = arg.kind_of?(Hash) ? arg.keys.first : arg
+      res[key.to_sym] = self.class.resolve(arg)
+      res
+    end
+    Partializer::Collection.new name, hash.keys, hash
+  end
+
+  class << self
+    def partialize *args, &block
+      name = self.name.to_s.underscore
+
+      hashie = args.flatten.inject({}) do |res, arg|
+        item = resolve_value(arg)
+        res.merge! Hashie::Mash.new arg.to_sym => item
+      end
+
+      collection = Partializer::Collection.new name, args, hashie
+
+      define_method :partials do
+        @partials ||= collection # Partializer::Collection.new hashie, partials
+      end
+    end
+
+    def partializer name, options = {}, &block
+      default_parent = ::Partializer
+
+      parent = options[:parent] || default_parent
+      raise ArgumentError, "Parent must have a partialize method, was: #{parent}" unless parent.respond_to? :partialize
+
+      clazz_name = name.to_s.camelize
+      context = self.kind_of?(Class) ? self : self.class
+
+      clazz = parent ? Class.new(parent) : Class.new
+      context.const_set clazz_name, clazz          
+      clazz = context.const_get(clazz_name)
+
+      clazz.instance_eval(&block) if block_given?
+      clazz
+    end
+
+    def partials_for name, *args
+      hash = args.flatten.inject({}) do |res, arg|
+        key = arg.kind_of?(Hash) ? arg.keys.first : arg
+        res[key.to_sym] = resolve(arg)
+        res
+      end
+      define_method name do
+        Partializer::Collection.new name, hash.keys, hash
+      end
+    end
+
+
+    protected
+
+    include Resolver
+
+    def partialize_item_of hash
+      matching?(hash) ? hash.values.first.to_sym : hash
+    end
+
+    def matching? hash
+      hash.keys.first.to_sym == hash.values.first.to_sym
+    end
+
+  end
+
+  protected
+
+  include Resolver
+
+  def method_missing meth_name, *args, &block    
+    instance = create_partializer(meth_name)
+    instance.respond_to?(:partials) ? instance.partials : instance
+  end
+end

data/lib/partializer/collection.rb

@@ -0,0 +1,96 @@
+class Partializer
+  class Collection
+    include Enumerable
+
+    attr_reader :hashie, :name, :ns, :action
+
+    def initialize name, *items
+      hash = items.extract_options!      
+      partials << partial_keys(items)
+      self.name = name.to_s
+      @hashie = Hashie::Mash.new resolve(hash) unless hash.empty?
+      set_names unless hashie.nil?
+    end
+
+    def each &block
+      partials.each {|partial| yield partial }      
+    end
+
+    def partials
+      @partials ||= Partializer::Partials.new
+    end
+
+    def path
+      [ns, action, name.gsub('.', '/')].compact.join('/')
+    end
+    alias_method :to_partial_path, :path
+
+
+    def set_context ns, action
+      @ns, @action = [ns, action]
+      partials.list.each {|p| p.send :set_context, ns, action }
+    end
+
+    protected
+
+    def name= name
+      @name = name
+      partials.list.each do |p|
+        p.path = name
+      end
+    end
+
+    def set_names
+      hashie.keys.each do |key|
+        if key.kind_of?(String)
+          h = hashie.send(key)
+          if h.kind_of? Partializer::Collection
+            h.send :name=, "#{name}.#{key}"
+            h.set_names unless h.hashie.nil?
+          end
+        end
+      end
+    end
+
+    def resolve hash
+      hash.inject({}) do |res, pair|
+        key = pair.first
+        item = pair.last
+        key = key.to_s.sub(/^_/, '').to_sym
+
+        value = resolve_value key, item        
+        
+        res[key.to_s.sub(/^_/, '').to_sym] = value
+        res
+      end
+    end
+
+    def resolve_value key, item
+      case item
+      when Partializer::Collection
+        item.hashie ? item.send(key) : item
+      when Symbol, String
+        Partializer::Collection.new('noname', item)
+      when Hash
+        item.values.first
+      else
+        raise ArgumentError, "cant resolve: #{item.inspect}"
+      end
+    end
+
+    def partial_keys *args
+      args.flatten.map do |item| 
+        case item
+        when Hash
+          item.keys.map(&:to_sym)
+        when String, Symbol
+          item.to_s.sub(/^_/, '').to_sym
+        end
+      end.flatten.compact.uniq
+    end    
+
+    def method_missing meth_name, *args, &block
+      hashie.send(meth_name)
+    end    
+  end
+end

data/lib/partializer/engine.rb

@@ -0,0 +1,9 @@
+class Partializer
+  module Rails
+    class Engine < ::Rails::Engine
+      initializer 'partializer' do 
+        ActionView::Base.send :include, ::Partializer::ViewHelper
+      end
+    end
+  end
+end

data/lib/partializer/partial.rb

@@ -0,0 +1,43 @@
+class Partializer
+  class Partial
+    attr_reader :path, :name, :ns, :action
+
+    def initialize path, name
+      @path = path unless path.blank?
+      self.name = name
+    end
+
+    def path= path_name      
+      raise ArgumentError, "Path is blank" if path_name.blank?
+      @path = path_name.gsub /\\./, '/' 
+      normalize!
+    end
+
+    def name= name
+      @name = name
+      normalize!
+    end
+
+    def view_path
+      [ns, action, path, name].compact.join('/')
+    end
+    
+    def to_partial_path
+      view_path.gsub('.', '/')
+    end
+
+    protected
+
+    def set_context ns, action
+      @ns, @action = [ns, action]
+      self
+    end
+
+    def normalize!
+      if path =~ /\.#{name}$/
+        norm = path.split('.')[0..-2].join('.')
+        @path = norm unless norm.blank? 
+      end
+    end
+  end
+end

data/lib/partializer/partials.rb

@@ -0,0 +1,39 @@
+require 'partializer/partial'
+
+class Partializer
+  class Partials
+    include Enumerable
+    
+    attr_reader :name
+
+    def initializer list
+      @list = list
+    end
+
+    def << *partials
+      @list ||= []
+      partials.flatten.each do |partial_name|        
+        partial = Partializer::Partial.new(path, partial_name)
+        @list << partial
+      end
+    end
+
+    alias_method :path, :name
+    
+    def to_partial_path
+      path.gsub('.', '/')
+    end
+
+    def list
+      @list ||= []
+    end
+
+    def each &block
+      list.each {|item| yield item.name }
+    end
+
+    def set_context ns, action
+      list.each {|p| p.send :set_context, ns, action }
+    end
+  end
+end

data/lib/partializer/resolver.rb

@@ -0,0 +1,52 @@
+class Partializer
+  module Resolver
+    def create_partializer name
+      context = self.kind_of?(Class) ? self : self.class
+      clazz = "#{context.name}::#{name.to_s.camelize}".constantize
+      clazz.new
+    end
+
+    def resolve arg
+      case arg
+      when Hash
+        resolve_hash(arg)
+      when String, Symbol
+        resolve_sym(arg)
+      when Partializer::Collection
+        arg
+      else
+        raise ArgumentError, "Could not partialize: #{arg}"
+      end
+    end
+
+    def resolve_hash hash
+      Partializer::Collection.new 'hash', hash.keys, hash
+    end
+
+    # Creates a Collection from a Symbol
+    # :gallery
+    # gallery -> :gallery
+    # partials: [:gallery]
+    def resolve_sym arg
+      value = resolve_value arg
+      arg = arg.to_s.sub(/^_/, '')
+      if value.to_s == arg.to_s
+        Partializer::Collection.new 'sym', arg
+      else
+        Partializer::Collection.new 'sym', arg, {arg.to_sym => value}
+      end
+    end
+
+    # a Partializer or a sym!
+    def resolve_value arg
+      arg = arg.to_s
+      arg[0] == '_' ? resolve_partializer(arg) : arg.to_sym
+    end
+
+    def resolve_partializer arg
+      arg.sub!(/^_/, '')
+      instance = create_partializer(arg)
+      {instance.class.name.to_s.demodulize.underscore => instance.partials}
+    end
+  end
+end

data/lib/partializer/view_helper.rb

@@ -0,0 +1,61 @@
+class Partializer
+  module ViewHelper
+    def partialize subject, path, &block
+      parts = case subject
+      when String
+        subject.split('#')
+      when Partializer::Collection
+        [subject.ns, subject.action]
+      end
+
+      name = parts.first
+      action = parts.last
+      try_clazzes = [name.to_s.camelize, "Partializers::#{name.to_s.camelize}"]
+
+      clazz = try_clazzes.select do |clazz|
+        begin
+          clazz.constantize
+        rescue NameError
+          nil
+        end
+      end.first
+
+      unless clazz
+        raise ArgumentError, "No Partializer could be found for: #{subject} in: #{try_clazzes}"
+      end
+      
+      instance = clazz.constantize.new
+      instance = instance.send(action)
+
+      path.split('.').each do |meth|
+        instance = instance.send(meth)
+      end
+      instance.set_context *parts
+      instance
+    end
+
+    def render_partials subject, options = {}
+      partials = case subject
+      when Partializer::Collection
+        subject.partials
+      else
+        subject
+      end
+
+      unless partials.kind_of? Partializer::Partials
+        raise ArgumentError, "Must be a Partializer::Collection or Partializer::Partials, was: #{collection}"
+      end
+
+      # make partializer available as object in partial called
+      locals_opts = {locals: {:partializer => subject}}.merge(options[:locals] || {})
+      options.merge! locals_opts
+
+      # render options.merge(:partial => partials)
+      partials.list.inject("") do |res, partial|
+        opts = {:partial => partial.to_partial_path}.merge(options)
+        res += raw(render opts)
+        # res += "#{opts.inspect} ------- "
+      end.html_safe
+    end
+  end
+end

data/partializer.gemspec

@@ -0,0 +1,80 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "partializer"
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Kristian Mandrup"]
+  s.date = "2012-08-29"
+  s.description = "Makes it easy to render the subpartials of any partial"
+  s.email = "kmandrup@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/partializer.rb",
+    "lib/partializer/collection.rb",
+    "lib/partializer/engine.rb",
+    "lib/partializer/partial.rb",
+    "lib/partializer/partials.rb",
+    "lib/partializer/resolver.rb",
+    "lib/partializer/view_helper.rb",
+    "partializer.gemspec",
+    "spec/partializer/collection_spec.rb",
+    "spec/partializer/partial_spec.rb",
+    "spec/partializer/resolver_spec.rb",
+    "spec/partializer/view_helper_spec.rb",
+    "spec/partializer_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/support/properties.rb"
+  ]
+  s.homepage = "http://github.com/kristianmandrup/partializer"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "Partialize your Rails partials for easy management and rendering"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<hashie>, [">= 0"])
+      s.add_runtime_dependency(%q<rails>, [">= 3.0.0"])
+      s.add_development_dependency(%q<rspec>, [">= 2.8.0"])
+      s.add_development_dependency(%q<rdoc>, [">= 3.12"])
+      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_development_dependency(%q<simplecov>, [">= 0.5"])
+    else
+      s.add_dependency(%q<hashie>, [">= 0"])
+      s.add_dependency(%q<rails>, [">= 3.0.0"])
+      s.add_dependency(%q<rspec>, [">= 2.8.0"])
+      s.add_dependency(%q<rdoc>, [">= 3.12"])
+      s.add_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_dependency(%q<simplecov>, [">= 0.5"])
+    end
+  else
+    s.add_dependency(%q<hashie>, [">= 0"])
+    s.add_dependency(%q<rails>, [">= 3.0.0"])
+    s.add_dependency(%q<rspec>, [">= 2.8.0"])
+    s.add_dependency(%q<rdoc>, [">= 3.12"])
+    s.add_dependency(%q<bundler>, [">= 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+    s.add_dependency(%q<simplecov>, [">= 0.5"])
+  end
+end
+

data/spec/partializer/collection_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Partializer::Collection do
+  include Partializer::Resolver
+
+  let(:clazz) { Partializer::Collection }
+
+  describe '#initialize' do
+    subject { clazz.new 'hash', hash.keys, hash }
+
+    let(:args) { [{upper: :gallery}, :lower] }
+
+    let(:hash) do
+      args.flatten.inject({}) do |res, arg|
+        key = arg.kind_of?(Hash) ? arg.keys.first : arg
+        res[key.to_sym] = resolve(arg)
+        res
+      end
+    end
+
+    specify do
+      subject.name.should == 'hash'
+    end
+
+    specify do
+      subject.partials.should be_a Partializer::Partials
+    end
+
+    specify do
+      subject.partials.should include(:upper)
+    end
+
+    specify do
+      subject.upper.partials.should include(:gallery)
+    end
+  end
+end

data/spec/partializer/partial_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Partializer::Partial do
+  subject { clazz.new 'main', 'lower'}
+
+  let(:clazz) { Partializer::Partial }
+
+  describe '#initialize' do
+    its(:view_path) { should == 'main/lower'}
+  end
+  
+  describe '#path=' do
+    before :all do
+      subject.path = 'go'
+    end
+
+    its(:view_path) { should == 'go/lower'}
+  end
+end

data/spec/partializer/resolver_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+class Resolve
+  include Partializer::Resolver
+end
+
+describe Partializer::Resolver do
+  subject { Resolve.new }
+
+  describe '#resolve_sym' do
+    specify do
+      subject.resolve_sym(:gallery).partials.should include(:gallery)
+    end
+
+    specify do
+      expect { subject.resolve_sym(:gallery).gallery }.to raise_error
+    end
+  end
+
+  describe '#resolve_hash' do
+    let(:hash) do
+      {:com => :gallery}
+    end
+
+    specify do
+      subject.resolve_hash(hash).partials.should include(:com)
+    end
+
+    specify do
+      subject.resolve_hash(hash).com.partials.should include(:gallery) 
+    end
+  end    
+
+  # describe '#resolve' do
+  #   describe 'hash' do
+  #     let(:hash) do
+  #       {:com => :gallery}
+  #     end
+
+  #     specify do
+  #       subject.resolve(hash).partials.should include(:com)
+  #     end
+
+  #     specify do
+  #       subject.resolve(hash).com.partials.should include(:gallery)
+  #     end
+  #   end    
+
+  #   describe 'symbol' do
+  #     specify do
+  #       subject.resolve(:gallery).partials.should include(:gallery)
+  #     end
+
+  #     specify do
+  #       expect { subject.resolve(:gallery).gallery }.to raise_error
+  #     end
+  #   end    
+  # end
+end

data/spec/partializer/view_helper_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Partializer::ViewHelper do
+  include Partializer::ViewHelper
+
+  let(:main_partializer) { partialize('properties#show', 'main') }
+  let(:my_main_partializer) { partialize('properties#show', 'my_main') }
+
+  describe '#initialize' do
+    subject { main_partializer }
+
+    its(:name) { should == 'main'}
+    its(:path) { should == 'properties/show/main' }
+    its(:to_partial_path) { should == 'properties/show/main' }
+
+    specify do
+      subject.partials.should include(:upper, :lower)
+    end
+
+    # see view_helper.rb: res += "#{partial.view_path}:"
+    specify do
+      # puts render_partials(subject)
+      render_partials(subject).should match /main\/upper/
+    end
+  end
+
+  describe 'nested partializing' do
+    subject { partialize my_main_partializer, 'lower'}
+
+    its(:name) { should == 'my_main.lower'}
+    its(:path) { should == 'properties/show/my_main/lower' }    
+  end
+end

data/spec/partializer_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Partializer do
+  subject { properties }
+
+  its(:show) { should be_a Partializers::Properties::Show }
+
+  let(:properties) { Partializers::Properties.new }
+
+  describe 'show' do
+    subject { properties.show }
+
+    specify do
+      subject.side.partials.should include(:basic_info)
+    end
+
+    specify do
+      subject.main.partials.should include(:upper, :lower)
+    end
+
+    specify do
+      subject.main.upper.partials.should include(:gallery)
+      subject.main.upper.name.should == 'main.upper'
+    end
+
+    specify do
+      subject.main.lower.partials.should include(:lower)
+      subject.main.lower.name.should == 'main.lower'
+    end
+
+    specify do
+      subject.my_main.lower.partials.should include(:description)
+    end
+
+    specify do
+      subject.my_main.lower.communication.partials.should include(:profile)
+      subject.my_main.lower.communication.name.should == 'my_main.lower.communication'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rspec'
+require 'partializer'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/support/properties.rb

@@ -0,0 +1,19 @@
+module Partializers
+  class Properties < Partializer
+    class Show < Partializer
+      partials_for :main, [{upper: :gallery}, :lower]
+        
+      partials_for :side, [:basic_info, :cost, :more_info, :period, :similar_properties]
+
+      partializer :lower do
+        partializer :communication do
+          partialize :profile, :contact_requests, :social, :favorite, :priority_subscription, :free_subscription, :comments
+        end
+
+        partialize :_communication, :description
+      end
+
+      partials_for :my_main,  [{upper: :gallery}, :_lower]      
+    end
+  end
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: partializer
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Kristian Mandrup
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.5'
+description: Makes it easy to render the subpartials of any partial
+email: kmandrup@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/partializer.rb
+- lib/partializer/collection.rb
+- lib/partializer/engine.rb
+- lib/partializer/partial.rb
+- lib/partializer/partials.rb
+- lib/partializer/resolver.rb
+- lib/partializer/view_helper.rb
+- partializer.gemspec
+- spec/partializer/collection_spec.rb
+- spec/partializer/partial_spec.rb
+- spec/partializer/resolver_spec.rb
+- spec/partializer/view_helper_spec.rb
+- spec/partializer_spec.rb
+- spec/spec_helper.rb
+- spec/support/properties.rb
+homepage: http://github.com/kristianmandrup/partializer
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3003520417573953991
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Partialize your Rails partials for easy management and rendering
+test_files: []