netzke-core 0.5.5 → 0.6.0

data/lib/generators/migration_helper.rb

@@ -0,0 +1,32 @@
+module MigrationHelper
+  include Rails::Generators::Migration  
+  
+  module ClassMethods    
+    def migration_lookup_at(dirname) #:nodoc:
+      Dir.glob("#{dirname}/[0-9]*_*.rb")
+    end
+
+    def migration_exists?(dirname, file_name) #:nodoc:
+      migration_lookup_at(dirname).grep(/\d+_#{file_name}.rb$/).first
+    end
+
+    def current_migration_number(dirname) #:nodoc:
+      migration_lookup_at(dirname).collect do |file|
+        File.basename(file).split("_").first.to_i
+      end.max.to_i
+    end
+
+    def next_migration_number(dirname) #:nodoc:
+      orm = Rails.configuration.generators.options[:rails][:orm]
+      require "rails/generators/#{orm}"
+      "#{orm.to_s.camelize}::Generators::Base".constantize.next_migration_number(dirname)
+    rescue
+      raise NotImplementedError
+    end
+  end         
+
+  def self.included(base) #:nodoc: 
+    puts "MigrationHelper included by #{base}"
+    base.extend ClassMethods      
+  end
+end

data/lib/generators/netzke/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Generates a netzke preferences migration 
+
+Example:
+    rails g netzke:core
+
+    This will create:
+        A netzke preferences migration 
+        

data/lib/generators/netzke/core_generator.rb

@@ -0,0 +1,24 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+require 'generators/migration_helper'
+
+module Netzke
+  module Generators  
+    class CoreGenerator < Rails::Generators::Base
+      include ::MigrationHelper
+      
+      def execute
+        migration_template 'create_netzke_preferences.rb', 'db/migrate/create_netzke_preferences.rb'
+      end
+      
+      def self.source_root
+        File.join(gem_root, 'templates', 'core')
+      end        
+      
+      def self.gem_root
+        File.expand_path("../../../../", __FILE__)
+      end 
+                 
+    end
+  end
+end

data/lib/netzke/actions.rb

@@ -0,0 +1,102 @@
+module Netzke
+  # Netzke component allows specifying Ext actions.
+  # An action can be defined in 2 different ways, both of which result in a method definition like this 
+  #     def _<some_action>_action
+  #       ...
+  #     end
+  # 
+  # The 2 ways to define an action are:
+  # * as a hash:
+  #     action :bug_server, :text => "Call server", :icon => "/images/icons/phone.png"  
+  # 
+  # * as a block:
+  #     action :bug_server do
+  #       {:text => config[:text], :disabled => true}
+  #     end
+  # 
+  # The block can optionally receive the configuration of an action being overridden:
+  #     action :bug_server do |orig|
+  #       {:text => config[:text] + orig[:text], :disabled => orig[:disabled]}
+  #     end
+  module Actions
+    extend ActiveSupport::Concern
+
+    ACTION_METHOD_NAME = "%s_action"
+    ACTION_METHOD_REGEXP = /^(.+)_action$/
+    
+    included do
+      alias_method_chain :js_config, :actions
+    end
+    
+    module ClassMethods
+      def action(name, config = {}, &block)
+        config[:name] = name.to_s
+        method_name = ACTION_METHOD_NAME % name
+        
+        if block_given?
+          define_method(method_name, &block)
+        else
+          if superclass.instance_methods.map(&:to_s).include?(method_name)
+            define_method(method_name) do
+              super().merge(config)
+            end
+          else
+            define_method(method_name) do
+              config
+            end
+          end
+        end
+      end
+    end
+    
+    # Actions to be used in the config
+    def actions
+      # Call all the action related methods to collect the actions
+      self.class.instance_methods.grep(ACTION_METHOD_REGEXP).inject({}) do |r, m|
+        m.match(ACTION_METHOD_REGEXP)
+        r.merge($1.to_sym => normalize_action_config(send(m)))
+      end
+    end
+
+    def js_config_with_actions #:nodoc
+      actions.empty? ? js_config_without_actions : js_config_without_actions.merge(:actions => actions)
+    end
+    
+    private
+      def normalize_action_config(config)
+        if config[:icon].is_a?(Symbol)
+          config[:icon] = Netzke::Core.with_icons ? Netzke::Core.icons_uri + "/" + config[:icon].to_s + ".png" : nil
+        end
+        
+        config[:text] ||= config[:name].humanize
+        
+        config
+      end
+      
+      def auto_collect_actions_from_config_and_js_properties
+        # res = extract_actions(js_properties)
+        # puts %Q(!!! res: #{res.inspect}\n)
+      end
+      
+      # def extract_actions(hsh)
+      #   hsh.each_pair.inject({}) do |r,(k,v)| 
+      #     v.is_a?(Array) ? r.merge(extract_actions_from_array(v)) : r
+      #   end
+      # end
+      # 
+      # def extract_actions_from_array(arry)
+      #   arry.inject({}) do |r, el|
+      #     if el.is_a?(Hash)
+      #       el[:action] ? r.merge(el[:action] => default_action_config(el[:action])) : r.merge(extract_actions(el))
+      #     else
+      #       r
+      #     end
+      #   end
+      # end
+      # 
+      # def default_action_config(action_name)
+      #   {:text => action_name.to_s.humanize}
+      # end
+      
+  end
+end