manatee 0.0.1.pre1

data/app/assets/javascripts/manatee/renderer.js.erb

@@ -0,0 +1,53 @@
+I18n.defaultLocale = <%= Manatee.default_locale.to_s.inspect %>;
+I18n.locale        = <%= Manatee.locale.to_s.inspect %>;
+
+var <%= Manatee.template_namespace %> = <%= Manatee.template_namespace %> || {};
+var <%= Manatee.renderer_namespace %> = {};
+
+(function(){
+  function _pushStack(view_name, params){
+    var old_params = {};
+    for(key in params){
+      old_params[key] = this[key];
+      this[key]       = params[key];
+    }
+    this._rendering_stack.push( [view_name, old_params] );
+  }
+
+  function _popStack(){
+    var stack = this._rendering_stack.pop();
+    for(key in stack[1]){
+      this[key] = stack[1][key];
+    }
+  }
+
+  function render(view_name, params){
+    params = params || {};
+    _pushStack.call(this, view_name, params);
+    var result = this._templates[view_name].call(this, this);
+    _popStack.call(this);
+    return result;
+  }
+
+  function helper(name, block){
+    this[name] = block.bind(this);
+  }
+
+  function alias(name, aliased_name){
+    this[name] = this[aliased_name];
+  }
+
+  function cleanStack(){
+    this._rendering_stack = [];
+  }
+
+  this.alias            = alias.bind(this);
+  this.helper           = helper.bind(this);
+  this._templates       = <%= Manatee.template_namespace %>;
+  this._context         = <%= Manatee.context.to_json %>;
+  this._rendering_stack = [];
+
+  this.helper('render',     render);
+  this.helper('cleanStack', cleanStack);
+
+}).call(<%= Manatee.renderer_namespace %>);

data/app/assets/javascripts/manatee_railsless.js

@@ -0,0 +1 @@
+//= require ./manatee/helpers

data/lib/manatee.rb

@@ -0,0 +1,87 @@
+lib = File.expand_path '..', __FILE__
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'json'
+require 'execjs'
+require 'i18n-js'
+require 'sprockets'
+
+require 'manatee/version'
+
+require 'manatee/config'
+require 'manatee/handler'
+require 'manatee/sprockets'
+
+if defined? Rails
+  require 'manatee/rails'
+end
+
+module Manatee
+  def self.default_config(name, value = nil)
+    define_singleton_method(name) do
+      variable = :"@#{name}"
+      if instance_variable_defined? variable
+        instance_variable_get variable
+      else
+        if block_given?
+          instance_variable_set variable, yield(self)
+        else
+          instance_variable_set variable, value
+        end
+      end
+    end
+  end
+
+  default_config :request_forgery_protection_token, :authenticity_token
+  default_config :protect_from_forgery, true
+
+  default_config :router_namespace,   'RR'
+  default_config :renderer_namespace, 'Renderer'
+  default_config :template_namespace, 'JST'
+
+  default_config :views_asset, 'views'
+  default_config :full_domain, 'http://localhost:3000'
+
+  default_config(:locale){ |c| I18n.locale }
+  default_config(:default_locale){ |c| I18n.default_locale }
+
+  default_config :force_domain,        false
+  default_config :force_assets_domain, false
+
+  default_config :default_format, javascript: :js, stylesheet: :css
+
+  default_config :assets_domain, 'http://localhost:3000'
+
+  default_config(:fonts_domain){ |c| c.assets_domain }
+  default_config(:audios_domain){ |c| c.assets_domain }
+  default_config(:videos_domain){ |c| c.assets_domain }
+  default_config(:images_domain){ |c| c.assets_domain }
+  default_config(:javascript_domain){ |c| c.assets_domain }
+  default_config(:stylesheet_domain){ |c| c.assets_domain }
+
+  default_config :assets_path, '/assets'
+
+  default_config(:fonts_path){ |c| c.assets_path + '/fonts' }
+  default_config(:audios_path){ |c| c.assets_path + '/audios' }
+  default_config(:videos_path){ |c| c.assets_path + '/videos' }
+  default_config(:images_path){ |c| c.assets_path + '/images' }
+  default_config(:javascript_path){ |c| c.assets_path + '/javascripts' }
+  default_config(:stylesheet_path){ |c| c.assets_path + '/stylesheets' }
+
+  def self.assets
+    if defined? Rails
+      ::Rails.application.assets
+    else
+      @assets or raise("Manatee's Sprockets environment is not configured, call: Manatee.config{ |c| c.assets = sprockets_environment }")
+    end
+  end
+
+  def self.config(&block)
+    yield Manatee::Config.new
+  end
+
+  def self.context
+    Manatee::Config.context
+  end
+
+end

data/lib/manatee/config.rb

@@ -0,0 +1,51 @@
+module Manatee
+  class Config
+    def self.context
+      domain = {
+        app:        Manatee.full_domain,
+        asset:      Manatee.assets_domain,
+        font:       Manatee.fonts_domain,
+        audio:      Manatee.audios_domain,
+        video:      Manatee.videos_domain,
+        image:      Manatee.images_domain,
+        javascript: Manatee.javascript_domain,
+        stylesheet: Manatee.stylesheet_domain
+      }
+
+      default_path = {
+        asset:      Manatee.assets_path,
+        font:       Manatee.fonts_path,
+        audio:      Manatee.audios_path,
+        video:      Manatee.videos_path,
+        image:      Manatee.images_path,
+        javascript: Manatee.javascript_path,
+        stylesheet: Manatee.stylesheet_path
+      }
+
+      force_asset_domain = Manatee.force_assets_domain || Manatee.full_domain != Manatee.assets_domain
+
+      {
+        domain:                        domain,
+        forceDomain:                   Manatee.force_domain,
+        defaultPath:                   default_path,
+        defaultFormat:                 Manatee.default_format,
+        forceAssetDomain:              force_asset_domain,
+        protectFromForgery:            Manatee.protect_from_forgery,
+        requestForgeryProtectionToken: Manatee.request_forgery_protection_token
+      }
+    end
+
+    def method_missing(method, *args, &block)
+      str_method = method.to_s
+      if str_method[-1] == '=' && Manatee.methods(false).include?(str_method[0..-2].to_sym)
+        if block_given?
+          Manatee.default_config str_method[0..-2].to_sym, &block
+        else
+          Manatee.instance_variable_set :"@#{str_method[0..-2]}", args.first
+        end
+      else
+        super method, *args, &block
+      end
+    end
+  end
+end

data/lib/manatee/handler.rb

@@ -0,0 +1,45 @@
+require 'singleton'
+
+module Manatee
+  class Handler
+    include Singleton
+
+    def eval_template(identifier, params = {})
+      context.call javascript_template_code(identifier, params), params
+    end
+
+    def eval(javascript_code)
+      context.eval javascript_code
+    end
+
+    def context
+      check_context
+      @context
+    end
+
+    def reset!
+      @context = nil
+    end
+
+    protected
+    def javascript_template_code(identifier, params)
+      token = params[:csrf_token] ? params[:csrf_token].inspect : false
+      "(function(){ this.csrfToken = #{token}; return #{Manatee.template_namespace}[#{ identifier.inspect }]; }).call(#{Manatee.renderer_namespace})"
+    end
+
+    def check_context
+      load_context if !instance_variable_get(:@context) || @last_mtime != views_asset.mtime
+    end
+
+    def load_context
+      asset       = views_asset
+      @last_mtime = asset.mtime
+      @context    = ExecJS.compile asset.source
+    end
+
+    def views_asset
+      Manatee.assets[ Manatee.views_asset ]
+    end
+
+  end
+end

data/lib/manatee/rails.rb

@@ -0,0 +1,6 @@
+require 'manatee/rails/helper'
+require 'manatee/rails/handler'
+require 'manatee/rails/resolver'
+require 'manatee/rails/extensions'
+require 'manatee/rails/hash_visitor'
+require 'manatee/rails/routes_compiler'

data/lib/manatee/rails/extensions.rb

@@ -0,0 +1,23 @@
+module ActionDispatch::Journey
+  module Nodes
+    class Node
+      def compile_hash
+        Manatee::Rails::HashVisitor.new.accept self
+      end
+    end
+  end
+end
+
+# This is required to Rails for using app directory
+module Manatee
+  class Engine < ::Rails::Engine
+  end
+
+  # This method must be used to hook Manatee into Rails
+  def self.subscribe_on_rails
+    ActionView::Base.send :include, Manatee::Rails::Helper
+    ApplicationController.prepend_view_path Manatee::Rails::Resolver.new(Manatee.views_asset)
+    ActionView::Template.register_template_handler :'jst', Manatee::Rails::Handler.instance
+    Manatee::Sprockets::JshProcessor.subscribe ::Rails.application.assets
+  end
+end

data/lib/manatee/rails/handler.rb

@@ -0,0 +1,16 @@
+module Manatee
+  module Rails
+    class Handler < Manatee::Handler
+
+      def self.default_format
+        Mime::HTML
+      end
+
+      def call(template)
+        identifier = template.identifier
+        "Manatee::Handler.instance.eval_template #{ identifier.inspect }, self.assigns.except('marked_for_same_origin_verification').merge(csrf_token: form_authenticity_token)"
+      end
+
+    end
+  end
+end

data/lib/manatee/rails/hash_visitor.rb

@@ -0,0 +1,35 @@
+module Manatee
+  module Rails
+    class HashVisitor < ActionDispatch::Journey::Visitors::Visitor
+
+      private
+      def visit_GROUP(node)
+        {
+          type:       node.type,
+          children: [ visit(node.left) ]
+        }
+      end
+
+      def terminal(node)
+        {
+          type:  node.type,
+          value: node.left.to_s
+        }
+      end
+
+      def binary(node)
+        {
+          type:      node.type,
+          children:[ visit(node.left), visit(node.right) ]
+        }
+      end
+
+      def nary(node)
+        {
+          type:     node.type,
+          children: node.children.map{ |c| visit c }
+        }
+      end
+    end
+  end
+end

data/lib/manatee/rails/helper.rb

@@ -0,0 +1,9 @@
+module Manatee
+  module Rails
+    module Helper
+      def csrf_meta_tags
+        (super + content_tag(:script, "Renderer.csrfToken = #{form_authenticity_token.inspect};".html_safe))
+      end
+    end
+  end
+end

data/lib/manatee/rails/resolver.rb

@@ -0,0 +1,70 @@
+module Manatee
+  module Rails
+    class Resolver < ActionView::Resolver
+
+      def initialize(jst_template_path)
+        super()
+        @jst_template_path = jst_template_path
+      end
+
+      protected
+      def find_templates(name, prefix, partial, details)
+        if details[:handlers].include? :jst
+          path    = normalize_path prefix, name, partial
+          locales = normalize_array details[:locale]
+          formats = normalize_array details[:formats]
+
+          templates = []
+          formats.each do |format|
+            locales.each do |locale|
+              template = find_asset_template path, locale, format
+              templates << template if template
+            end
+          end
+
+          templates
+        else
+          []
+        end
+      end
+
+      def find_asset_template(path, locale, format)
+        identifier = [normalize_identifier(path), locale, format].compact.join '.'
+        build_template Manatee.assets["#{identifier}.jst"], path, identifier, format
+      end
+
+      def normalize_path(prefix, name, partial)
+        name = partial ? "_#{name}" : name
+        prefix.present? ? "#{prefix}/#{name}" : name
+      end
+
+      def normalize_identifier(path)
+        "#{@jst_template_path}/#{path}"
+      end
+
+      def normalize_array(array)
+        return [nil] if array.blank?
+        normalized_array = array.map(&:to_s).uniq.compact
+        normalized_array << nil
+      end
+
+      def build_template(asset, path, identifier, format)
+        return nil unless asset
+
+        source     = asset.source
+        identifier = identifier
+        handler    = ActionView::Template.registered_template_handler :jst
+
+        format = format ? Mime[format] : Mime::HTML
+        details = {
+          format:       format,
+          updated_at:   asset.mtime,
+          virtual_path: path
+        }
+
+        ActionView::Template.new source, identifier, handler, details
+      end
+
+    end
+  end
+end

data/lib/manatee/rails/routes_compiler.rb

@@ -0,0 +1,34 @@
+module Manatee
+  module Rails
+    class RoutesCompiler
+      def compile
+        named_routes.map do |name|
+          compile_route name, named_routes[name].path
+        end
+      end
+
+      protected
+      def compile_route(name, path)
+        {
+          name:           name.to_s,
+          helper_name:    helper_name(name),
+          names:          path.names,
+          optional_names: path.optional_names,
+          required_names: path.required_names,
+          ast:            path.spec.compile_hash
+        }
+      end
+
+      def helper_name(name)
+        helper_name    = name.to_s.camelize
+        helper_name[0] = helper_name[0].downcase
+        helper_name
+      end
+
+      def named_routes
+        ::Rails.application.routes.named_routes
+      end
+
+    end
+  end
+end