paloma 1.2.6 → 2.0.0

data/app/templates/application/_locals.js

@@ -0,0 +1,13 @@
+(function(){
+  // Initializes locals container for the global scope.
+  // All _locals.js file will inherit all locals here by default.
+  //
+  // Define a local by adding property to 'locals'.
+  //
+  // Example:
+  // locals.localMethod = function(){};
+  var locals = Paloma.locals['/'] = {};
+
+  
+  // ~> Start local definitions here and remove this line.
+})();

data/app/templates/controller/_locals.js

@@ -0,0 +1,19 @@
+(function(){
+  // Initializes callbacks container for the this specific scope.
+  Paloma.callbacks[':controller_path'] = {};
+
+  // Initializes locals container for this specific scope.
+  // Define a local by adding property to 'locals'.
+  //
+  // Example:
+  // locals.localMethod = function(){};
+  var locals = Paloma.locals[':controller_path'] = {};
+
+  
+  // ~> Start local definitions here and remove this line.
+
+
+  // Remove this line if you don't want to inherit locals defined
+  // on parent's _locals.js
+  Paloma.inheritLocals({from : ':parent', to : ':controller_path'});
+})();

data/app/templates/controller/_manifest.js

@@ -0,0 +1,3 @@
+//= require ./_locals.js
+//= require ./_filters.js
+//= require_tree .

data/app/templates/controller/action.js

@@ -0,0 +1,23 @@
+(function(){
+  // You access variables from before/around filters from _x object.
+  // You can also share variables to after/around filters through _x object.
+  var _x = Paloma.variableContainer;
+
+  // We are using _L as an alias for the locals container.
+  // Use either of the two to access locals from other scopes.
+  //
+  // Example:
+  // _L.otherController.localVariable = 100;
+  var _L = Paloma.locals;
+
+  // Access locals for the current scope through the _l object.
+  //
+  // Example:
+  // _l.localMethod(); 
+  var _l = _L[':controller_path'];
+
+
+  Paloma.callbacks[':controller_path'][':action'] = function(params){
+    // Do something here.
+  };
+})();

data/app/templates/index.js

@@ -1 +1,3 @@
-//= require ./paloma.js
+//= require paloma_core.js
+//= require ./_locals.js
+//= require ./_filters.js

data/app/templates/namespace/_locals.js

@@ -0,0 +1,16 @@
+(function(){
+  // Initializes locals container for this specific scope.
+  // Define a local by adding property to 'locals'.
+  //
+  // Example:
+  // locals.localMethod = function(){};
+  var locals = Paloma.locals[':namespace'] = {};
+
+  
+  // ~> Start local definitions here and remove this line.
+
+
+  // Remove this line if you don't want to inherit locals defined
+  // on parent's _locals.js
+  Paloma.inheritLocals({from : '/', to : ':namespace'});
+})();

data/app/templates/namespace/_manifest.js

@@ -0,0 +1,3 @@
+//= require ./_locals.js
+//= require ./_filters.js
+//= require ./:controller/_manifest.js

data/app/views/paloma/_callback_hook.html.erb

@@ -2,34 +2,39 @@
 
 <div class="callback-details" id="callback-details-<%= callback_details_id %>">
   <script type="text/javascript">
-    var id = "callback-details-<%= callback_details_id %>",
-      callbacks = [];
+    (function(){
       
-    // Remove any callback details if any 
-    $('.callback-details[id!=" + id + "]').remove(); 
-    
-    
-    // Convert callbacks to javascript variable      
-    <% callbacks.each do |callback| %>
-      callbacks.push({
-        name: '<%= callback[:name] %>', 
-        params: eval($('<div/>').html("(<%= callback[:params].to_json %>)").text())
-      }); 
-    <% end %>
-    
-    
-    // Run Callbacks
-    $(document).ready(function(){
-      for (var i = 0, len = callbacks.length; i < len; i++){
-        var callback = callbacks[i],
-          callbackFunction = Paloma.callbacks[callback.name];
+      // Do not continue if Paloma.js is not found.
+      if (window['Paloma'] === undefined && window['console'] !== undefined){
+        console.warn("Paloma.js not found. Require it in your application.js.");
+        return true;
+      }
+      
+      
+      var id = "callback-details-<%= callback_details_id %>",
+        callbacks = [];
         
-        console.log("Paloma: Fetching [" + callback.name + "]");      
-        if (callbackFunction != undefined){
-          console.log("Paloma: Calling [" + callback.name + "]");
-          callbackFunction(callback.params);
+      // Remove any callback details if any 
+      $('.callback-details[id!=" + id + "]').remove(); 
+      
+      
+      // Convert callbacks to javascript variable      
+      <% callbacks.each do |callback| %>
+        callbacks.push({
+          controller: '<%= callback[:controller] %>', 
+          action:     '<%= callback[:action] %>', 
+          params:     eval($('<div/>').html("(<%= callback[:params].to_json %>)").text())
+        }); 
+      <% end %>
+      
+      
+      // Run Callbacks
+      $(document).ready(function(){
+        for (var i = 0, len = callbacks.length; i < len; i++){
+          var callback = callbacks[i];
+          Paloma.execute(callback.controller, callback.action, callback.params);
         }
-      }
-    });
+      });
+    })();
   </script>
 </div>

data/lib/paloma.rb

@@ -19,6 +19,7 @@ module Paloma
   def self.templates
     @templates ||= "#{Paloma.root}/app/templates"
   end
+  
 end
 
 require 'action_controller/railtie'
@@ -30,3 +31,5 @@ require 'paloma/generators/add_generator'
 require 'paloma/generators/setup_generator'
 require 'paloma/action_controller_filters'
 require 'paloma/action_controller_extension'
+require 'paloma/rails/controller_generator'
+require 'paloma/rails/engine'

data/lib/paloma/action_controller_extension.rb

@@ -9,41 +9,43 @@ module Paloma
 
   module ActionControllerExtension
     def redirect_js_hook options = {}, response_status = {}
-      add_to_callbacks @__callback__, @__js_params__
+      add_to_callbacks @__paloma_callback__
       original_redirect_to options, response_status
     end      
     alias_method :redirect_to, :redirect_js_hook
     
     
     #
-    # js_callback false
-    # js_callback :new, :params => {}
-    # js_callback :controller => '', :action => '', :params => {}
-    # js_callback :params => {}
+    # js false
+    # js :new, :params => {}
+    # js :controller => '', :action => '', :params => {}
+    # js :params => {}
     #
-    def js_callback options = {}, extras = {}
-      default_callback = "#{controller_path}/#{action_name}"
+    def js options = {}, extras = {}
+      callback = {:controller => controller_path, :action => action_name}
       params = {}
       
       if options.is_a? Hash
         params = options[:params]
         callback = options[:controller].present? && options[:action].present? ? 
-          "#{options[:controller]}/#{options[:action]}" :
-          default_callback
+          {:controller => options[:controller], :action => options[:action]} :
+          callback
 
       elsif options.is_a? Symbol
         params = extras[:params] 
-        callback = "#{controller_path}/#{options}"
+        callback[:action] = options
       
-      elsif options.nil? || options.is_a?(TrueClass)
-        callback = default_callback
-      
-      else # false
+      elsif options.is_a? FalseClass
         callback = nil
       end
       
-      @__callback__ = callback
-      @__js_params__ = params
+      params ||= {}
+      
+      # Include request details
+      params[:controller_path] = controller_path
+      params[:action] = action_name
+      
+      @__paloma_callback__ = callback.present? ? callback.merge({:params => params}) : nil
     end 
   end
   

data/lib/paloma/action_controller_filters.rb

@@ -4,7 +4,7 @@ module Paloma
     def self.included base
       base.module_eval do
         prepend_view_path "#{Paloma.root}/app/views/"
-        before_filter :js_callback
+        before_filter :js
         after_filter :update_callback, :if => :html_response_from_render?
       end
     end
@@ -18,9 +18,7 @@ module Paloma
 
         
     def update_callback
-      return clear_callbacks if @__callback__.nil?
-
-      add_to_callbacks @__callback__, @__js_params__
+      add_to_callbacks @__paloma_callback__
 
       paloma_txt = view_context.render(
         :partial => "paloma/callback_hook",
@@ -45,10 +43,9 @@ module Paloma
     end
     
     
-    def add_to_callbacks name, params
-      return true if name.nil?
+    def add_to_callbacks callback
       session[:callbacks] ||= []
-      session[:callbacks].push({:name => name, :params => params})
+      session[:callbacks].push(callback) if callback.present?
     end
     
     

data/lib/paloma/generators/add_generator.rb

@@ -27,114 +27,110 @@ module Paloma
     argument :actions, :type => :array, :required => false
     
     def create_callback_file
-      args = split_arguments(file_path)
+      initialize_arguments file_path
       
-      @namespace_name = args[0]
-      @namespace_folder = args[1]
-      @controller_name = args[2]
-      @controller_folder = args[3]
-      
-      generate_folder(@namespace_folder)
-      generate_folder(@controller_folder)
-
-      # Create a js file for action if there is an action argument
-      if actions.present?
-        generate_actions actions  
-      end
+      generate_namespace_folder if @namespace.present?
+      generate_controller_folder if @controller.present?
+      generate_action_files(actions) if actions.present?
     end
     
     
-    private
     
-    def split_arguments args
-      #split controller from actions
+  private
+    
+    
+    def initialize_arguments args
+      # split controller from actions
       arg = args.split(' ')
+      @controller_path = arg[0]
       
-      #Split namespace from controller
-      namespace = arg[0].split('/')
-      namespace_name = (namespace.length > 1) ? namespace[0] : nil
-      namespace_folder = namespace_name.nil? ? nil : "#{Paloma.destination}/#{namespace_name}"
-            
-      controller_name = namespace_name.nil? ? namespace[0].split(' ')[0] : namespace[1].split(' ')[0]
-      controller_folder = namespace_folder.nil? ? 
-                            "#{Paloma.destination}/#{controller_name}" : 
-                            "#{namespace_folder}/#{controller_name}"
-       
-      # [namespace_name, namespace_folder, controller_name, controller_folder]
-      files = [namespace_name, namespace_folder, controller_name, controller_folder]
+      full_controller_path = @controller_path.split '/'
+      @controller = full_controller_path.pop
+      @namespace = full_controller_path.join '/'
+      @namespace_folder = "#{Paloma.destination}/#{@namespace}" if @namespace 
+      @controller_folder = "#{Paloma.destination}/#{@controller_path}"
     end
     
     
-    def generate_actions actions
-      actions.each do |action|
-        action_js = "#{@controller_folder}/#{action}.js"
-        if action.present? && !File.exists?(action_js)
-          controller_path = @namespace_name.nil? ? @controller_name : "#{@namespace_name}/#{@controller_name}"
-          
-          content = File.read("#{Paloma.templates}/action.js").gsub(
-            /controller\/action/, 
-            "#{controller_path}/#{action}")
-            
-          File.open(action_js, 'w'){ |f| f.write(content) }
-          
-          puts "create #{action_js}"  
-        end
-      end
+    def generate_namespace_folder
+      return true if @namespace_folder.nil? || Dir.exists?(@namespace_folder)
+      
+      Dir.mkdir(@namespace_folder)
+      
+      generate_from_template :template => '/namespace/_locals.js',
+        :filename => "#{@namespace_folder}/_locals.js",
+        :replace => {':namespace' => @namespace}
+        
+      generate_from_template :template => '_filters.js',
+        :filename => "#{@namespace_folder}/_filters.js",
+        :replace => {':scope' => @namespace}
+
+      generate_from_template :template => '/namespace/_manifest.js',
+        :filename => "#{@namespace_folder}/_manifest.js",
+        :replace => {':controller' => @controller}
+      
+      # Require _manifest.js to Paloma's main index file
+      File.open(Paloma.index_js, 'a+'){ |f| 
+        f << "\n//= require ./#{@namespace}/_manifest.js" 
+      }
     end
     
     
-    def generate_folder folder
-      unless (folder.nil? || Dir.exists?(folder))
-        Dir.mkdir(folder)  
-        
-        callbacks_js = "#{folder}/_callbacks.js"
-        local_js = "#{folder}/_local.js"
-        
-        generate_from_template local_js unless File.exists?(local_js)
-        generate_from_template callbacks_js unless File.exists?(callbacks_js)
-        
-        if folder == @namespace_folder
-          content = File.read(callbacks_js).gsub('//= require_tree .', '')
-          File.open(callbacks_js, 'w'){ |f| f.write(content) }
-        end
-        
-        require_callbacks folder  
+    def generate_controller_folder
+      return true if @controller_folder.nil? || Dir.exists?(@controller_folder)
+      
+      Dir.mkdir(@controller_folder)
+      
+      generate_from_template :template => '/controller/_locals.js', 
+        :filename => "#{@controller_folder}/_locals.js",
+        :replace => {
+          ':controller_path' => @controller_path,
+          ':parent' => (@namespace.present? ? @namespace : '/')}
+
+      generate_from_template :template => '_filters.js',
+        :filename => "#{@controller_folder}/_filters.js",
+        :replace => {':scope' => @controller_path}
+
+      generate_from_template :template => '/controller/_manifest.js', 
+        :filename => "#{@controller_folder}/_manifest.js"
+      
+      if @namespace.present?
+        # Require _manifest.js to namespace's _manifest.js file
+        File.open("#{@namespace_folder}/_manifest.js", 'a+'){ |f| 
+          f << "\n//= require ./#{@controller}/_manifest.js"}
+      else
+        # Require _manifest.js to Paloma's main index file
+        File.open(Paloma.index_js, 'a+'){ |f| 
+          f << "\n//= require ./#{@controller}/_manifest.js" }
       end
     end
     
     
-    def require_callbacks folder
-      # Require controller's _callbacks.js to Paloma's main index.js file.
-      # Located on "#{Paloma.destination}/index.js" or by default on
-      # app/assets/javascripts/paloma/index.js
-      
-      if (@namespace_folder.present? && folder != @namespace_folder)
-        File.open("#{@namespace_folder}/_callbacks.js", 'a+'){ |f|
-          is_present = f.lines.grep("\n//= require ./#{@controller_name}/_callbacks.js").any?
-          f << "\n//= require ./#{@controller_name}/_callbacks.js" unless is_present
-        }
-      end
-       
-      controller = @namespace_folder.present? ? @namespace_name : @controller_name
-      
-      unless (@namespace_folder.present? && folder != @namespace_folder)
-        File.open(Paloma.index_js, 'a+'){ |f|
-          f << "\n//= require ./#{controller}/_callbacks.js"
-        }
+    def generate_action_files actions
+      actions.each do |action|
+        action_js = "#{@controller_folder}/#{action}.js"
+        next if action.nil? || File.exists?(action_js)
+        
+        content = File.read("#{Paloma.templates}/controller/action.js").
+          gsub(':controller_path', @controller_path).
+          gsub(':action', action)
+          
+        File.open(action_js, 'w'){ |f| f.write(content) }
+        puts "create #{action_js}"  
       end
     end
     
     
-    def generate_from_template destination_filename
-      controller = destination_filename.gsub(/[\/|\w|_]+\/paloma\//, '')
+    def generate_from_template options = {:template => nil, :filename => nil, :replace => {}}
+      return true if File.exists?(options[:filename])
       
-      filename = controller.split('/').last
-      controller = controller.gsub('/' + filename, '')
-      controller = controller.gsub('/', '.')
+      content = File.read("#{Paloma.templates}/#{options[:template]}")
+      options[:replace].each do |pattern, value| 
+        content.gsub!(pattern, value)
+      end if options[:replace].present?
       
-      content = File.read("#{Paloma.templates}/#{filename}").gsub(/controller/, controller)
-      File.open(destination_filename, 'w'){ |f| f.write(content) }
-      puts "create #{destination_filename}"
+      File.open(options[:filename], 'w'){ |f| f.write(content) }
+      puts "create #{options[:filename]}"
     end 
   end
 end