jro_apps/redmine Commit - r10027:fc3a09e49a69

Let macros optionally accept a block of text (#3061)....

Jean-Philippe Lang -

r10027:fc3a09e49a69

parent child

Context file:

r10027:fc3a09e49a69

Collapse all files

app/helpers/application_helper.rb +5 -4

                             (
                             \{\{                        # opening tag
                             ([\w]+)                     # macro name
-                            (\((.*?)\))?                # optional arguments
+                            (\(([^\n\r]*?)\))?          # optional arguments
+                            ([\n\r].*[\n\r])?           # optional block of text
                             \}\}                        # closing tag
                             )
-                           )/x unless const_defined?(:MACROS_RE)
+                           )/mx unless const_defined?(:MACROS_RE)
               MACRO_SUB_RE = /(
                               \{\{
                   all, index = $1, $2.to_i
                   orig = macros.delete(index)
                   if execute && orig && orig =~ MACROS_RE
-                    esc, all, macro, args = $2, $3, $4.downcase, $6.to_s
+                    esc, all, macro, args, block = $2, $3, $4.downcase, $6.to_s, $7.try(:strip)
                     if esc.nil?
-                      h(exec_macro(macro, obj, args) || all)
+                      h(exec_macro(macro, obj, args, block) || all)
                     else
                       h(all)
                     end

lib/redmine/wiki_formatting/macros.rb +43 -6

                       Redmine::WikiFormatting::Macros.available_macros.key?(name.to_sym)
                     end
-                    def exec_macro(name, obj, args)
+                    def exec_macro(name, obj, args, text)
                       macro_options = Redmine::WikiFormatting::Macros.available_macros[name.to_sym]
                       return unless macro_options
                       end
                       begin
-                        send(method_name, obj, args) if respond_to?(method_name)
+                        if self.class.instance_method(method_name).arity == 3
+                          send(method_name, obj, args, text)
+                        elsif text
+                          raise "This macro does not accept a block of text"
+                        else
+                          send(method_name, obj, args)
+                        end
                       rescue => e
                         "<div class=\"flash error\">Error executing the <strong>#{h name}</strong> macro (#{h e.to_s})</div>".html_safe
                       end
                   class << self
                     # Called with a block to define additional macros.
-                    # Macro blocks accept 2 arguments:
+                    # Macro blocks accept 2 or 3 arguments:
                     # * obj: the object that is rendered
                     # * args: macro arguments
+                    # * text: a block of text (if the macro accepts
+                    #   3 arguments)
                     #
                     # Plugins can use this method to define new macros:
                     #
                     #     macro :my_macro do |obj, args|
                     #       "My macro output"
                     #     end
+                    #
+                    #     desc "This is my macro that accepts a block of text"
+                    #     macro :my_macro do |obj, args, text|
+                    #       "My macro output"
+                    #     end
                     #   end
+                    #
+                    # Macros are invoked in formatted text using the following
+                    # syntax:
+                    #
+                    #   No arguments:
+                    #   {{my_macro}}
+                    #
+                    #   With arguments:
+                    #   {{my_macro(arg1, arg2)}}
+                    #
+                    #   With a block of text:
+                    #   {{my_macro
+                    #   multiple lines
+                    #   of text
+                    #   }}
+                    #
+                    #   With arguments and a block of text
+                    #   {{my_macro(arg1, arg2)
+                    #   multiple lines
+                    #   of text
+                    #   }}
                     def register(&block)
                       class_eval(&block) if block_given?
                     end
                     #
                     # Examples:
                     # By default, when the macro is invoked, the coma separated list of arguments
-                    # is parsed and passed to the macro block as an array:
+                    # is split and passed to the macro block as an array:
                     #
                     #   macro :my_macro do |obj, args|
                     #     # args is an array
                   # Builtin macros
                   desc "Sample macro."
-                  macro :hello_world do |obj, args|
+                  macro :hello_world do |obj, args, text|
-                    h("Hello world! Object: #{obj.class.name}, " + (args.empty? ? "Called with no argument." : "Arguments: #{args.join(', ')}"))
+                    h("Hello world! Object: #{obj.class.name}, " +
+                      (args.empty? ? "Called with no argument" : "Arguments: #{args.join(', ')}") +
+                      " and " + (text.present? ? "a #{text.size} bytes long block of text." : "no block of text.")
+                    )
                   end
                   desc "Displays a list of all available macros, including description if available."

test/unit/lib/redmine/wiki_formatting/macros_test.rb +19 -5

                 assert_equal '<p>Bar: () (String)</p>', textilizable("{{bar()}}")
               end
+              def test_macro_registration_with_3_args_should_receive_text_argument
+                Redmine::WikiFormatting::Macros.register do
+                  macro :baz do |obj, args, text|
+                    "Baz: (#{args.join(',')}) (#{text.class.name}) (#{text})"
+                  end
+                end
+                assert_equal "<p>Baz: () (NilClass) ()</p>", textilizable("{{baz}}")
+                assert_equal "<p>Baz: () (NilClass) ()</p>", textilizable("{{baz()}}")
+                assert_equal "<p>Baz: () (String) (line1\nline2)</p>", textilizable("{{baz()\nline1\nline2\n}}")
+                assert_equal "<p>Baz: (arg1,arg2) (String) (line1\nline2)</p>", textilizable("{{baz(arg1, arg2)\nline1\nline2\n}}")
+              end
               def test_multiple_macros_on_the_same_line
                 Redmine::WikiFormatting::Macros.macro :foo do |obj, args|
                   args.any? ? "args: #{args.join(',')}" : "no args"
               def test_macro_should_receive_the_object_as_argument_when_with_object_and_attribute
                 issue = Issue.find(1)
                 issue.description = "{{hello_world}}"
-                assert_equal '<p>Hello world! Object: Issue, Called with no argument.</p>', textilizable(issue, :description)
+                assert_equal '<p>Hello world! Object: Issue, Called with no argument and no block of text.</p>', textilizable(issue, :description)
               end
               def test_macro_should_receive_the_object_as_argument_when_called_with_object_option
                 text = "{{hello_world}}"
-                assert_equal '<p>Hello world! Object: Issue, Called with no argument.</p>', textilizable(text, :object => Issue.find(1))
+                assert_equal '<p>Hello world! Object: Issue, Called with no argument and no block of text.</p>', textilizable(text, :object => Issue.find(1))
               end
               def test_macro_exception_should_be_displayed
                 Redmine::WikiFormatting::Macros.macro :exception do |obj, args|
                   raise "My message"
             RAW
                 expected = <<-EXPECTED
-            <p>Hello world! Object: NilClass, Arguments: foo</p>
+            <p>Hello world! Object: NilClass, Arguments: foo and no block of text.</p>
             <pre>
             {{hello_world(pre)}}
             !{{hello_world(pre)}}
             </pre>
-            <p>Hello world! Object: NilClass, Arguments: bar</p>
+            <p>Hello world! Object: NilClass, Arguments: bar and no block of text.</p>
             EXPECTED
                 assert_equal expected.gsub(%r{[\r\n\t]}, ''), textilizable(text).gsub(%r{[\r\n\t]}, '')
               def test_macros_should_not_mangle_next_macros_outputs
                 text = '{{macro(2)}} !{{macro(2)}} {{hello_world(foo)}}'
-                assert_equal '<p>{{macro(2)}} {{macro(2)}} Hello world! Object: NilClass, Arguments: foo</p>', textilizable(text)
+                assert_equal '<p>{{macro(2)}} {{macro(2)}} Hello world! Object: NilClass, Arguments: foo and no block of text.</p>', textilizable(text)
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages