bureaucrat 0.0.3 → 0.10.0

data/lib/bureaucrat/widgets.rb

@@ -1,397 +1,553 @@
 require 'uri'
 
-require 'bureaucrat/utils'
-
 module Bureaucrat
-module Widgets
-  class Media
-    include Utils
+  module Widgets
+    # Base class for widgets
+    class Widget
+      include Utils
 
-    MEDIA_TYPES = [:css, :js]
-    DEFAULT_MEDIA_PATH = 'http://localhost'
+      attr_accessor :is_required
+      attr_reader :attrs
 
-    attr_accessor :media_path
+      def initialize(attrs = nil)
+        @attrs = attrs.nil? ? {} : attrs.dup
+      end
 
-    def initialize(media_attrs={})
-      self.media_path = media_attrs.delete(:media_path) || DEFAULT_MEDIA_PATH
-      media_attrs = media_attrs.to_hash if media_attrs.is_a?(Media)
-      @css = {}
-      @js = []
+      def initialize_copy(original)
+        super(original)
+        @attrs = original.attrs.dup
+      end
 
-      MEDIA_TYPES.each do |name|
-          data = media_attrs[name]
-          add_type(name, data) if data
-        end
-    end
+      def render(name, value, attrs = nil)
+        raise NotImplementedError
+      end
 
-    def to_s
-      render
+      def build_attrs(extra_attrs = nil, options = {})
+        attrs = @attrs.merge(options)
+        attrs.update(extra_attrs) if extra_attrs
+        attrs
+      end
+
+      def value_from_formdata(data, name)
+        data[name]
+      end
+
+      def self.id_for_label(id_)
+        id_
+      end
+
+      def has_changed?(initial, data)
+        data_value = data || ''
+        initial_value = initial || ''
+        initial_value != data_value
+      end
+
+      def needs_multipart?
+        false
+      end
+
+      def hidden?
+        false
+      end
     end
 
-    def to_hash
-      hash = {}
-      MEDIA_TYPES.each {|name| hash[name] = instance_variable_get("@#{name}")}
-      hash
+    # Base class for input widgets
+    class Input < Widget
+      def render(name, value, attrs=nil)
+        value ||= ''
+        final_attrs = build_attrs(attrs,
+                                  type: input_type.to_s,
+                                  name: name.to_s)
+        final_attrs[:value] = value.to_s unless value == ''
+        mark_safe("<input#{flatatt(final_attrs)} />")
+      end
+
+      def input_type
+        nil
+      end
     end
 
-    def render
-      mark_safe(MEDIA_TYPES.map do |name|
-                  render_type(name)
-                end.inject(&:+).join("\n"))
+    # Class for text inputs
+    class TextInput < Input
+      def input_type
+        'text'
+      end
     end
 
-    def render_type(type)
-      send("render_#{type}")
+    # Class for password inputs
+    class PasswordInput < Input
+      def initialize(attrs = nil, render_value = false)
+        super(attrs)
+        @render_value = render_value
+      end
+
+      def input_type
+        'password'
+      end
+
+      def render(name, value, attrs=nil)
+        value = nil unless @render_value
+        super(name, value, attrs)
+      end
     end
 
-    def render_js
-      @js.map do |path|
-          "<script type=\"text/javascript\" src=\"#{absolute_path(path)}\"></script>"
-        end
+    # Class for hidden inputs
+    class HiddenInput < Input
+      def input_type
+        'hidden'
+      end
+
+      def hidden?
+        true
+      end
     end
 
-    def render_css
-      fragments = @css.keys.sort.map do |medium|
-          @css[medium].map do |path|
-            "<link href=\"#{absolute_path(path)}\" type=\"text/css\" media=\"#{medium}\" rel=\"stylesheet\" />"
+    class MultipleHiddenInput < HiddenInput
+      # Used by choice fields
+      attr_accessor :choices
+
+      def initialize(attrs=nil, choices=[])
+        super(attrs)
+        # choices can be any enumerable
+        @choices = choices
+      end
+
+      def render(name, value, attrs=nil, choices=[])
+        value ||= []
+        final_attrs = build_attrs(attrs, type: input_type.to_s,
+                                  name: "#{name}[]")
+
+        id = final_attrs[:id]
+        inputs = []
+
+        value.each.with_index do |v, i|
+          input_attrs = final_attrs.merge(value: v.to_s)
+
+          if id
+            input_attrs[:id] = "#{id}_#{i}"
           end
+
+          inputs << "<input#{flatatt(input_attrs)} />"
         end
-      fragments.empty? ? fragments : fragments.inject(&:+)
-    end
 
-    def absolute_path(path)
-      path =~ /^(\/|https?:\/\/)/ ? path : URI.join(media_path, path)
+        mark_safe(inputs.join("\n"))
+      end
     end
 
-    def [](name)
-      raise IndexError("Unknown media type '#{name}'") unless
-        MEDIA_TYPES.include?(name)
-      Media.new(name => instance_variable_get("@{name}"))
-    end
+    class FileInput < Input
+      def render(name, value, attrs=nil)
+        super(name, nil, attrs)
+      end
 
-    def add_type(type, data)
-      send("add_#{type}", data)
-    end
+      def value_from_formdata(data, name)
+        data[name] && TemporaryUploadedFile.new(data[name])
+      end
+
+      def has_changed?(initial, data)
+        data.nil?
+      end
 
-    def add_js(data)
-      @js += data.select {|path| !@js.include?(path)}
+      def input_type
+        'file'
+      end
+
+      def needs_multipart?
+        true
+      end
     end
 
-    def add_css(data)
-      data.each do |medium, paths|
-          @css[medium] ||= []
-          css = @css[medium]
-          css.concat(paths.select {|path| !css.include?(path)})
+    class ClearableFileInput < FileInput
+      FILE_INPUT_CONTRADICTION = Object.new
+
+      def initial_text
+        'Currently'
+      end
+
+      def input_text
+        'Change'
+      end
+
+      def clear_checkbox_label
+        'Clear'
+      end
+
+      def template_with_initial
+        '%(initial_text)s: %(initial)s %(clear_template)s<br />%(input_text)s: %(input)s'
+      end
+
+      def template_with_clear
+        '%(clear)s <label for="%(clear_checkbox_id)s">%(clear_checkbox_label)s</label>'
+      end
+
+      def clear_checkbox_name(name)
+        "#{name}-clear"
+      end
+
+      def clear_checkbox_id(checkbox_name)
+        "#{checkbox_name}_id"
+      end
+
+      def render(name, value, attrs = nil)
+        substitutions = {
+          initial_text: initial_text,
+          input_text: input_text,
+          clear_template: '',
+          clear_checkbox_label: clear_checkbox_label
+        }
+        template = '%(input)s'
+        substitutions[:input] = super(name, value, attrs)
+
+        if value && value.respond_to?(:url) && value.url
+          template = template_with_initial
+          substitutions[:initial] = '<a href="%s">%s</a>' % [escape(value.url),
+                                                             escape(value.to_s)]
+          unless is_required
+            checkbox_name = clear_checkbox_name(name)
+            checkbox_id = clear_checkbox_id(checkbox_name)
+            substitutions[:clear_checkbox_name] = conditional_escape(checkbox_name)
+            substitutions[:clear_checkbox_id] = conditional_escape(checkbox_id)
+            substitutions[:clear] = CheckboxInput.new.
+              render(checkbox_name, false, {id: checkbox_id})
+            substitutions[:clear_template] =
+              Utils.format_string(template_with_clear, substitutions)
+          end
         end
-    end
 
-    def +(other)
-      combined = Media.new
-      MEDIA_TYPES.each do |name|
-          combined.add_type(name, instance_variable_get("@#{name}"))
-          combined.add_type(name, other.instance_variable_get("@#{name}"))
+        mark_safe(Utils.format_string(template, substitutions))
+      end
+
+      def value_from_formdata(data, name)
+        upload = super(data, name)
+        checked = CheckboxInput.new.
+          value_from_formdata(data, clear_checkbox_name(name))
+
+        if !is_required && checked
+          if upload
+            # If the user contradicts themselves (uploads a new file AND
+            # checks the "clear" checkbox), we return a unique marker
+            # object that FileField will turn into a ValidationError.
+            FILE_INPUT_CONTRADICTION
+          else
+            # False signals to clear any existing value, as opposed to just None
+            false
+          end
+        else
+          upload
         end
-      combined
+      end
     end
-  end
 
-  class Widget
-    include Utils
+    class Textarea < Widget
+      def initialize(attrs=nil)
+        # The 'rows' and 'cols' attributes are required for HTML correctness.
+        default_attrs = {cols: '40', rows: '10'}
+        default_attrs.merge!(attrs) if attrs
 
-    class << self
-      attr_accessor :needs_multipart_form, :is_hidden
+        super(default_attrs)
+      end
 
-      def inherited(c)
-        super(c)
-        c.is_hidden = is_hidden
-        c.needs_multipart_form = needs_multipart_form
+      def render(name, value, attrs=nil)
+        value ||= ''
+        final_attrs = build_attrs(attrs, name: name)
+        mark_safe("<textarea#{flatatt(final_attrs)}>#{conditional_escape(value.to_s)}</textarea>")
       end
     end
 
-    self.needs_multipart_form = false
-    self.is_hidden = false
+    # DateInput
+    # DateTimeInput
+    # TimeInput
 
-    attr_reader :attrs
+    class CheckboxInput < Widget
+      def initialize(attrs=nil, check_test=nil)
+        super(attrs)
+        @check_test = check_test || lambda {|v| make_bool(v)}
+      end
 
-    def initialize(attrs=nil)
-      @attrs = attrs.nil? ? {} : attrs.dup
-    end
+      def render(name, value, attrs=nil)
+        final_attrs = build_attrs(attrs, type: 'checkbox', name: name.to_s)
 
-    def initialize_copy(original)
-      super(original)
-      @attrs = original.attrs.dup
-    end
+        # FIXME: this is horrible, shouldn't just rescue everything
+        result = @check_test.call(value) rescue false
 
-    def render(name, value, attrs=nil)
-      raise NotImplementedError
-    end
+        if result
+          final_attrs[:checked] = 'checked'
+        end
 
-    def build_attrs(extra_attrs=nil, options={})
-      attrs = @attrs.merge(options)
-      attrs.update(extra_attrs) if extra_attrs
-      attrs
-    end
+        unless ['', true, false, nil].include?(value)
+          final_attrs[:value] = value.to_s
+        end
 
-    def value_from_datahash(data, files, name)
-      data[name]
-    end
+        mark_safe("<input#{flatatt(final_attrs)} />")
+      end
 
-    def self.id_for_label(id_)
-      id_
-    end
+      def value_from_formdata(data, name)
+        if data.include?(name)
+          value = data[name]
 
-    def has_changed?(initial, data)
-      data_value = data || ''
-      initial_value = initial || ''
-      initial_value != data_value
-    end
+          if value.is_a?(String)
+            case value.downcase
+            when 'true' then true
+            when 'false' then false
+            else value
+            end
+          else
+            value
+          end
+        else
+          false
+        end
+      end
 
-    def hidden?
-      self.class.is_hidden
+      def has_changed(initial, data)
+        make_bool(initial) != make_bool(data)
+      end
     end
 
-    def media
-      Media.new
-    end
-  end
+    class Select < Widget
+      attr_accessor :choices
 
-  class Input < Widget
-    class << self
-      attr_accessor :input_type
+      def initialize(attrs=nil, choices=[])
+        super(attrs)
+        @choices = choices.collect
+      end
 
-      # Copy data to the child class
-      def inherited(c)
-        super(c)
-        c.input_type = input_type.dup if input_type
+      def render(name, value, attrs=nil, choices=[])
+        value = '' if value.nil?
+        final_attrs = build_attrs(attrs, name: name)
+        output = ["<select#{flatatt(final_attrs)}>"]
+        options = render_options(choices, [value])
+        output << options if options && !options.empty?
+        output << '</select>'
+        mark_safe(output.join("\n"))
       end
-    end
 
-    self.is_hidden = false
-    self.input_type = nil
+      def render_options(choices, selected_choices)
+        selected_choices = selected_choices.map(&:to_s).uniq
+        output = []
+        (@choices.to_a + choices.to_a).each do |option_value, option_label|
+            option_label ||= option_value
+            if option_label.is_a?(Array)
+              output << '<optgroup label="%s">' % escape(option_value.to_s)
+              option_label.each do |option|
+                val, label = option
+                output << render_option(val, label, selected_choices)
+              end
+              output << '</optgroup>'
+            else
+              output << render_option(option_value, option_label,
+                                      selected_choices)
+            end
+          end
+        output.join("\n")
+      end
 
-    def render(name, value, attrs=nil)
-      value ||= ''
-      final_attrs = build_attrs(attrs,
-                                :type => self.class.input_type.to_s,
-                                :name => name.to_s)
-      final_attrs[:value] = value.to_s unless value == ''
-      mark_safe("<input#{flatatt(final_attrs)} />")
-    end
-  end
+      def render_option(option_attributes, option_label, selected_choices)
+        unless option_attributes.is_a?(Hash)
+          option_attributes = { value: option_attributes.to_s }
+        end
 
-  class TextInput < Input
-    self.input_type = 'text'
-  end
+        if selected_choices.include?(option_attributes[:value])
+          option_attributes[:selected] = "selected"
+        end
 
-  class PasswordInput < Input
-    self.input_type = 'password'
+        attributes = []
 
-    def initialize(attrs=nil, render_value=true)
-      super(attrs)
-      @render_value = render_value
-    end
+        option_attributes.each_pair do |attr_name, attr_value|
+          attributes << %Q[#{attr_name.to_s}="#{escape(attr_value.to_s)}"]
+        end
 
-    def render(name, value, attrs=nil)
-      value = nil unless @render_value
-      super(name, value, attrs)
+        "<option #{attributes.join(' ')}>#{conditional_escape(option_label.to_s)}</option>"
+      end
     end
-  end
 
-  class HiddenInput < Input
-    self.input_type = 'hidden'
-    self.is_hidden = true
-  end
+    class NullBooleanSelect < Select
+      def initialize(attrs=nil)
+        choices = [['1', 'Unknown'], ['2', 'Yes'], ['3', 'No']]
+        super(attrs, choices)
+      end
 
-  class MultipleHiddenInput < HiddenInput
-    # Used by choice fields
-    attr_accessor :choices
+      def render(name, value, attrs=nil, choices=[])
+        value = case value
+                when true, '2' then '2'
+                when false, '3' then '3'
+                else '1'
+                end
+        super(name, value, attrs, choices)
+      end
 
-    def initialize(attrs=nil, choices=[])
-      super(attrs)
-      # choices can be any enumerable
-      @choices = choices
-    end
+      def value_from_formdata(data, name)
+        case data[name]
+        when '2', true, 'true' then true
+        when '3', false, 'false' then false
+        else nil
+        end
+      end
 
-    def render(name, value, attrs=nil, choices=[])
-      value ||= []
-      final_attrs = build_attrs(attrs, :type => self.class.input_type,
-                                :name => name)
-      mark_safe(value.map do |v|
-                  rattrs = {:value => v.to_s}.merge(final_attrs)
-                  "<input#{flatatt(rattrs)} />"
-                end.join("\n"))
-    end
+      def has_changed?(initial, data)
+        unless initial.nil?
+          initial = make_bool(initial)
+        end
+
+        unless data.nil?
+          data = make_bool(data)
+        end
 
-    def value_from_datahash(data, files, name)
-      #if data.is_a?(MultiValueDict) || data.is_a?(MergeDict)
-      #  data.getlist(name)
-      #else
-      #  data[name]
-      #end
-      data[name]
+        initial != data
+      end
     end
-  end
 
-  class FileInput < Input
-    self.input_type = 'file'
-    self.needs_multipart_form = true
+    class SelectMultiple < Select
+      def render(name, value, attrs=nil, choices=[])
+        value = [] if value.nil?
+        final_attrs = build_attrs(attrs, name: "#{name}[]")
+        output = ["<select multiple=\"multiple\"#{flatatt(final_attrs)}>"]
+        options = render_options(choices, value)
+        output << options if options && !options.empty?
+        output << '</select>'
+        mark_safe(output.join("\n"))
+      end
 
-    def render(name, value, attrs=nil)
-      super(name, nil, attrs)
-    end
+      def has_changed?(initial, data)
+        initial = [] if initial.nil?
+        data = [] if data.nil?
 
-    def value_from_datahash(data, files, name)
-      files.fetch(name, nil)
-    end
+        if initial.length != data.length
+          return true
+        end
 
-    def has_changed?(initial, data)
-      data.nil?
+        Set.new(initial.map(&:to_s)) != Set.new(data.map(&:to_s))
+      end
     end
-  end
 
-  class Textarea < Widget
-    def initialize(attrs=nil)
-      # The 'rows' and 'cols' attributes are required for HTML correctness.
-      @attrs = {:cols => '40', :rows => '10'}
-      @attrs.merge!(attrs) if attrs
-    end
+    class RadioInput
+      include Utils
 
-    def render(name, value, attrs=nil)
-      value ||= ''
-      final_attrs = build_attrs(attrs, :name => name)
-      mark_safe("<textarea#{flatatt(final_attrs)}>#{conditional_escape(value.to_s)}</textarea>")
-    end
-  end
+      def initialize(name, value, attrs, choice, index)
+        @name = name
+        @value = value
+        @attrs = attrs
+        @choice_value = choice[0].to_s
+        @choice_label = choice[1].to_s
+        @index = index
+      end
 
-  # DateInput
-  # DateTimeInput
-  # TimeInput
+      def to_s
+        label_for = @attrs.include?(:id) ? " for=\"#{@attrs[:id]}_#{@index}\"" : ''
+        choice_label = conditional_escape(@choice_label.to_s)
+        mark_safe("<label#{label_for}>#{tag} #{choice_label}</label>")
+      end
 
-  class CheckboxInput < Widget
-    def initialize(attrs=nil, check_test=nil)
-      super(attrs)
-      @check_test = check_test || lambda {|v| make_bool(v)}
-    end
+      def checked?
+        @value == @choice_value
+      end
 
-    def render(name, value, attrs=nil)
-      final_attrs = build_attrs(attrs, :type => 'checkbox', :name => name.to_s)
-      result = @check_test.call(value) rescue false
-      final_attrs[:checked] = 'checked' if result
-      final_attrs[:value] = value.to_s unless
-        ['', true, false, nil].include?(value)
-      mark_safe("<input#{flatatt(final_attrs)} />")
+      def tag
+        @attrs[:id] = "#{@attrs[:id]}_#{@index}" if @attrs.include?(:id)
+        final_attrs = @attrs.merge(type: 'radio', name: @name,
+                                   value: @choice_value)
+        final_attrs[:checked] = 'checked' if checked?
+        mark_safe("<input#{flatatt(final_attrs)} />")
+      end
     end
 
-    def value_from_datahash(data, files, name)
-      data.include?(name) ? super(data, files, name) : false
-    end
+    class RadioFieldRenderer
+      include Utils
 
-    def has_changed(initial, data)
-      make_bool(initial) != make_bool(data)
-    end
-  end
+      def initialize(name, value, attrs, choices)
+        @name = name
+        @value = value
+        @attrs = attrs
+        @choices = choices
+      end
 
-  class Select < Widget
-    attr_accessor :choices
+      def each
+        @choices.each_with_index do |choice, i|
+          yield RadioInput.new(@name, @value, @attrs.dup, choice, i)
+        end
+      end
 
-    def initialize(attrs=nil, choices=[])
-      super(attrs)
-      @choices = choices.collect
-    end
+      def [](idx)
+        choice = @choices[idx]
+        RadioInput.new(@name, @value, @attrs.dup, choice, idx)
+      end
 
-    def render(name, value, attrs=nil, choices=[])
-      value = '' if value.nil?
-      final_attrs = build_attrs(attrs, :name => name)
-      output = ["<select#{flatatt(final_attrs)}>"]
-      options = render_options(choices, [value])
-      output << options if options && !options.empty?
-      output << '</select>'
-      mark_safe(output.join("\n"))
-    end
+      def to_s
+        render
+      end
 
-    def render_options(choices, selected_choices)
-      selected_choices = selected_choices.map(&:to_s).uniq
-      output = []
-      (@choices + choices).each do |option_value, option_label|
-          if option_label.is_a?(Array)
-            output << '<optgroup label="%s">' % escape(option_value.to_s)
-            option_label.each do |option|
-              val, label = option
-              output << render_option(val, label, selected_choices)
-            end
-            output << '</optgroup>'
-          else
-            output << render_option(option_value, option_label,
-                                    selected_choices)
-          end
-        end
-      output.join("\n")
+      def render
+        list = []
+        each {|radio| list << "<li>#{radio}</li>"}
+        mark_safe("<ul>\n#{list.join("\n")}\n</ul>")
+      end
     end
 
-    def render_option(option_value, option_label, selected_choices)
-      option_value = option_value.to_s
-      selected_html = selected_choices.include?(option_value) ? ' selected="selected"' : ''
-      "<option value=\"#{escape(option_value)}\"#{selected_html}>#{conditional_escape(option_label.to_s)}</option>"
-    end
-  end
+    class RadioSelect < Select
+      def self.id_for_label(id_)
+        id_.empty? ? id_ : id_ + '_0'
+      end
 
-  class NullBooleanSelect < Select
-    def initialize(attrs=nil)
-      choices = [['1', 'Unknown'], ['2', 'Yes'], ['3', 'No']]
-      super(attrs, choices)
-    end
+      def renderer
+        RadioFieldRenderer
+      end
 
-    def render(name, value, attrs=nil, choices=[])
-      value = case value
-              when true, '2' then '2'
-              when false, '3' then '3'
-              else '1'
-              end
-      super(name, value, attrs, choices)
-    end
+      def initialize(*args)
+        options = args.last.is_a?(Hash) ? args.last : {}
+        @renderer = options.fetch(:renderer, renderer)
+        super
+      end
 
-    def value_from_datahash(data, files, name)
-      value = data[name]
-      case value
-      when '2', true then true
-      when '3', false then false
-      else nil
+      def get_renderer(name, value, attrs=nil, choices=[])
+        value ||= ''
+        str_value = value.to_s
+        final_attrs = build_attrs(attrs)
+        choices = @choices.to_a + choices.to_a
+        @renderer.new(name, str_value, final_attrs, choices)
       end
-    end
 
-    def has_changed?(initial, data)
-      make_bool(initial) != make_bool(data)
+      def render(name, value, attrs=nil, choices=[])
+        get_renderer(name, value, attrs, choices).render
+      end
     end
-  end
 
-  class SelectMultiple < Select
-    def render(name, value, attrs=nil, choices=[])
-      value = [] if value.nil?
-      final_attrs = build_attrs(attrs, :name => name)
-      output = ["<select multiple=\"multiple\"#{flatatt(final_attrs)}>"]
-      options = render_options(choices, value)
-      output << options if options && !options.empty?
-      output << '</select>'
-      mark_safe(output.join("\n"))
-    end
+    class CheckboxSelectMultiple < SelectMultiple
+      def self.id_for_label(id_)
+        id_.empty? ? id_ : id_ + '_0'
+      end
 
-    def value_from_datahash(data, files, name)
-      #if data.is_a?(MultiValueDict) || data.is_a?(MergeDict)
-      #  data.getlist(name)
-      #else
-      #  data[name]
-      #end
-      data[name]
-    end
+      def render(name, values, attrs=nil, choices=[])
+        values ||= []
+        multi_name = "#{name}[]"
+        has_id = attrs && attrs.include?(:id)
+        final_attrs = build_attrs(attrs, name: multi_name)
+        output = ['<ul>']
+        str_values = {}
+        values.each {|val| str_values[(val.to_s)] = true}
+
+        (@choices.to_a + choices.to_a).each_with_index do |opt_pair, i|
+            opt_val, opt_label = opt_pair
+            if has_id
+              final_attrs[:id] = "#{attrs[:id]}_#{i}"
+              label_for = " for=\"#{final_attrs[:id]}\""
+            else
+              label_for = ''
+            end
 
-    def has_changed?(initial, data)
-      initial = [] if initial.nil?
-      data = [] if data.nil?
-      return true if initial.length != data.length
-      initial.zip(data).each do |value1, value2|
-          return true if value1.to_s != value2.to_s
-        end
-      false
+            check_test = lambda{|value| str_values[value]}
+            cb = CheckboxInput.new(final_attrs, check_test)
+            opt_val = opt_val.to_s
+            rendered_cb = cb.render(multi_name, opt_val)
+            opt_label = conditional_escape(opt_label.to_s)
+            output << "<li><label#{label_for}>#{rendered_cb} #{opt_label}</label></li>"
+          end
+        output << '</ul>'
+        mark_safe(output.join("\n"))
+      end
     end
+
+    # TODO: MultiWidget < Widget
+    # TODO: SplitDateTimeWidget < MultiWidget
+    # TODO: SplitHiddenDateTimeWidget < SplitDateTimeWidget
+
   end
-end; end
+end