xhive 1.0.0.pre

data/db/migrate/20121012191751_create_xhive_sites.rb

@@ -0,0 +1,10 @@
+class CreateXhiveSites < ActiveRecord::Migration
+  def change
+    create_table :xhive_sites do |t|
+      t.string :name
+      t.string :domain
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20121012193105_create_xhive_pages.rb

@@ -0,0 +1,14 @@
+class CreateXhivePages < ActiveRecord::Migration
+  def change
+    create_table :xhive_pages do |t|
+      t.string :name
+      t.string :title
+      t.text :content
+      t.string :meta_keywords
+      t.text :meta_description
+      t.string :slug
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20121013235227_add_home_page_to_xhive_sites.rb

@@ -0,0 +1,5 @@
+class AddHomePageToXhiveSites < ActiveRecord::Migration
+  def change
+    add_column :xhive_sites, :home_page_id, :integer
+  end
+end

data/db/migrate/20121013235306_add_site_to_xhive_pages.rb

@@ -0,0 +1,6 @@
+class AddSiteToXhivePages < ActiveRecord::Migration
+  def change
+    add_column :xhive_pages, :site_id, :integer
+    add_index :xhive_pages, :site_id
+  end
+end

data/db/migrate/20121016224054_create_xhive_stylesheets.rb

@@ -0,0 +1,13 @@
+class CreateXhiveStylesheets < ActiveRecord::Migration
+  def change
+    create_table :xhive_stylesheets do |t|
+      t.belongs_to :site
+      t.string     :name
+      t.text       :content
+      t.string     :slug
+
+      t.timestamps
+    end
+    add_index :xhive_stylesheets, [:site_id, :slug], :unique => true
+  end
+end

data/db/migrate/20121016224326_add_slug_index_to_pages.rb

@@ -0,0 +1,5 @@
+class AddSlugIndexToPages < ActiveRecord::Migration
+  def change
+    add_index :xhive_pages, [:site_id, :slug], :unique => true
+  end
+end

data/db/migrate/20121019185702_create_xhive_mappers.rb

@@ -0,0 +1,13 @@
+class CreateXhiveMappers < ActiveRecord::Migration
+  def change
+    create_table :xhive_mappers do |t|
+      t.string  :resource
+      t.string  :action
+      t.integer :page_id
+      t.integer :site_id
+
+      t.timestamps
+    end
+    add_index :xhive_mappers, [:site_id, :resource, :action]
+  end
+end

data/lib/tasks/xhive_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :xhive do
+#   # Task goes here
+# end

data/lib/xhive/base_tag.rb

@@ -0,0 +1,89 @@
+require 'uri'
+require 'liquid'
+
+module Xhive
+  class BaseTag < ::Liquid::Tag
+    # Public: initializes the tag. Also stores the passed attributes.
+    #
+    # Example: transforms this liquid meta tag {% some_tag attr1:foo attr2:bar %}
+    #          into #<SomeTag attributes: { :attr1 => 'foo', :attr2 => 'bar' }>
+    #
+    def initialize(tag_name, markup, tokens)
+      @attributes = {}
+      markup.scan(::Liquid::TagAttributes) do |key, value|
+        # Remove single or double quotes around the quoted fragment before storing them in attributes
+        @attributes[key.to_sym] = value.gsub("'",'').gsub('"','')
+      end
+      super
+    end
+
+    # Public: renders the tag.
+    #
+    # context - The hash containing a set of external attributes.
+    #
+    # Returns: the rendered tag or a list of errors.
+    #
+    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>"
+      else
+        errors
+      end
+    end
+
+  private
+
+    # Private: checks the attributes to see if there is any required
+    #          param missing.
+    #
+    # Returns: a list with the error descriptions.
+    #
+    def check_parameters
+      errors = ""
+      @url.scan(/:(\w*)/).flatten.map(&:to_sym).each do |arg|
+        errors += "<li><p>parameter '#{arg.to_s}' is required</p></li>" unless @attributes.has_key?(arg)
+      end
+      errors.empty? ? "" : "<ul>#{errors}</ul>"
+    end
+
+    # Private: replaces any REST-like attributes in the url.
+    #
+    # Returns: a new url with populated parameters.
+    #
+    def rest_url
+      URI.encode(@url.gsub(/:(\w*)/) { "%{#{$1}}" } % @attributes)
+    end
+
+    # Private: replaces each attribute with its actual value.
+    #
+    def process_parameters(context)
+      @attributes.each {|k, v| @attributes[k] = process_value(v, context)}
+    end
+
+    # Private: transforms a parameters hash into a query string.
+    #
+    def parameters_to_args
+      @attributes.except(:id).map {|k,v| "#{k.to_s}=#{CGI.escape(v.to_s.gsub(/\'/,'').gsub(/\"/,''))}"}.join("&")
+    end
+
+    # Private: checks if the value is a meta variable and grabs its value from the context if so.
+    #
+    # Returns: the raw attribute value or the context value.
+    #
+    def process_value(value, context)
+      # If the value contains a meta variable, get it from the context
+      if value =~ /\{\{(.*)\}\}/
+        context[$1]
+      else
+        value
+      end
+    end
+  end
+end
+
+

data/lib/xhive/controller.rb

@@ -0,0 +1,24 @@
+module Xhive
+  module Controller
+    def current_controller
+      self.class_variable_get "@@current_controller"
+    end
+
+    def self.extended(base)
+      base.class_eval do
+        @@current_controller = nil
+
+        include InstanceMethods
+
+        prepend_before_filter :set_current_controller
+      end
+    end
+  end
+
+  module InstanceMethods
+    # This is to access the current_controller from within presenters
+    def set_current_controller
+      @@current_controller = self
+    end
+  end
+end

data/lib/xhive/engine.rb

@@ -0,0 +1,24 @@
+require "cells"
+
+module Xhive
+  class Engine < ::Rails::Engine
+    isolate_namespace Xhive
+    ::Cell::Base.prepend_view_path('app/cells')
+    initializer "xhive.extend_application_controller" do
+      ActiveSupport.on_load(:action_controller) do
+        extend Xhive::Widgify
+        extend Xhive::Controller
+
+        include Xhive::ApplicationHelper
+
+        helper_method :initialize_widgets_loader
+      end
+    end
+    initializer "xhive.load_all_controller_classes" do
+      ActiveSupport.on_load(:action_controller) do
+        Rails.application.reload_routes!
+        Dir[Rails.root.join("app/controllers/**/*.rb")].each {|f| require f}
+      end
+    end
+  end
+end

data/lib/xhive/hashy.rb

@@ -0,0 +1,42 @@
+module Xhive
+  # Adds the ability to get/set an attribute using the dot operator
+  #
+  # Examples
+  #
+  #   a = Hashy.new
+  #   a.foo # => nil
+  #   a.foo = 'bar'
+  #   a.foo # => 'bar'
+  #
+  #   a = Hashy.new(:foo => 'bar')
+  #   a.foo # => 'bar'
+  #   a.duu # => nil
+  #
+  class Hashy < Hash
+    # Public: initializer
+    #
+    # attrs - The Hash containing the initial elements (default: {})
+    #
+    # Returns an instance of Hashy
+    def initialize(attrs={})
+      super
+      attrs.each {|k,v| self[k.to_sym] = v }
+    end
+
+  private
+
+    def method_missing(sym, *args, &block)
+      # If I receive a method with the form 'foo='
+      if sym.to_s =~ /=/
+        attr = sym.to_s.scan(/(\w*)=/)
+        self[attr[0][0].to_sym] = args[0] unless attr.empty?
+      elsif sym.to_s =~ /^.*\?$/
+        attr = sym.to_s.scan(/(\w*)\?/)
+        self.fetch(attr[0][0].to_sym, false) ? true : false
+      else
+        # This should be the standard behavior with []
+        self.fetch(sym, nil)
+      end
+    end
+  end
+end

data/lib/xhive/presentable.rb

@@ -0,0 +1,28 @@
+module Xhive
+  module Presentable
+    def presenter
+      klass = presenter_class.constantize
+      klass.new(self)
+    end
+
+    def presenter_class
+      self.class.klass_name || "#{self.class.name}Presenter"
+    end
+
+    module ClassMethods
+      @klass_name = nil
+
+      def presenter_class=(class_name)
+        @klass_name = class_name
+      end
+
+      def klass_name
+        @klass_name
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/xhive/router/base.rb

@@ -0,0 +1,61 @@
+module Xhive
+  module Router
+    class Base
+      # Public: returns the route that matches the url.
+      #
+      # url - The String containing the url to match.
+      #
+      # Returns: an Route object.
+      #
+      def self.match(url)
+        Route.find(url)
+      end
+
+      # Public: returns the route definition for a controller#action pair.
+      #
+      # controller - The String containing the controller name.
+      # action     - The String containing the action name.
+      #
+      # Returns: the route definition. e.g. 'pages/:id/show'.
+      #
+      def self.route_for(controller, action)
+        routes = normalized_routes
+        url = routes.to_a.select {|route| route[:end_point] == "#{controller}##{action}"}.first.fetch(:path)
+        url = url.gsub('(.:format)', '')
+        url
+      rescue
+        fail Error, "#{controller}##{action}"
+      end
+
+    private
+
+      # Private: joins the Rails application routes and the Xhive::Engine routes.
+      #
+      # Returns: an array of normalized routes.
+      #
+      def self.normalized_routes
+        load_routes_for(Rails.application.routes) | load_routes_for(Xhive::Engine.routes)
+      end
+
+      # Private: returns an array of normalized routes.
+      #
+      # Example: [{:end_point => 'pages#show', :path => '/pages/:id/show'}]
+      #
+      # Returns: an array with a set of normalized routes.
+      #
+      def self.load_routes_for(router)
+        # TODO: find another way to get the routes prefix. This might get changed as is not public API.
+        mount_point = router._generate_prefix({}).to_s
+        routes = router.routes.to_a
+        routes.collect do |route|
+          if route.requirements[:controller] && route.requirements[:action]
+            controller = route.requirements[:controller].gsub(/rails\/|xhive\//, '')
+            action = route.requirements[:action]
+            path = route.path.spec.to_s
+            { :end_point => "#{controller}##{action}", :path => "#{mount_point}#{path}" }
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/xhive/router/cells.rb

@@ -0,0 +1,36 @@
+module Xhive
+  module Router
+    class Cells
+      # Public: draws the internal widget routes for cell based widgets.
+      #
+      # Example:
+      #
+      #   Xhive::Routes.draw do |router|
+      #     mount 'my_widget', :to => 'my_cell#action'
+      #   end
+      #
+      def self.draw
+        Rails.application.reload_routes!
+        yield self
+      end
+
+      # Public: mounts a cell based route and creates the Liquid tag.
+      #
+      # route   - The String containing the route.
+      # options - The Hash containing the route endpoint.
+      #
+      # Example: mount 'my_widget', :to => 'my_cell#action'
+      #
+      def self.mount(route, options)
+        cell, action = options[:to].split('#')
+        widgets_base_route = Base.route_for('widgets', 'show').gsub(/\/\*\w*$/, '')
+        widget_route = "#{widgets_base_route}/#{route}"
+        tag_class_name = "#{cell}_#{action}".classify
+
+        Route.add(widget_route, cell.classify, action)
+
+        Xhive::TagFactory.create_class(tag_class_name, widget_route)
+      end
+    end
+  end
+end

data/lib/xhive/router/error.rb

@@ -0,0 +1,14 @@
+module Xhive
+  module Router
+    class Error < StandardError
+      def initialize(action)
+        @action = action
+        super
+      end
+
+      def message
+        "No route was found for action #{@action}"
+      end
+    end
+  end
+end

data/lib/xhive/router/route.rb

@@ -0,0 +1,77 @@
+module Xhive
+  module Router
+    class Route
+      @@routes = []
+
+      attr :route, :klass, :action, :args
+
+      def initialize(route, klass, action)
+        @route = route
+        @klass = klass
+        @action = action
+        @args = extract_args(route)
+      end
+
+      # Public: adds a new route to the collection.
+      #
+      # route  - The String containing the route definition.
+      # klass  - The String containing the Controller/Cell class name.
+      # action - The String containing the action name.
+      #
+      def self.add(route, klass, action)
+        @@routes << new(route, klass, action)
+      end
+
+      # Public: finds the route that matches the url.
+      #
+      # url - The String containing the url.
+      #
+      # Returns: a Route object that matches the url.
+      #
+      def self.find(url)
+        @@routes.select {|r| r.matches?(url) }.first
+      end
+
+      # Public: checks if the route matches the url.
+      #
+      # url - The String containing the url to match.
+      #
+      # Returns: true or false.
+      #
+      def matches?(url)
+        !!(matcher =~ url)
+      end
+
+      # Public: returns the parameters present in the url.
+      #
+      # url - The String containing the url.
+      #
+      # Returns: a hash of the form { :id => '1', :name => 'john' }
+      #
+      def params_from(url)
+        values = url.scan(matcher).flatten
+        params = Hash[args.zip values]
+      end
+
+    private
+
+      # Private: returns a regexp matcher for the route.
+      #
+      # Returns: a Regexp object with the route matcher.
+      #
+      def matcher
+        Regexp.new("^#{route.gsub(/\:[-\w]*/, '([-\w]*)')}$")
+      end
+
+      # Private: extracts the argument names from a given url.
+      #
+      # url - The String containing the url.
+      #
+      # Returns: an array of argument names.
+      #
+      def extract_args(url)
+        variables = url.scan(/:([-\w]*)/).flatten.map(&:to_sym)
+      end
+    end
+  end
+end

data/lib/xhive/router.rb

@@ -0,0 +1,10 @@
+module Xhive
+  module Router
+  end
+end
+
+require 'xhive/router/error'
+require 'xhive/router/base'
+require 'xhive/router/route'
+require 'xhive/router/cells'
+

data/lib/xhive/tag_factory.rb

@@ -0,0 +1,21 @@
+module Xhive
+  class TagFactory
+    # Public: creates and registers the tag class for a specific name/url pair.
+    #
+    # name - The String containing the widget name.
+    # url  - The String containing the widget url.
+    #
+    def self.create_class(name, url)
+      klass = Class.new(Xhive::BaseTag) do
+        const_set 'URL', url
+        def initialize(tag_name, markup, tokens)
+          @url = self.class.const_get 'URL'
+          super
+        end
+      end
+
+      Liquid.const_set name, klass
+      Liquid::Template.register_tag(name.underscore, "Liquid::#{name}".constantize)
+    end
+  end
+end

data/lib/xhive/version.rb

@@ -0,0 +1,3 @@
+module Xhive
+  VERSION = "1.0.0.pre"
+end

data/lib/xhive/widgify.rb

@@ -0,0 +1,53 @@
+module Xhive
+  module Widgify
+    # Public: remove layout from action and create Liquid tag class.
+    #
+    # actions - The array of actions to widgify.
+    #
+    def widgify(*actions)
+      actions.each do |action|
+        remove_layout_for_action(action)
+        Xhive::TagFactory.create_class(tag_name_for(action), route_for(action))
+      end
+    end
+
+    # Public: creates an array with the actions to exclude from layout.
+    #
+    def self.extended(base)
+      base.class_variable_set "@@widgets_list", []
+    end
+
+  private
+
+    # Private: returns the route definition for a controller#action pair.
+    #
+    # action - The string with the action name.
+    #
+    # Returns: the route definition. e.g. 'pages/:id/show'.
+    #
+    def route_for(action)
+      Xhive::Router::Base.route_for(controller_name, action)
+    end
+
+    # Private: builds the tag name for a given action.
+    #
+    # action - The string with the action name.
+    #
+    # Returns: the tag name.
+    #
+    def tag_name_for(action)
+      controller_name = self.name.gsub(/Controller|Xhive|::/, '')
+      tag_name = "#{controller_name}#{action.capitalize}"
+    end
+
+    # Private: adds the action to the widgets list and sets the layout to false.
+    #
+    # action - The string with the action name.
+    #
+    def remove_layout_for_action(action)
+      self.class_variable_get("@@widgets_list") << action.to_sym
+      self.layout :false, :only => self.class_variable_get("@@widgets_list")
+    end
+  end
+end
+

data/lib/xhive.rb

@@ -0,0 +1,12 @@
+require "xhive/engine"
+
+module Xhive
+end
+
+require 'xhive/hashy'
+require 'xhive/controller'
+require 'xhive/presentable'
+require 'xhive/router'
+require 'xhive/base_tag'
+require 'xhive/tag_factory'
+require 'xhive/widgify'