caterpillar 1.3.1 → 1.4.0

data/lib/caterpillar/parser.rb

@@ -1,6 +1,4 @@
 # encoding: utf-8
-
-
 #--
 # (c) Copyright 2008 Mikael Lammentausta
 # See the file LICENSES.txt included with the distribution for
@@ -22,7 +20,6 @@ module Caterpillar
     # Changes the path variables to a format supported by the Rails-portlet.
     def portlets(routes=@routes)
       raise 'No configuration' unless @config
-      raise 'No routes provided' unless routes
       portlets = []
 
       @config.instances.flatten.each do |portlet|
@@ -49,7 +46,7 @@ module Caterpillar
           portlet.update( :reqs => {} )
           portlet.update( :vars => [] )
 
-        else
+        else # parse path from routes
           begin
             _r = routes.select{
               |route| route[:name]==portlet[:name].to_sym
@@ -57,10 +54,13 @@ module Caterpillar
             path = _r.first[:path] # take only the first segments
             raise if path.nil?
           rescue
-            STDERR.puts ' !! no route for %s' % portlet[:name]
+            $stderr.puts ' !! no route for %s' % portlet[:name]
             next
           end
-
+                                      
+          # getting de default values from wildcards (:controller, :action, :other)
+          portlet.update(:defaults => _r.first[:defaults])
+          
           ### requirements - controller & action
           portlet.update( :reqs => _r.first[:reqs] )
 
@@ -74,9 +74,11 @@ module Caterpillar
           portlet.update( :vars => vars )
 
           # delete the route from routes
-          _r.each do |r|
-            routes.delete(r)
-          end
+	  if routes
+            _r.each do |r|
+              routes.delete(r)
+            end
+	  end
         end
         portlet.update( :path => path )
 
@@ -92,10 +94,11 @@ module Caterpillar
       # leftover named routes
       if @config.include_all_named_routes==true
         portlets << routes
-        portlets.flatten!
       end
 
       # sanity check
+      portlets.flatten!
+      portlets.compact!
       portlets.each do |portlet|
         ### hostname
         portlet[:host] ||= @config.host

data/lib/caterpillar/portlet.rb

@@ -1,40 +1,23 @@
 # encoding: utf-8
 #--
 # (c) Copyright 2008, 2010 Mikael Lammentausta
+#                     2010 Tulio Ornelas
 # See the file LICENSES.txt included with the distribution for
 # software license details.
 #++
+          
+if RUBY_PLATFORM =~ /java/
+  gem 'jrexml'
+  require 'jrexml'
+else
+  require "rexml/document"
+end
 
 module Caterpillar
   # Formulates generic JSR286 portlet XML
   class Portlet
     class << self
 
-    # Creates portlet XML
-    def xml(portlets)
-    	session = 
-        begin
-          {
-            :key    => Caterpillar::Security.get_session_key(),
-            :secret => Caterpillar::Security.get_secret()
-          }
-        rescue nil
-        end
-        
-      xml = self.header
-      portlets.each do |p|
-        xml << self.template(p,session)
-      end
-      xml << self.footer
-      return xml
-    end
-
-    def debug(config,routes) # :nodoc:
-      routes.select{|r| !r[:name].empty?}.each do |route|
-        puts '%s: %s' % [route[:name], route[:path]]
-      end
-    end
-
     # Rails-portlet Java class
     def portlet_class
       'com.celamanzi.liferay.portlets.rails286.Rails286Portlet'
@@ -45,100 +28,162 @@ module Caterpillar
       'com.celamanzi.liferay.portlets.rails286.Rails286PortletFilter'
     end
 
-    # JSR 286 portlet XML header. Opens portlet-app.
-    def header
-      xml =  '<?xml version="1.0" encoding="UTF-8"?>' +"\n"
-      xml << '<portlet-app xmlns="http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd"
-             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-             xsi:schemaLocation="http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd"
-             version="2.0">'
-      xml << "\n\n"
-      return xml
-    end
+    # Creates <portlet-app> XML document for portlet-ext.xml.
+    #
+    # @param portlets is an Array of Hashes
+    # @returns String
+    def xml(portlets)
+      # create a new XML document
+      doc = REXML::Document.new
+      doc << REXML::XMLDecl.new('1.0', 'utf-8') 
+      app = REXML::Element.new('portlet-app', doc)
+      app.attributes['version'] = '2.0'
+      app.attributes['xmlns'] = 'http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd'
+      app.attributes['xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance'
+      app.attributes['xsi:schemaLocation'] = 'http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd'
+
+      # create session values, common for all portlets
+      session = 
+        begin
+          {
+            :key    => Caterpillar::Security.get_session_key(),
+            :secret => Caterpillar::Security.get_secret()
+          }
+        rescue
+          nil
+        end
 
-    # Closes portlet-app.
-    def footer
-      '</portlet-app>' + "\n"
+      # create XML element tree
+      portlets.each do |portlet|
+        # <portlet>
+        app.elements << self.portlet_element(portlet, session, app)
+        # <filter>
+        app.elements << self.filter_element(portlet)
+        # filter mapping
+        app.elements << self.filter_mapping(portlet)
+      end
+      xml = ''
+      #doc.write(xml, -1) # no indentation, tag and text should be on same line
+      doc.write(xml, 4) # without identation is very dificult to reconfigure those files in production
+      return xml.gsub('\'', '"') # fix rexml attribute single quotes to double quotes
     end
 
-    # portlet.xml template.
+    # <portlet> element.
     # session is a hash containing session key and secret from Rails.
-    def template(portlet,session=nil)
-      # add roles
-      # TODO: move into portlet hash
-      # administrator, power-user, user
-      roles = %w{ administrator }
-      xml =  "  <!-- %s -->\n" % portlet[:title]
+    def portlet_element(portlet, session = nil, app = nil)            
+      element = REXML::Element.new('portlet')
+      # NOTE: to pass validation, the elements need to be in proper order!
+                                                              
+      REXML::Element.new('portlet-name', element).text = portlet[:name]
+      REXML::Element.new('portlet-class', element).text = self.portlet_class
 
-      xml << "  <portlet>\n"
-      ### identification
-      xml << "    <portlet-name>%s</portlet-name>\n" % portlet[:name]
-      xml << "    <portlet-class>%s</portlet-class>\n" % self.portlet_class
-      ### supported portlet modes
-      xml << "    <supports>\n"
-      xml << "      <mime-type>text/html</mime-type>\n"
-      xml << "      <portlet-mode>view</portlet-mode>\n"
-      if portlet[:edit_mode] == true
-        xml << "      <portlet-mode>edit</portlet-mode>\n"
-      end
-      xml << "    </supports>\n"
-      ### title for portlet container
-      xml << "    <portlet-info>\n"
-      xml << "      <title>%s</title>\n" % portlet[:title]
-      xml << "    </portlet-info>\n"
-      ### init parameters, XXX: fails xsd test
-#=begin
       # insert session key
       unless session.nil?
-        xml << "    <init-param>\n"+\
-               "      <name>session_key</name>\n"+\
-               "      <value>#{session[:key]}</value>\n"+\
-               "    </init-param>\n"
+        param = REXML::Element.new('init-param', element)
+        REXML::Element.new('name', param).text = 'session_key'
+        REXML::Element.new('value', param).text = session[:key]
+
+        param = REXML::Element.new('init-param', element)
+        REXML::Element.new('name', param).text = 'secret'
+        REXML::Element.new('value', param).text = session[:secret]
       end
-      # insert secret
-      unless session.nil?
-        xml << "    <init-param>\n"+\
-               "      <name>secret</name>\n"+\
-               "      <value>#{session[:secret]}</value>\n"+\
-               "    </init-param>\n"
+
+      supports = REXML::Element.new('supports', element)
+      REXML::Element.new('mime-type', supports).text = 'text/html'
+      ### supported portlet modes
+      REXML::Element.new('portlet-mode', supports).text = 'view'
+      if portlet[:edit_mode] == true
+        REXML::Element.new('portlet-mode', supports).text = 'edit'
       end
-#=end
+                           
+      # Public Render Parameters
+      if portlet[:public_render_parameters] and portlet[:public_render_parameters].length > 0
+        portlet[:public_render_parameters].each do |param|
+          REXML::Element.new('supported-public-render-parameter', element).text = param
+        end
+      end
+
+      info = REXML::Element.new('portlet-info', element)
+      ### title for portlet container
+      REXML::Element.new('title', info).text = portlet[:title]
+
+      # add roles
+      # TODO: move into portlet hash
+      # administrator, power-user, user
+      roles = %w{ administrator }
       roles.each do |role|
-        xml << "    <security-role-ref>\n"
-        xml << "      <role-name>#{role}</role-name>\n"
-        xml << "    </security-role-ref>\n"
+        ref = REXML::Element.new('security-role-ref', element)
+        REXML::Element.new('role-name', ref).text = role
       end
-      xml << "  </portlet>\n\n"
 
-      ### portlet filters
-      xml << "  <filter>\n"
+      # Public Render Parameters
+      if (not app.nil?) and portlet[:public_render_parameters] and portlet[:public_render_parameters].length > 0
+        portlet[:public_render_parameters].each do |param|
+          prp = REXML::Element.new('public-render-parameter', app)
+          REXML::Element.new('identifier', prp).text = param
+          qname = REXML::Element.new('qname', prp)
+          qname.text = "x:#{param}"
+          qname.attributes['xmlns:x'] = 'http://www.liferay.com/public-render-parameters' 
+        end
+      end
+      
+      return element
+    end
+
+    # <filter> element.
+    def filter_element(portlet)
       # the filter reads the settings and sets the portlet session
-      xml << "    <filter-name>%s_filter</filter-name>\n" % portlet[:name]
-      xml << "    <filter-class>%s</filter-class>\n" % self.portlet_filter_class
-      xml << "    <lifecycle>RENDER_PHASE</lifecycle>\n"
-      xml << "    <lifecycle>RESOURCE_PHASE</lifecycle>\n"
+      element = REXML::Element.new('filter')
+
+      REXML::Element.new('filter-name', element).text = "#{portlet[:name]}_filter"
+      REXML::Element.new('filter-class', element).text = self.portlet_filter_class
+      REXML::Element.new('lifecycle', element).text = 'RENDER_PHASE'
+      REXML::Element.new('lifecycle', element).text = 'RESOURCE_PHASE'
 
       # define host, servlet and route (path to be more precise)
-      xml << "    <init-param>\n"
-      xml << "      <name>host</name>\n"
-      xml << "      <value>%s</value>\n" % portlet[:host] || ""
-      xml << "    </init-param>\n"
-      xml << "    <init-param>\n"
-      xml << "      <name>servlet</name>\n"
-      xml << "      <value>%s</value>\n" % portlet[:servlet]
-      xml << "    </init-param>\n"
-      xml << "    <init-param>\n"
-      xml << "      <name>route</name>\n"
-      xml << "      <value>%s</value>\n" % portlet[:path].gsub(/&/,"&amp;")
-      xml << "    </init-param>\n"
-
-      xml << "  </filter>\n\n"
-
-      xml << "  <filter-mapping>\n"
-      xml << "    <filter-name>%s_filter</filter-name>\n" % portlet[:name]
-      xml << "    <portlet-name>%s</portlet-name>\n" % portlet[:name]
-      xml << "  </filter-mapping>\n"
-      xml << "\n"
+      param = REXML::Element.new('init-param', element)
+      REXML::Element.new('name', param).text = 'host'
+      REXML::Element.new('value', param).text = portlet[:host]
+
+      param = REXML::Element.new('init-param', element)
+      REXML::Element.new('name', param).text = 'servlet'
+      REXML::Element.new('value', param).text = portlet[:servlet]
+
+      param = REXML::Element.new('init-param', element)
+      REXML::Element.new('name', param).text = 'route'
+      portlet_path = portlet[:path].gsub(/&/,"&amp;")
+      REXML::Element.new('value', param).text = portlet_path
+                                  
+      if portlet[:edit_mode] == true
+        param = REXML::Element.new('init-param', element)
+        REXML::Element.new('name', param).text = 'preferences_route'
+        
+        if portlet[:preferences_route]
+          preferences_route = portlet[:preferences_route]
+        else
+          preferences_route = portlet_path.gsub(':controller', portlet[:defaults][:controller])
+          preferences_route = preferences_route.gsub(':action', 'preferences')
+        end
+        REXML::Element.new('value', param).text = preferences_route
+      end
+
+      return element
+    end
+
+    # <filter-mapping> element.
+    def filter_mapping(portlet)
+      element = REXML::Element.new('filter-mapping')
+
+      REXML::Element.new('filter-name', element).text = "#{portlet[:name]}_filter"
+      REXML::Element.new('portlet-name', element).text = portlet[:name]
+
+      return element
+    end
+
+    def debug(config,routes) # :nodoc:
+      routes.select{|r| !r[:name].empty?}.each do |route|
+        puts '%s: %s' % [route[:name], route[:path]]
+      end
     end
 
   end # static methods

data/lib/caterpillar/task.rb

@@ -34,19 +34,17 @@ module Caterpillar
     # The main task.
     # Reads the configuration file and launches appropriate tasks.
     def initialize(name = :usage, config = nil, tasks = :define_tasks)
-      #STDOUT.puts 'Caterpillar v.%s (c) Copyright 2008,2009 Mikael Lammentausta' % VERSION
-      #STDOUT.puts 'Provided under the terms of the MIT license.'
-      #STDOUT.puts
-
       @name   = name
-      @config = Util.eval_configuration(config)
+
+      @config = (name == 'rails' or name == 'version' ) ? Config.new(false) : Util.eval_configuration(config)
       @logger = @config.logger
+
       @xml_files = []
 
       if name == 'rails'
         @required_gems = %w(rails caterpillar jruby-jars warbler)
       else
-        unless @config.rails_root
+        if not @config and not %w{generate version}.include?(name)
           Usage.show()
           exit 1
         end
@@ -59,9 +57,9 @@ module Caterpillar
     private
 
     def define_tasks
+      define_version_task
       define_xml_task
       define_usage_task
-      define_config_task
       define_pluginize_task
       define_environment_task
       define_portletxml_task
@@ -82,6 +80,7 @@ module Caterpillar
       define_deploy_xml_task
       define_deploy_war_task
       define_rails_task
+      define_generate_task
     end
 
     def define_usage_task
@@ -90,24 +89,38 @@ module Caterpillar
       end
     end
 
-    # TODO: copy and diff config file
-    def define_config_task
-      task :config do
-        STDOUT.puts 'TODO'
+    def define_version_task
+      task :version do
+        version_str = "Caterpillar #{Caterpillar::VERSION} "
+        version_str << "Ruby #{RUBY_VERSION} "
+        if RUBY_PLATFORM =~ /java/
+          version_str << "JRuby #{JRUBY_VERSION}"
+        end
+        $stdout.puts version_str
       end
     end
 
     def define_pluginize_task
-      desc "Unpack Caterpillar as a plugin in your Rails application"
+      desc "Unpack Caterpillar to your Rails application"
       task :pluginize do
-        if !Dir["vendor/plugins/caterpillar*"].empty?
-          puts "I found an old nest in vendor/plugins; please trash it so I can make a new one"
-          puts "(directory vendor/plugins/caterpillar* exists)"
+        if !Dir["vendor/plugins/caterpillar*"].empty? && ENV["FORCE"].nil?
+          puts "I found an old pupa"
+          puts "(directory vendor/plugins/caterpillar* exists);"
+          puts "please trash it so I can make a new one,"
+          puts "or prepend the command with environment variable FORCE=1."
+          exit 1
         elsif !File.directory?("vendor/plugins")
-          puts "I can't find a place to build my nest"
+          puts "I can't find a place to build my pupa"
           puts "(directory 'vendor/plugins' is missing)"
+          exit 1
         else
+          rm_rf FileList["vendor/plugins/caterpillar*"], :verbose => false
           ruby "-S", "gem", "unpack", "caterpillar", "--target", "vendor/plugins"
+          # rename the versioned name to plain "caterpillar",
+          # since Rails has trouble loading some helper files without so
+          File.rename(
+            "vendor/plugins/caterpillar-#{Caterpillar::VERSION}",
+            "vendor/plugins/caterpillar")
           ruby "./script/generate caterpillar"
         end
       end
@@ -124,9 +137,10 @@ module Caterpillar
       if @config.container.kind_of? Liferay
         tasks << "#{@name}:liferayportletapp"
         tasks << "#{@name}:liferaydisplay"
-      end
-
+      end              
+      
       task :makexml => tasks
+      puts 'Done!'
     end
 
     # Prints the list of portlets.
@@ -170,17 +184,34 @@ module Caterpillar
       end
     end
 
+    def define_generate_task
+      @name = :generate
+      desc 'Generates stand-alone configuration file'
+      task :generate do
+        filename = 'portlets-config.rb'
+        FileUtils.cp(
+          File.expand_path(File.join(__FILE__,
+            %w{.. .. .. generators caterpillar templates config portlets.rb})),
+          filename
+          )
+        info("Generated #{filename}")
+      end
+    end
+
     ### SUB-TASKS
 
     # reads Rails environment configuration
     def define_environment_task
-      task :default => :test
       task :environment do
-        require(File.join(@config.rails_root, 'config', 'environment'))
+        begin
+          require(File.join(@config.rails_root, 'config', 'environment'))
+        rescue
+          raise 'Rails environment could not be loaded'
+        end
         if @config.container.is_a?(Caterpillar::Liferay)
           if @config.container.version.nil? and !defined?(Lportal)
-            STDERR.puts 'Liferay version is undefined, and lportal gem is not present.'
-            STDERR.puts 'Please define portlet.container.version in %s.' % @config.class::FILE
+            $stderr.puts 'Liferay version is undefined, and lportal gem is not present.'
+            $stderr.puts 'Please define portlet.container.version in %s.' % @config.class::FILE
             raise 'Insufficient configuration'
           end
           @config.container.version ||= Lportal::Schema.version
@@ -191,7 +222,7 @@ module Caterpillar
 
     # collects Rails' routes and parses the config
     def define_parse_task
-      task :parse => :environment do
+      task :parse do
         @config.routes = Util.parse_routes(@config)
         @portlets = Parser.new(@config).portlets
       end
@@ -202,9 +233,9 @@ module Caterpillar
       @name = :xml
       # set the output filename
       if @config.container.kind_of? Liferay
-        file = File.join('tmp','portlet-ext.xml')
+        file = 'portlet-ext.xml'
       else
-        file = File.join('tmp','portlet.xml')
+        file = 'portlet.xml'
       end
       @xml_files << file
       with_namespace_and_config do |name, config|
@@ -212,7 +243,7 @@ module Caterpillar
         task :portlet do
           #portal_info
 
-          exit 1 unless system('touch %s' % file)
+          FileUtils.touch(file)
           f=File.open(file,'w')
           f.write Portlet.xml(@portlets)
           f.close
@@ -224,12 +255,12 @@ module Caterpillar
     # Writes liferay-portlet-ext.xml
     def define_liferayportletappxml_task
       @name = :xml
-      file = File.join('tmp','liferay-portlet-ext.xml')
+      file = 'liferay-portlet-ext.xml'
       @xml_files << file
       with_namespace_and_config do |name, config|
         desc 'Create Liferay portlet XML'
         task :liferayportletapp do
-          exit 1 unless system('touch %s' % file)
+          FileUtils.touch(file)
           f=File.open(file,'w')
           f.write config.container.portletapp_xml(@portlets)
           f.close
@@ -241,7 +272,7 @@ module Caterpillar
     # Writes liferay-display.xml
     def define_liferaydisplayxml_task
       @name = :xml
-      file = File.join('tmp','liferay-display.xml')
+      file = 'liferay-display.xml'
       @xml_files << file
 
       with_namespace_and_config do |name, config|
@@ -249,7 +280,7 @@ module Caterpillar
         task :liferaydisplay do
           raise 'Version 5.1.2 of Liferay is broken!' if config.container.version == '5.1.2'
 
-          exit 1 unless system('touch %s' % file)
+          FileUtils.touch(file)
           f=File.open(file,'w')
           f.write config.container.display_xml(@portlets)
           f.close
@@ -333,13 +364,15 @@ module Caterpillar
 
           # detect the version of the JAR to install
           portlet_jar = nil
-          version = (
-            if container_v and container_v[/^5.1/]
-              '0.6.0' # FIXME: branch properly
-            else
-              '0.10.0'
-            end
-          )
+          # XXX: since the filter name has changed, the old JAR does not work
+          #version = (
+          #  if container_v and container_v[/^5.1/]
+          #    '0.6.0' # FIXME: branch properly
+          #  else
+          #    '0.10.0'
+          #  end
+          #)
+          version = '0.10.1'
           require 'find'
           Find.find(source) do |file|
             if File.basename(file) == "rails-portlet-#{version}.jar"
@@ -573,6 +606,7 @@ module Caterpillar
         end
         exit 1 unless conferring_step 'Creating Rails project...' do
           create_rails_project
+          Dir.chdir("#{ARGV[1]}"){system("ruby script/generate html_template >/dev/null")}
         end
         exit 1 unless conferring_step 'Updating config/environment.rb...' do
           update_environment(ARGV[1] + '/config/environment.rb')
@@ -580,10 +614,11 @@ module Caterpillar
         exit 1 unless conferring_step 'Activating caterpillar...' do
           # Rake::Task['pluginize'].execute         
           Dir.chdir("#{ARGV[1]}/vendor/plugins"){system 'ruby -S gem unpack caterpillar >/dev/null'}
-          Dir.chdir("#{ARGV[1]}"){system 'script/generate caterpillar >/dev/null'}
+          Dir.chdir("#{ARGV[1]}"){system 'ruby script/generate caterpillar >/dev/null'}
         end
         exit 1 unless conferring_step 'Configuring warbler...' do
           Dir.chdir("#{ARGV[1]}"){system 'ruby -S warble config >/dev/null 2>&1'}
+          update_warble(ARGV[1] +'/config/warble.rb' , ARGV[1].split('/')[-1])
         end
       end
     end
@@ -609,7 +644,7 @@ module Caterpillar
       end
 
       _sorted.each_pair do |category,portlets|
-        STDOUT.puts category
+        $stdout.puts category
         portlets.each do |portlet|
           # spaces
           spaces = ''
@@ -619,13 +654,13 @@ module Caterpillar
 
           #field = :path
           #fields = [:name, :id]
-          STDOUT.puts "\t" + portlet[:title] +spaces+ portlet[:name].inspect + "\t" + portlet[:vars].inspect
+          $stdout.puts "\t" + portlet[:title] +spaces+ portlet[:path] # + "\t" + portlet[:vars].inspect
         end
       end
     end
 
     def info(msg)
-      STDOUT.puts ' * ' + msg
+      $stdout.puts ' * ' + msg
     end
 
     def portal_info(config=@config)
@@ -635,7 +670,7 @@ module Caterpillar
         config.container.version,
         config.container.root
       ]
-      @logger ? @logger.info(msg) : STDOUT.puts(msg)
+      info(msg)
     end
 
     private
@@ -689,22 +724,30 @@ module Caterpillar
 
     def update_environment(file_path)
       file = File.read(file_path).
-        sub(/([ ]*#[ ]*config\.gem)/,
-            "  config.gem 'caterpillar', :version => '#{Caterpillar::VERSION}'\n" + '\1')
+          sub(/([ ]*#[ ]*config\.gem)/,
+            "  config.gem 'caterpillar', :version => '>= #{Caterpillar::VERSION}'\n" + '\1')
+      File.open(file_path, 'w') {|f| f << file}
+    end
+
+    def update_warble(file_path, project_name)
+      file = File.read(file_path).
+          sub(/([ ]*#[ ]*config\.war_name = \"mywar\")/,
+            "  config.war_name = '#{project_name}-portlet'\n")
       File.open(file_path, 'w') {|f| f << file}
     end
+    
 
     def conferring_step(message)
-      STDOUT.print message
-      STDOUT.flush
+      $stdout.print message
+      $stdout.flush
       
       result = yield
       if result.class == String or result.class == NilClass
-        STDOUT.puts "\e[31mFAILED\e[0m"
+        $stdout.puts "\e[31mFAILED\e[0m"
         puts result unless result.nil?
         return false
       else
-        STDOUT.puts "\e[32mOK\e[0m"
+        $stdout.puts "\e[32mOK\e[0m"
         return true
       end
     end