doing 2.1.2pre → 2.1.6pre

data/lib/doing/plugin_manager.rb

@@ -28,26 +28,30 @@ module Doing
         plugins
       end
 
-      # Public: Setup the plugin search path
+      # Setup the plugin search path
+      #
+      # @param      add_dir  [String] optional additional
+      #                      path to include
+      #
+      # @return     [Array] Returns an Array of plugin search paths
       #
-      # Returns an Array of plugin search paths
       def plugins_path(add_dir = nil)
         paths = Array(File.join(File.dirname(__FILE__), 'plugins'))
         paths << File.join(add_dir) if add_dir
         paths.map { |d| File.expand_path(d) }
       end
 
-      ##
+
       # Register a plugin
       #
-      # param: +[String|Array]+ title  The name of the plugin (can be an array of names)
-      #
-      # param: +type+ The plugin type (:import, :export)
+      # @param      title  [String|Array] The name of the
+      #                    plugin (can be an array of names)
+      # @param      type   [Symbol] The plugin type
+      #                    (:import, :export)
+      # @param      klass  [Class] The class responding to
+      #                    :render or :import
       #
-      # param: +klass+ The class responding to :render or :import
-      #
-      #
-      # returns: Success boolean
+      # @return     [Boolean] Success boolean
       #
       def register(title, type, klass)
         type = validate_plugin(title, type, klass)
@@ -90,6 +94,15 @@ module Doing
         type
       end
 
+      ##
+      ## Converts a partial symbol to a valid plugin type,
+      ## e.g. :imp => :import
+      ##
+      ## @param      type     [Symbol] the symbol to test
+      ## @param      default  [Symbol] fallback value
+      ##
+      ## @return     [Symbol] :import or :export
+      ##
       def valid_type(type, default: nil)
         type ||= default
 
@@ -154,10 +167,13 @@ module Doing
       end
 
       ##
-      ## Return a regular expression of all
-      ##             plugin triggers for type
+      ## Return a regular expression of all plugin triggers
+      ## for type
+      ##
+      ## @param      type  [Symbol] The type :import or
+      ##                   :export
       ##
-      ## @param      type  The type :import or :export
+      ## @return     [Regexp] regular expression
       ##
       def plugin_regex(type: :export)
         type = valid_type(type)
@@ -168,24 +184,43 @@ module Doing
         Regexp.new("^(?:#{pattern.join('|')})$", true)
       end
 
+      ##
+      ## Return array of available template names
+      ##
+      ## @param      type  [Symbol] Plugin type (:import,
+      ##                   :export)
+      ##
+      ## @return     [Array<String>] template names
+      ##
       def plugin_templates(type: :export)
         type = valid_type(type)
         templates = []
         plugs = plugins[type].clone
         plugs.delete_if { |_t, o| o[:templates].nil? }.each do |_, options|
           options[:templates].each do |t|
-            templates << t[:name]
+            out = t[:name]
+            out += " (#{t[:format]})" if t.key?(:format)
+            templates << out
           end
         end
 
-        templates
+        templates.sort.uniq
       end
 
+      ##
+      ## Return a regular expression of all template
+      ## triggers for type
+      ##
+      ## @param      type  [Symbol] The type :import or
+      ##                   :export
+      ##
+      ## @return     [Regexp] regular expression
+      ##
       def template_regex(type: :export)
         type = valid_type(type)
         pattern = []
         plugs = plugins[type].clone
-        plugs.delete_if { |_t, o| o[:templates].nil? }.each do |_, options|
+        plugs.delete_if { |_, o| o[:templates].nil? }.each do |_, options|
           options[:templates].each do |t|
             pattern << t[:trigger].normalize_trigger
           end
@@ -193,16 +228,44 @@ module Doing
         Regexp.new("^(?:#{pattern.join('|')})$", true)
       end
 
-      def template_for_trigger(trigger, type: :export)
-        type = valid_type(type)
-        plugs = plugins[type].clone
-        plugs.delete_if { |_t, o| o[:templates].nil? }.each do |_, options|
+      ##
+      ## Find and return the appropriate template for a
+      ## trigger string. Outputs a string that can be
+      ## written out to the terminal for redirection
+      ##
+      ## @param      trigger  [String] The trigger to test
+      ## @param      type     [Symbol] the plugin type
+      ##                      (:import, :export)
+      ##
+      ## @return     [String] string content of template for trigger
+      ##
+      def template_for_trigger(trigger, type: :export, save_to: nil)
+        plugins[valid_type(type)].clone.delete_if { |_t, o| o[:templates].nil? }.each do |_, options|
           options[:templates].each do |t|
-            return options[:class].template(trigger) if trigger =~ /^(?:#{t[:trigger].normalize_trigger})$/
+            next unless trigger =~ /^(?:#{t[:trigger].normalize_trigger})$/
+
+            tpl = options[:class].template(trigger)
+            return tpl unless save_to
+
+            raise PluginException.new('No default filename defined', :export, t[:name]) unless t.key?(:filename)
+
+            return save_template(tpl, save_to, t[:filename])
           end
         end
         raise Errors::InvalidArgument, "No template type matched \"#{trigger}\""
       end
+
+      def save_template(tpl, dir, filename)
+        dir = File.expand_path(dir)
+        FileUtils.mkdir_p(dir) unless File.exist?(dir)
+        raise DoingRuntimeError, "Path #{dir} exists but is not a directory" unless File.directory?(dir)
+
+        file = File.join(dir, filename)
+        File.open(file, 'w') do |f|
+          f.puts(tpl)
+          Doing.logger.warn('File update:', "Template written to #{file}")
+        end
+      end
     end
   end
 end

data/lib/doing/plugins/export/dayone_export.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+# title: Day One Export
+# description: Export entries to Day One plist for auto import
+# author: Brett Terpstra
+# url: https://brettterpstra.com
+module Doing
+  class DayOneRenderer
+    attr_accessor :items, :page_title, :totals
+
+    def initialize(page_title, items, totals)
+      @page_title = page_title
+      @items = items
+      @totals = totals
+    end
+
+    def get_binding
+      binding()
+    end
+  end
+
+  class DayoneExport
+    include Doing::Util
+
+    def self.settings
+      {
+        trigger: 'day(?:one)?(?:-(?:days?|entries))?',
+        templates: [
+          { name: 'dayone', trigger: 'day(?:one)?$', format: 'erb', filename: 'dayone.erb' },
+          { name: 'dayone_entry', trigger: 'day(?:one)-entr(?:y|ies)?$', format: 'erb', filename: 'dayone-entry.erb' }
+        ]
+      }
+    end
+
+    def self.template(trigger)
+      case trigger
+      when /day(?:one)-entr(?:y|ies)?$/
+        IO.read(File.join(File.dirname(__FILE__), '../../../templates/doing-dayone-entry.erb'))
+      else
+        IO.read(File.join(File.dirname(__FILE__), '../../../templates/doing-dayone.erb'))
+      end
+    end
+
+    def self.render(wwid, items, variables: {})
+
+      return if items.nil?
+
+      opt = variables[:options]
+      trigger = opt[:output]
+      digest = case trigger
+               when /-days?$/
+                 :day
+               when /-entries$/
+                 :entries
+               else
+                 :digest
+               end
+
+      all_items = []
+      days = {}
+      flagged = false
+      tags = []
+
+      items.each do |i|
+        day_flagged = false
+        date_key = i.date.strftime('%Y-%m-%d')
+
+        if String.method_defined? :force_encoding
+          title = i.title.force_encoding('utf-8').link_urls(format: :markdown)
+          note = i.note.map { |line| line.force_encoding('utf-8').strip.link_urls(format: :markdown) } if i.note
+        else
+          title = i.title.link_urls(format: :markdown)
+          note = i.note.map { |line| line.strip.link_urls(format: :markdown) } if i.note
+        end
+
+        title = "#{title} @project(#{i.section})" unless variables[:is_single]
+
+        tags.concat(i.tag_array).sort!.uniq!
+        flagged = day_flagged = true if i.tags?(wwid.config['marker_tag'])
+
+        interval = wwid.get_interval(i, record: true) if i.title =~ /@done\((\d{4}-\d\d-\d\d \d\d:\d\d.*?)\)/ && opt[:times]
+        interval ||= false
+        human_time = false
+        if interval
+          d, h, m = wwid.format_time(wwid.get_interval(i, formatted: false))
+          human_times = []
+          human_times << format('%<d>d day%<p>s', d: d, p: d == 1 ? '' : 's') if d > 0
+          human_times << format('%<h>d hour%<p>s', h: h, p: h == 1 ? '' : 's') if h > 0
+          human_times << format('%<m>d minute%<p>s', m: m, p: m == 1 ? '' : 's') if m > 0
+          human_time = human_times.join(', ')
+        end
+
+        done = i.tags?('done') ? ' ' : ' '
+
+        item = {
+          date_object: i.date,
+          date: i.date.strftime('%a %-I:%M%p'),
+          shortdate: i.date.relative_date,
+          done: done,
+          note: note,
+          section: i.section,
+          time: interval,
+          human_time: human_time,
+          title: title.strip,
+          starred: day_flagged,
+          tags: i.tag_array
+        }
+        all_items << item
+
+
+        if days.key?(date_key)
+          days[date_key][:starred] = true if day_flagged
+          days[date_key][:tags] = days[date_key][:tags].concat(i.tag_array).sort.uniq
+          days[date_key][:entries].push(item)
+        else
+          days[date_key] ||= { tags: [], entries: [], starred: false }
+          days[date_key][:starred] = true if day_flagged
+          days[date_key][:tags] = days[date_key][:tags].concat(i.tag_array).sort.uniq
+          days[date_key][:entries].push(item)
+        end
+      end
+
+
+      template = if wwid.config['export_templates']['dayone'] && File.exist?(File.expand_path(wwid.config['export_templates']['dayone']))
+                   IO.read(File.expand_path(wwid.config['export_templates']['dayone']))
+                 else
+                   self.template('dayone')
+                 end
+
+      totals = opt[:totals] ? wwid.tag_times(format: :markdown, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
+
+      case digest
+      when :day
+        days.each do |k, hsh|
+          title = "#{k}: #{variables[:page_title]}"
+          to_dayone(template: template,
+                    title: title,
+                    items: hsh[:entries],
+                    totals: '',
+                    date: Time.parse(k),
+                    tags: tags,
+                    starred: hsh[:starred])
+        end
+      when :entries
+        entry_template = if wwid.config['export_templates']['dayone_entry'] && File.exist?(File.expand_path(wwid.config['export_templates']['dayone_entry']))
+                           IO.read(File.expand_path(wwid.config['export_templates']['dayone_entry']))
+                         else
+                           self.template('dayone-entry')
+                         end
+        all_items.each do |item|
+          to_dayone(template: entry_template,
+                    title: '',
+                    items: [item],
+                    totals: '',
+                    date: item[:date_object],
+                    tags: item[:tags],
+                    starred: item[:starred])
+        end
+      else
+        to_dayone(template: template,
+                    title: variables[:page_title],
+                    items: all_items,
+                    totals: totals,
+                    date: Time.now,
+                    tags: tags,
+                    starred: flagged)
+      end
+
+      @out = ''
+    end
+
+    def self.to_dayone(template: self.template(nil), title: 'doing', items: [], totals: '', date: Time.now, tags: [], starred: false)
+      mdx = DayOneRenderer.new(title, items, totals)
+
+      engine = ERB.new(template)
+      content = engine.result(mdx.get_binding)
+
+      uuid = SecureRandom.uuid
+      # uuid = `uuidgen`.strip
+
+      plist = {
+        'Creation Date' => date,
+        'Creator' => { 'Software Agent' => 'Doing/2.0.0' },
+        'Entry Text' => content,
+        'Starred' => starred,
+        'Tags' => tags.sort.uniq.delete_if { |t| t =~ /(done|cancell?ed|from)/ },
+        'UUID' => uuid
+      }
+
+      container = File.expand_path('~/Library/Group Containers/')
+      dayone_dir = Dir.glob('*.dayoneapp2', base: container).first
+      import_dir = File.join(container, dayone_dir, 'Data', 'Auto Import', 'Default Journal.dayone', 'entries')
+      FileUtils.mkdir_p(import_dir) unless File.exist?(import_dir)
+      entry_file = File.join(import_dir, "#{uuid}.doentry")
+      Doing.logger.debug('Day One Export:', "Exporting to #{entry_file}")
+      File.open(entry_file, 'w') do |f|
+        f.puts plist.to_plist
+      end
+
+      Doing.logger.count(:exported, level: :info, count: items.count, message: '%count %items exported to Day One import folder')
+    end
+
+    Doing::Plugins.register 'dayone', :export, self
+    Doing::Plugins.register 'dayone-days', :export, self
+    Doing::Plugins.register 'dayone-entries', :export, self
+  end
+end

data/lib/doing/plugins/export/html_export.rb

@@ -12,8 +12,8 @@ module Doing
       {
         trigger: 'html?|web(?:page)?',
         templates: [
-          { name: 'haml', trigger: 'h[ta]ml?|web' },
-          { name: 'css', trigger: 'css|styl(?:e|us)' }
+          { name: 'html', trigger: 'h[ta]ml?|web', format: 'haml', filename: 'html_export.haml' },
+          { name: 'html_style', trigger: 'css|styl(?:e|us)', format: 'css', filename: 'html_export.css' }
         ]
       }
     end

data/lib/doing/plugins/export/json_export.rb

@@ -134,6 +134,7 @@ module Doing
       end
     end
 
+    Doing::Plugins.register 'json', :export, self
     Doing::Plugins.register 'timeline', :export, self
   end
 end

data/lib/doing/plugins/export/markdown_export.rb

@@ -25,7 +25,7 @@ module Doing
     def self.settings
       {
         trigger: 'markdown|mk?d|gfm',
-        templates: [{ name: 'markdown', trigger: 'mk?d|markdown' }]
+        templates: [{ name: 'markdown', trigger: 'mk?d|markdown', format: 'erb', filename: 'doing-markdown.erb' }]
       }
     end
 

data/lib/doing/plugins/export/template_export.rb

@@ -23,40 +23,36 @@ module Doing
       out = ''
       items.each do |item|
         if opt[:highlight] && item.title =~ /@#{wwid.config['marker_tag']}\b/i
-          # flag = Doing::Color.send(wwid.config['marker_color'])
-          reset = Doing::Color.default
+          flag = Doing::Color.send(wwid.config['marker_color'])
+          reset = Doing::Color.reset + Doing::Color.default
         else
-          # flag = ''
+          flag = ''
           reset = ''
         end
 
+        placeholders = {}
+
         if (!item.note.empty?) && wwid.config['include_notes']
           note = item.note.map(&:strip).delete_if(&:empty?)
           note.map! { |line| "#{line.sub(/^\t*/, '')}  " }
 
           if opt[:wrap_width]&.positive?
             width = opt[:wrap_width]
-            note.map! { |line| line.chomp.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n") }
-            note = note.join("\n").split(/\n/).delete_if(&:empty?)
+            note.map! do |line|
+              line.simple_wrap(width)
+              # line.chomp.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n")
+            end
+            note = note.delete_if(&:empty?)
           end
         else
           note = []
         end
 
-        output = opt[:template].dup
-
-        output.gsub!(/%[a-z]+/) do |m|
-          if Doing::Color.respond_to?(m.sub(/^%/, ''))
-            Doing::Color.send(m.sub(/^%/, ''))
-          else
-            m
-          end
-        end
-
-        output.sub!(/%(\d+)?date/) do
-          pad = Regexp.last_match(1).to_i
-          format("%#{pad}s", item.date.strftime(opt[:format]))
-        end
+        # output.sub!(/%(\d+)?date/) do
+        #   pad = Regexp.last_match(1).to_i
+        #   format("%#{pad}s", item.date.strftime(opt[:format]))
+        # end
+        placeholders['date'] = item.date.strftime(opt[:format])
 
         interval = wwid.get_interval(item, record: true, formatted: false) if opt[:times]
         if interval
@@ -71,7 +67,8 @@ module Doing
         end
 
         interval ||= ''
-        output.sub!(/%interval/, interval)
+        # output.sub!(/%interval/, interval)
+        placeholders['interval'] = interval
 
         duration = item.duration if opt[:duration]
         if duration
@@ -85,78 +82,89 @@ module Doing
           end
         end
         duration ||= ''
-        output.sub!(/%duration/, duration)
-
-        output.sub!(/%(\d+)?shortdate/) do
-          pad = Regexp.last_match(1) || 13
-          format("%#{pad}s", item.date.relative_date)
-        end
-
-        output.sub!(/%section/, item.section) if item.section
-
-        title_rx = /(?mi)%(?<width>-?\d+)?(?:(?<ichar>[ _t])(?<icount>\d+))?(?<prefix>.[ _t]?)?title(?<after>.*?)$/
-        title_color = Doing::Color.reset + output.match(/(?mi)^(.*?)(%.*?title)/)[1].last_color
-
-        title_offset = Doing::Color.uncolor(output).match(title_rx).begin(0)
-
-        output.sub!(title_rx) do
-          m = Regexp.last_match
-
-          after = m['after']
-          pad = m['width'].to_i
-          indent = ''
-          if m['ichar']
-            char = m['ichar'] =~ /t/ ? "\t" : ' '
-            indent = char * m['icount'].to_i
-          end
-          prefix = m['prefix']
-          if opt[:wrap_width]&.positive? || pad.positive?
-            width = pad.positive? ? pad : opt[:wrap_width]
-            item.title.wrap(width, pad: pad, indent: indent, offset: title_offset, prefix: prefix, color: title_color, after: after, reset: reset)
-            # flag + item.title.gsub(/(.{#{opt[:wrap_width]}})(?=\s+|\Z)/, "\\1\n ").sub(/\s*$/, '') + reset
-          else
-            format("%s%#{pad}s%s", prefix, item.title.sub(/\s*$/, ''), after)
-          end
-        end
-
-        # output.sub!(/(?i-m)^([\s\S]*?)(%(?:[io]d|(?:\^[\s\S])?(?:(?:[ _t]|[^a-z0-9])?\d+)?(?:[\s\S][ _t]?)?)?note)([\s\S]*?)$/, '\1\3\2')
-        if opt[:tags_color]
-          output.highlight_tags!(opt[:tags_color])
-        end
-
-        if note.empty?
-          output.gsub!(/%(chomp|[io]d|(\^.)?(([ _t]|[^a-z0-9])?\d+)?(.[ _t]?)?)?note/, '')
-        else
-          output.sub!(/%note/, "\n#{note.map { |l| "\t#{l.strip}  " }.join("\n")}")
-          output.sub!(/%idnote/, "\n#{note.map { |l| "\t\t#{l.strip}  " }.join("\n")}")
-          output.sub!(/%odnote/, "\n#{note.map { |l| "#{l.strip}  " }.join("\n")}")
-          output.sub!(/(?mi)%(?:\^(?<mchar>.))?(?:(?<ichar>[ _t]|[^a-z0-9])?(?<icount>\d+))?(?<prefix>.[ _t]?)?note/) do
-            m = Regexp.last_match
-            mark = m['mchar'] || ''
-            indent = if m['ichar']
-                       char = m['ichar'] =~ /t/ ? "\t" : ' '
-                       char * m['icount'].to_i
-                     else
-                       ''
-                     end
-            prefix = m['prefix'] || ''
-            "\n#{note.map { |l| "#{mark}#{indent}#{prefix}#{l.strip}  " }.join("\n")}"
-          end
-
-          output.sub!(/%chompnote/) do
-            note.map { |l| l.gsub(/\n+/, ' ').gsub(/(^\s*|\s*$)/, '').gsub(/\s+/, ' ') }.join(' ')
-          end
-        end
-
-        output.gsub!(/%hr(_under)?/) do
+        # output.sub!(/%duration/, duration)
+        placeholders['duration'] = duration
+
+        # output.sub!(/%(\d+)?shortdate/) do
+        #   pad = Regexp.last_match(1) || 13
+        #   format("%#{pad}s", item.date.relative_date)
+        # end
+        placeholders['shortdate'] = format("%13s", item.date.relative_date)
+        # output.sub!(/%section/, item.section) if item.section
+        placeholders['section'] = item.section || ''
+        placeholders['title'] = item.title
+
+        # title_rx = /(?mi)%(?<width>-?\d+)?(?:(?<ichar>[ _t])(?<icount>\d+))?(?<prefix>.[ _t]?)?title(?<after>.*?)$/
+        # title_color = Doing::Color.reset + output.match(/(?mi)^(.*?)(%.*?title)/)[1].last_color
+
+        # title_offset = Doing::Color.uncolor(output).match(title_rx).begin(0)
+
+        # output.sub!(title_rx) do
+        #   m = Regexp.last_match
+
+        #   after = m['after']
+        #   pad = m['width'].to_i
+        #   indent = ''
+        #   if m['ichar']
+        #     char = m['ichar'] =~ /t/ ? "\t" : ' '
+        #     indent = char * m['icount'].to_i
+        #   end
+        #   prefix = m['prefix']
+        #   if opt[:wrap_width]&.positive? || pad.positive?
+        #     width = pad.positive? ? pad : opt[:wrap_width]
+        #     item.title.wrap(width, pad: pad, indent: indent, offset: title_offset, prefix: prefix, color: title_color, after: after, reset: reset)
+        #     # flag + item.title.gsub(/(.{#{opt[:wrap_width]}})(?=\s+|\Z)/, "\\1\n ").sub(/\s*$/, '') + reset
+        #   else
+        #     format("%s%#{pad}s%s", prefix, item.title.sub(/\s*$/, ''), after)
+        #   end
+        # end
+
+
+
+        placeholders['note'] = note
+        placeholders['idnote'] = note.empty? ? '' : "\n#{note.map { |l| "\t\t#{l.strip}  " }.join("\n")}"
+        placeholders['odnote'] = note.empty? ? '' : "\n#{note.map { |l| "#{l.strip}  " }.join("\n")}"
+        placeholders['chompnote'] = note.empty? ? '' : note.map { |l| l.gsub(/\n+/, ' ').gsub(/(^\s*|\s*$)/, '').gsub(/\s+/, ' ') }.join(' ')
+
+        # if note.empty?
+        #   output.gsub!(/%(chomp|[io]d|(\^.)?(([ _t]|[^a-z0-9])?\d+)?(.[ _t]?)?)?note/, '')
+        # else
+        #   output.sub!(/%note/, "\n#{note.map { |l| "\t#{l.strip}  " }.join("\n")}")
+        #   output.sub!(/%idnote/, "\n#{note.map { |l| "\t\t#{l.strip}  " }.join("\n")}")
+        #   output.sub!(/%odnote/, "\n#{note.map { |l| "#{l.strip}  " }.join("\n")}")
+        #   output.sub!(/(?mi)%(?:\^(?<mchar>.))?(?:(?<ichar>[ _t]|[^a-z0-9])?(?<icount>\d+))?(?<prefix>.[ _t]?)?note/) do
+        #     m = Regexp.last_match
+        #     mark = m['mchar'] || ''
+        #     indent = if m['ichar']
+        #                char = m['ichar'] =~ /t/ ? "\t" : ' '
+        #                char * m['icount'].to_i
+        #              else
+        #                ''
+        #              end
+        #     prefix = m['prefix'] || ''
+        #     "\n#{note.map { |l| "#{mark}#{indent}#{prefix}#{l.strip}  " }.join("\n")}"
+        #   end
+
+        #   output.sub!(/%chompnote/) do
+        #     note.map { |l| l.gsub(/\n+/, ' ').gsub(/(^\s*|\s*$)/, '').gsub(/\s+/, ' ') }.join(' ')
+        #   end
+        # end
+
+        template = opt[:template].dup
+        template.sub!(/(?i-m)^([\s\S]*?)(%(?:[io]d|(?:\^[\s\S])?(?:(?:[ _t]|[^a-z0-9])?\d+)?(?:[\s\S][ _t]?)?)?note)([\s\S]*?)$/, '\1\3\2')
+        output = Doing::TemplateString.new(template, placeholders: placeholders, wrap_width: opt[:wrap_width], color: flag, tags_color: opt[:tags_color], reset: reset).colored
+
+        output.gsub!(/(?<!\\)%hr(_under)?/) do
           o = ''
           `tput cols`.to_i.times do
             o += Regexp.last_match(1).nil? ? '-' : '_'
           end
           o
         end
-        output.gsub!(/%n/, "\n")
-        output.gsub!(/%t/, "\t")
+        output.gsub!(/(?<!\\)%n/, "\n")
+        output.gsub!(/(?<!\\)%t/, "\t")
+
+        output.gsub!(/\\%/, '%')
 
         out += "#{output}\n"
       end