xhive 1.0.9.pre → 1.2.0.pre

data/README.md

@@ -34,22 +34,28 @@ Run bundle install
 
 Run xhive migrations
 
-```
+```bash
 rake xhive:install:migrations
 rake db:migrate
 ```
 
 Include the xhive javascript in your head tag.
 
-`<%= javascript_include_tag "xhive/application" %>`
+```erb
+<%= javascript_include_tag "xhive/application" %>
+```
 
 Include the custom stylesheets in your head tag.
 
-`<%= include_custom_stylesheets %>`
+```erb
+<%= include_custom_stylesheets %>
+```
 
 Include the widgets loader just before your \<\\body\> tag.
 
-`<%= initialize_widgets_loader %>`
+```erb
+<%= initialize_widgets_loader %>
+```
 
 # Usage
 
@@ -59,29 +65,33 @@ Include the widgets loader just before your \<\\body\> tag.
 
 Let's say you have a Posts controller and you want to access the show action as a widget.
 
-```
-app/controller/posts_controller.rb
+`app/controller/posts_controller.rb`
 
+```ruby
 class PostsController < ApplicationController
   def show
     @post = Post.find(params[:id])
   end
 end
+```
 
-app/views/posts/show.html.erb
+`app/views/posts/show.html.erb`
 
+```erb
 <h1><%= @post.title %></h1>
 
 <p><%= @post.body %></p>
+```
 
-config/routes.rb
+`config/routes.rb`
 
+```ruby
 resources :posts, :only => [:show]
-
 ```
+
 Just tell xhive to *widgify* your action:
 
-```
+```ruby
 class PostsController < ApplicationController
   widgify :show
 
@@ -90,9 +100,10 @@ class PostsController < ApplicationController
   end
 end
 ```
+
 And that's it. You will now be able to insert the content of any post from within an HTML template using:
 
-{% posts_show id:1234 %}
+`{% posts_show id:1234 %}`
 
 This tag will make the browser insert the post content asynchronously into the HTML document.
 
@@ -104,30 +115,32 @@ Let's use the same example to illustrate the use of cells with xhive.
 
 We have a Posts cell and we want to use the show method as an AJAX widget.
 
-```
-app/cells/posts_cell.rb
+`app/cells/posts_cell.rb`
 
+```ruby
 class PostsCell < Cell::Rails
   def show(params)
     @post = params[:id]
     render
   end
 end
+```
 
-app/cells/posts/show.html.erb
+`app/cells/posts/show.html.erb`
 
+```erb
 <div class='post'>
   <h1><%= @post.title %></h1>
 
   <p><%= @post.body %></p>
 </div>
-
 ```
+
 In this case, we need to tell xhive how we are mounting our widgets routes:
 
-```
-config/initializers/xhive.rb
+`config/initializers/xhive.rb`
 
+```ruby
 Xhive::Router::Cells.draw do |router|
   router.mount 'posts/:id', :to => 'posts#show'
 end
@@ -135,12 +148,37 @@ end
 
 And that's it. You will now be able to insert the content of any post from within an HTML template using:
 
-{% posts_show id:1234 %}
+`{% posts_show id:1234 %}`
 
 This tag will make the browser insert the post content asynchronously into the HTML document.
 
 xhive will also enforce the tag to include the :id parameter.
 
+You can customize the tag invocation name by using the :as symbolized option:
+
+```ruby
+Xhive::Router::Cells.draw do |router|
+  router.mount 'posts/:id', :to => 'posts#show', :as => 'show_post'
+end
+```
+Then you can insert the tag using the following snippet:
+
+`{% show_post id:1234 %}`
+
+You can also force the cell widget to be rendered inline instead of using AJAX.
+
+Just include the :inline symbolized option:
+
+```ruby
+Xhive::Router::Cells.draw do |router|
+  router.mount 'posts/:id', :to => 'posts#show', :as => 'show_post', :inline => true
+end
+```
+
+This is also useful when using stylesheet tags inside email pages.
+
+Caveat: the inline feature only works for Cell:Base cells.
+
 ## CMS features
 
 Ok, I can include my cells and controller actions as widgets, but... how?
@@ -153,13 +191,13 @@ To be able to use your widgets, you have to follow the following steps:
 
 Create a Site
 
-```
+```ruby
 site = Xhive::Site.create(:name => 'My awesome blog', :domain => 'localhost')
 ```
 
 Create a Page
 
-```
+```ruby
 page = Xhive::Page.create(:name => 'home',
                           :title => 'My blog page',
                           :content => '<h1>Home</h1><p>{% posts_show id:1 %}</p>',
@@ -180,7 +218,7 @@ xhive provides the Xhive::Mapper to wire up your resources to xhive pages.
 
 Create a new page to display all the posts
 
-```
+```ruby
 posts_page = Xhive::Page.create(:name => 'posts',
                                 :title => 'Blog Posts',
                                 :content => '{% for post in posts %}{% posts_show id:post.id %}{% endfor %}',
@@ -189,7 +227,7 @@ posts_page = Xhive::Page.create(:name => 'posts',
 
 Create a new stylesheet to display your posts:
 
-```
+```ruby
 stylesheet = Xhive::Stylesheet.create(:name => 'Posts', 
                                       :content => '.post {
                                                      h1 { font-size: 20px; color: blue; }
@@ -200,19 +238,19 @@ stylesheet = Xhive::Stylesheet.create(:name => 'Posts',
 
 Create a new mapper record for the posts resources
 
-```
+```ruby
 mapper = Xhive::Mapper.map_resource(site, posts_page, 'posts', 'index')
 ```
 
 If you want to map the page to a specific post
 
-```
+```ruby
 mapper = Xhive::Mapper.map_resource(site, posts_page, 'posts', 'index', post.id)
 ```
 
 From your posts controller, render the posts page
 
-```
+```ruby
 class PostsController < ApplicationController
   # This will render the page associated with the index action
   def index
@@ -230,6 +268,70 @@ end
 
 Using this feature you can let the designers implement the HTML/CSS to display the posts in your site without your intervention.
 
+## ActionMailer integration
+
+Using xhive you can extend the CMS capabilities to your system generated emails.
+
+```ruby
+class Notifications < ActionMailer::Base
+  def welcome(site, user)
+    @user = user
+    @link = root_url
+
+    mailer = Xhive::Mailer.new(site, self)
+    mailer.send :to => user.email, :subject => 'Welcome!'
+  end
+end
+```
+In order to use this, you must create a mapper for this specific email action:
+
+```ruby
+mapper = site.mappers.new(:resource => 'notifications', :action => 'welcome')
+mapper.page = my_awesome_email_page
+mapper.save
+```
+
+You can use your instance variables from within the dynamic page:
+
+```
+<p>Dear {{user.first_name}}</p>
+
+<p>Welcome to our awesome site</p>
+
+<p>Click <a href='{{link}}'>here</a> to start!</p>
+
+```
+
+If you want to use different pages for different, e.g. user categories, you can pass the user category to the mailer initializer:
+
+```ruby
+mailer = Xhive::Mailer.new(site, self, user.category)
+```
+
+And you add the key to the mapper creation step:
+
+```ruby
+mapper = site.mappers.new(:resource => 'notifications', :action => 'welcome', :key => 'spanish')
+mapper.page = email_for_spanish_users
+mapper.save
+```
+
+### Inline stylesheets for your emails
+
+If you add the inline widget to your cell routes you can use inline stylesheets within your email pages:
+
+```ruby
+Xhive::Router::Cells.draw do |router|
+  router.mount 'stylesheet/:id', :to => 'xhive/stylesheet#inline', :inline => true, :as => :inline_stylesheet
+end
+```
+
+Then you can add your stylesheet into your email page using the corresponding tag:
+
+`{% inline_stylesheet id:spain_users_stylesheet %}`
+
+This will create a `<style>` tag inside your email page and inject all the style rules.
+
 TODO
 ====
 
@@ -238,5 +340,6 @@ TODO
 
 Disclaimer
 ==========
-This is a work in progress and still a proof of concept. Use at your own risk :P.
+This is a work in progress and still a proof of concept. Use at your own risk.
 
+Please let me know of any problems, ideas, improvements, etc.

data/app/cells/base_cell.rb

@@ -0,0 +1,10 @@
+class BaseCell < Cell::Base
+  def self.render_action(action, attrs)
+    result = Cell::Base.render_cell_for(self.name.underscore, action, attrs)
+  rescue e
+    result = ''
+    logger.error "#{e.class.name}: #{e.message}"
+  ensure
+    return result
+  end
+end

data/app/cells/xhive/stylesheet_cell.rb

@@ -0,0 +1,8 @@
+module Xhive
+  class StylesheetCell < BaseCell
+    def inline(params)
+      @stylesheet = Xhive::Stylesheet.find(params[:id])
+      "<style type='text/css'>#{@stylesheet.presenter.compressed}</style>"
+    end
+  end
+end

data/app/helpers/xhive/application_helper.rb

@@ -8,11 +8,21 @@ module Xhive
       "<link href='#{xhive.stylesheets_path}' media='all' rel='stylesheet' type='text/css'/>".html_safe
     end
 
-    def render_page_with(key = nil, options={})
+    # Public: looks for a map and renders the corresponding page.
+    #
+    # key     - The String containing the key to look for (default = nil).
+    # options - The Hash the data to pass to the rendered page.
+    # block   - The block for a custom render if no map is found.
+    #
+    # Returns: the rendered page.
+    #
+    def render_page_with(key = nil, options={}, &block)
       page = Xhive::Mapper.page_for(current_site, controller_path, action_name, key)
-      render :inline => page.presenter.render_content(options), :layout => true
-    rescue
-      render
+      if page.present?
+        render :inline => page.present_content(options), :layout => true
+      else
+        block_given? ? yield : render
+      end
     end
 
     def current_site

data/app/models/xhive/mapper.rb

@@ -1,4 +1,6 @@
 module Xhive
+  # Maps resources to pages.
+  #
   class Mapper < ActiveRecord::Base
     attr_accessible :action, :page_id, :site_id, :resource, :key
 
@@ -10,13 +12,30 @@ module Xhive
     validates :site, :presence => true
     validates :page, :presence => true
 
+    # Public: looks for a page mapper and returns the associated page.
+    #
+    # site     - The Site to look into.
+    # resource - The String containing the resource name filter.
+    # action   - The String containing the action name filter.
+    # key      - The String containing the key filter.
+    #
+    # Returns: the mapped page or nil if not found.
+    #
     def self.page_for(site, resource, action, key = nil)
       mapper = find_map(site, resource, action, key)
       page = mapper.try(:page)
-      fail ActiveRecord::RecordNotFound unless page.present?
-      page
     end
 
+    # Public: creates a mapper for a specific resource and page.
+    #
+    # site     - The Site to associate the mapper to.
+    # page     - The Page object to map.
+    # resource - The String containing the associated resource name.
+    # action   - The String containing the associated action name.
+    # key      - The String containing the associated key.
+    #
+    # Returns: true if created. False otherwise.
+    #
     def self.map_resource(site, page, resource, action, key = nil)
       mapper = find_map(site, resource, action, key)
       mapper = new(:site_id => site.id, :resource => resource, :action => action, :key => key) unless mapper.present?
@@ -26,6 +45,15 @@ module Xhive
 
   private
 
+    # Private: looks for a mapper object.
+    #
+    # site     - The Site to look into.
+    # resource - The String containing the resource name filter.
+    # action   - The String containing the action name filter.
+    # key      - The String containing the key filter.
+    #
+    # Returns: the mapper object or nil if not found.
+    #
     def self.find_map(site, resource, action, key)
       mapper = where(:site_id => site.id).where(:resource => resource).where(:action => action)
       mapper = mapper.where(:key => key) if key.present?

data/app/models/xhive/page.rb

@@ -15,5 +15,9 @@ module Xhive
     validates :title, :presence => true
     validates :content, :presence => true
     validates :site, :presence => true
+
+    def present_content(opts={})
+      presenter.render_content(opts)
+    end
   end
 end

data/app/presenters/xhive/page_presenter.rb

@@ -6,15 +6,16 @@ module Xhive
     liquid_methods :name, :title, :content, :meta_keywords, :meta_description
 
     def render_content(options={})
+      liquified = LiquidWrapper.liquify_objects(options)
       layout = ::Liquid::Template.parse("{{content}}").render({"content" => page.content})
       text = ::Liquid::Template.parse(layout).render(
-        {'page' => self, 'user' => controller.safe_user.presenter}.merge(options.stringify_keys),
+        {'page' => self, 'user' => controller.try(:safe_user).try(:presenter)}.merge(liquified.stringify_keys),
         :registers => {:controller => controller}
       )
       result = text.html_safe
     rescue => e
-      logger.debug "#{e.class.name}: #{e.message}"
-      logger.debug e.backtrace.join("/n")
+      logger.error "#{e.class.name}: #{e.message}"
+      logger.error e.backtrace.join("/n")
       result = ''
     ensure
       return result

data/lib/xhive/base_tag.rb

@@ -26,11 +26,8 @@ module Xhive
     def render(context)
       if (errors = check_parameters).empty?
         process_parameters(context)
-        html = "<div "
-        html << " data-widget='true'"
-        html << " data-url='#{rest_url}'"
-        html << " data-params='#{parameters_to_args}'"
-        html << "></div>"
+        route = Xhive::Router::Route.find(rest_url)
+        render_inline?(route, context) ? render_inline(route) : render_widget_tag
       else
         errors
       end
@@ -38,6 +35,27 @@ module Xhive
 
   private
 
+    def render_widget_tag
+      html = "<div "
+      html << " data-widget='true'"
+      html << " data-url='#{rest_url}'"
+      html << " data-params='#{parameters_to_args}'"
+      html << "></div>"
+      html
+    end
+
+    def render_inline(route)
+      # TODO: extend this to the controller based widgets
+      result = Cell::Base.render_cell_for(route.klass.underscore, route.action, @attributes)
+    rescue NoMethodError
+      logger.error "Please check that your cell inherits from Cell:Base and that you are passing all the arguments to the cell action"
+    rescue NameError => e
+      logger.error "#{e.class.name}: #{e.message}"
+    ensure
+      return result
+    end
+
+
     # Private: checks the attributes to see if there is any required
     #          param missing.
     #
@@ -83,6 +101,12 @@ module Xhive
         value
       end
     end
+
+    # Private: checks if the tag is for inline rendering or not
+    #
+    def render_inline?(route, context)
+      route.try(:inline) && (context['inline'].nil? || context['inline'])
+    end
   end
 end
 

data/lib/xhive/controller.rb

@@ -6,8 +6,6 @@ module Xhive
 
     def self.extended(base)
       base.class_eval do
-        @@current_controller = nil
-
         include InstanceMethods
 
         prepend_before_filter :set_current_controller

data/lib/xhive/engine.rb

@@ -12,6 +12,8 @@ module Xhive
         include Xhive::ApplicationHelper
 
         helper_method :initialize_widgets_loader, :include_custom_stylesheets
+
+        self.class_variable_set('@@current_controller', nil)
       end
     end
     initializer "xhive.load_all_controller_classes", :after=> :disable_dependency_loading do

data/lib/xhive/liquid_wrapper.rb

@@ -0,0 +1,43 @@
+module Xhive
+  # Wrapper to add liquid_method to all of object attributes.
+  class LiquidWrapper
+    def initialize(object)
+      @object = object
+    end
+
+    # Public: liquid interface.
+    #
+    # Returns: object attributes or an empty Array.
+    #
+    def to_liquid
+      @object.respond_to?(:attributes) ? @object.attributes : []
+    end
+
+    # Public: builds wrapper around each collection object.
+    #
+    # objects - The Hash containing the objects.
+    #
+    # Returns: the objects hash with the objects wrappers.
+    #
+    def self.liquify_objects(objects)
+      objects.each do |k, v|
+        objects[k] = liquify(v)
+      end
+    end
+
+    # Public: builds a liquid wrapper around the object.
+    #
+    # object - The object to wrap.
+    #
+    # Returns: the same object (if it is already liquified) or a liquid wrapper.
+    #
+    def self.liquify(object)
+      object.respond_to?(:to_liquid) ? object : new(object)
+    end
+
+    # Delegate methods to wrapped object
+    def method_missing(sym, *args, &block)
+      @object.send sym, *args, &block
+    end
+  end
+end

data/lib/xhive/mailer.rb

@@ -0,0 +1,60 @@
+module Xhive
+  class Mailer
+    attr :site, :resource, :action, :key, :mailer, :content
+
+    def initialize(site, mailer, key = nil)
+      @site = site
+      @resource = mailer.class.name.underscore
+      @mailer = mailer
+      @action = mailer.action_name
+      @key = key
+    end
+
+    # Public: sends the email to the specified recipients.
+    #
+    # opts  - The Hash containing the email sending options.
+    #
+    #         :from
+    #         :to
+    #         :reply_to
+    #         :subject
+    #
+    # block - The block for customizing the email sending.
+    #
+    def send(opts = {}, &block)
+      unless block_given?
+        mailer.send(:mail, opts) do |format|
+          format.html { mailer.render :text => content }
+        end
+      else
+        yield content
+      end
+    end
+
+    # Public: returns the email content body.
+    #
+    # Returns: the rendered template or the mapped page content body.
+    #
+    def content
+      return @content if @content.present?
+      page = Xhive::Mapper.page_for(site, resource, action, key)
+      @content = page.present? ? page.present_content(mailer_instance_variables(mailer)) : mailer.render
+    end
+
+  private
+
+    # Private: extracts the instance variables from the mailer object.
+    #
+    # mailer - The ActionMailer::Base object.
+    #
+    # Returns: a Hash with all the instance variables instantiated.
+    #
+    def mailer_instance_variables(mailer)
+      internal_vars = [:@_routes, :@_action_has_layout, :@_message, :@_prefixes, :@_lookup_context, :@_action_name, :@_response_body]
+      vars = mailer.instance_variables - internal_vars
+      opts = {}
+      vars.each {|v| opts[v.slice(1..-1).to_sym] = mailer.instance_variable_get(v)}
+      opts
+    end
+  end
+end

data/lib/xhive/router/cells.rb

@@ -39,9 +39,9 @@ module Xhive
           cell, action = options[:to].split('#')
           widgets_base_route = Base.route_for('widgets', 'show').gsub(/\/\*\w*$/, '')
           widget_route = "#{widgets_base_route}/#{path}"
-          tag_class_name = "#{cell}_#{action}".camelize
+          tag_class_name = (options[:as] || "#{cell}_#{action}").to_s.classify.gsub('::', '')
 
-          Route.add(widget_route, cell.camelize, action)
+          Route.add(widget_route, cell, action, options.except(:to))
 
           Xhive::TagFactory.create_class(tag_class_name, widget_route)
         end

data/lib/xhive/router/route.rb

@@ -3,13 +3,15 @@ module Xhive
     class Route
       @@routes = []
 
-      attr :route, :klass, :action, :args
+      attr :route, :klass, :action, :args, :inline, :as
 
-      def initialize(route, klass, action)
+      def initialize(route, klass, action, opts={})
         @route = route
         @klass = klass
         @action = action
         @args = extract_args(route)
+        @inline = opts[:inline] || false
+        @as = opts[:as].to_s || klass
       end
 
       # Public: adds a new route to the collection.
@@ -17,9 +19,10 @@ module Xhive
       # route  - The String containing the route definition.
       # klass  - The String containing the Controller/Cell class name.
       # action - The String containing the action name.
+      # inline - The Boolean indicating if it should be rendered inline or as an AJAX widget.
       #
-      def self.add(route, klass, action)
-        @@routes << new(route, klass, action)
+      def self.add(route, klass, action, inline)
+        @@routes << new(route, klass, action, inline)
       end
 
       # Public: finds the route that matches the url.

data/lib/xhive/version.rb

@@ -1,3 +1,3 @@
 module Xhive
-  VERSION = "1.0.9.pre"
+  VERSION = "1.2.0.pre"
 end

data/lib/xhive.rb

@@ -4,6 +4,8 @@ module Xhive
 end
 
 require 'xhive/hashy'
+require 'xhive/liquid_wrapper'
+require 'xhive/mailer'
 require 'xhive/controller'
 require 'xhive/presentable'
 require 'xhive/router'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xhive
 version: !ruby/object:Gem::Version
-  version: 1.0.9.pre
+  version: 1.2.0.pre
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-02 00:00:00.000000000 Z
+date: 2012-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -156,7 +156,23 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: shoulda
+  name: shoulda-context
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -216,6 +232,8 @@ files:
 - app/assets/javascripts/xhive/pages.js
 - app/assets/stylesheets/xhive/application.css
 - app/assets/stylesheets/xhive/pages.css
+- app/cells/base_cell.rb
+- app/cells/xhive/stylesheet_cell.rb
 - app/controllers/xhive/application_controller.rb
 - app/controllers/xhive/images_controller.rb
 - app/controllers/xhive/pages_controller.rb
@@ -250,6 +268,8 @@ files:
 - lib/xhive/controller.rb
 - lib/xhive/engine.rb
 - lib/xhive/hashy.rb
+- lib/xhive/liquid_wrapper.rb
+- lib/xhive/mailer.rb
 - lib/xhive/presentable.rb
 - lib/xhive/router/base.rb
 - lib/xhive/router/cells.rb
@@ -277,7 +297,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1538157182709527364
+      hash: -4002595324166210209
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: