Class: LogEntry

Inherits:
Object
  • Object
show all
Includes:
Hashify
Defined in:
lib/log_entry.rb

Overview

A single log entry in a DailyLog.

See Also:

Constant Summary collapse

PERSON_REGEX = 
/(?:\s|^)[~@](\w+)/

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Hashify

#to_hash

Constructor Details

#initialize(params = {}) ⇒ LogEntry

Returns a new instance of LogEntry.



33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/log_entry.rb', line 33

def initialize(params = {})
  @time = params[:time]
  # If tags are nil, set to empty array.
  # This is similar to the CLI default value.
  @tags = params[:tags] || []
  @ticket = params[:ticket]
  @url = params[:url] || ''
  @epic = params[:epic]
  @message = params[:message]
  @project = params[:project]

  # Back reference to the day
  @day = params[:day] || nil
end

Instance Attribute Details

#day ⇒ Object (readonly)

Returns the value of attribute day.



31
32
33
 
# File 'lib/log_entry.rb', line 31

def day
  @day
end

#epic ⇒ Boolean

Returns whether the log entry is an epic.

Returns:

  • (Boolean) —

    whether the log entry is an epic.



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/log_entry.rb', line 24

class LogEntry
  PERSON_REGEX = /(?:\s|^)[~@](\w+)/

  include Hashify

  attr_accessor :time, :tags, :ticket, :url, :epic, :message, :project

  attr_reader :day

  def initialize(params = {})
    @time = params[:time]
    # If tags are nil, set to empty array.
    # This is similar to the CLI default value.
    @tags = params[:tags] || []
    @ticket = params[:ticket]
    @url = params[:url] || ''
    @epic = params[:epic]
    @message = params[:message]
    @project = params[:project]

    # Back reference to the day
    @day = params[:day] || nil
  end

  # Returns true if the entry is an epic, false otherwise.
  # @return [Boolean]
  def epic?
    @epic == true
  end

  # Returns the message string with formatting without the time.
  # @param known_people Hash[String, Person] A hash of people with their handles as keys.
  def message_string(known_people = nil)
    # replace all mentions of people with their names.
    msg = @message.dup
    people.each do |person|
      next unless known_people && known_people[person]

      msg.gsub!(/[~@]#{person}/) do |match|
        s = ''
        s += ' ' if match[0] == ' '
        s += "#{Rainbow(known_people[person].name).underline} (~#{person})" if known_people && known_people[person]
        s
      end
    end

    s = ''

    s += if epic
           Rainbow("[EPIC] #{msg}").bg(:white).fg(:black)
         else
           msg
         end

    s += "  [#{Rainbow(@ticket).fg(:blue)}]" if @ticket

    # Add tags in brackets if defined.
    s += '  [' + @tags.map { |tag| "#{tag}" }.join(', ') + ']' if @tags && @tags.size > 0

    # Add URL in brackets if defined.
    s += "  [#{@url}]" if @url && @url != ''

    s += "  [#{@project}]" if @project && @project != ''

    s
  end

  def people
    # Return people that are mentioned in the entry. People are defined as character sequences
    # starting with @ or ~. Whitespaces are used to separate people. Punctuation is ignored.
    # Empty set if no people are mentioned.
    # @return [Set<String>]
    @message.scan(PERSON_REGEX).flatten.uniq.sort.to_set
  end

  # Return true if there are people in the entry.
  #
  # @return [Boolean]
  def people?
    people.size.positive?
  end

  # Convert the log entry to YAML format.
  def to_yaml
    to_hash.to_yaml
  end

  # Compare two log entries for equality.
  #
  # @param other [LogEntry] The other log entry to compare against.
  # @return [Boolean] True if the log entries are equal, false otherwise.
  def ==(other)
    time == other.time && tags == other.tags && ticket == other.ticket && url == other.url &&
      epic == other.epic && message == other.message
  end
end

#message ⇒ String

Returns the message of the log entry.

Returns:

  • (String) —

    the message of the log entry.



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/log_entry.rb', line 24

class LogEntry
  PERSON_REGEX = /(?:\s|^)[~@](\w+)/

  include Hashify

  attr_accessor :time, :tags, :ticket, :url, :epic, :message, :project

  attr_reader :day

  def initialize(params = {})
    @time = params[:time]
    # If tags are nil, set to empty array.
    # This is similar to the CLI default value.
    @tags = params[:tags] || []
    @ticket = params[:ticket]
    @url = params[:url] || ''
    @epic = params[:epic]
    @message = params[:message]
    @project = params[:project]

    # Back reference to the day
    @day = params[:day] || nil
  end

  # Returns true if the entry is an epic, false otherwise.
  # @return [Boolean]
  def epic?
    @epic == true
  end

  # Returns the message string with formatting without the time.
  # @param known_people Hash[String, Person] A hash of people with their handles as keys.
  def message_string(known_people = nil)
    # replace all mentions of people with their names.
    msg = @message.dup
    people.each do |person|
      next unless known_people && known_people[person]

      msg.gsub!(/[~@]#{person}/) do |match|
        s = ''
        s += ' ' if match[0] == ' '
        s += "#{Rainbow(known_people[person].name).underline} (~#{person})" if known_people && known_people[person]
        s
      end
    end

    s = ''

    s += if epic
           Rainbow("[EPIC] #{msg}").bg(:white).fg(:black)
         else
           msg
         end

    s += "  [#{Rainbow(@ticket).fg(:blue)}]" if @ticket

    # Add tags in brackets if defined.
    s += '  [' + @tags.map { |tag| "#{tag}" }.join(', ') + ']' if @tags && @tags.size > 0

    # Add URL in brackets if defined.
    s += "  [#{@url}]" if @url && @url != ''

    s += "  [#{@project}]" if @project && @project != ''

    s
  end

  def people
    # Return people that are mentioned in the entry. People are defined as character sequences
    # starting with @ or ~. Whitespaces are used to separate people. Punctuation is ignored.
    # Empty set if no people are mentioned.
    # @return [Set<String>]
    @message.scan(PERSON_REGEX).flatten.uniq.sort.to_set
  end

  # Return true if there are people in the entry.
  #
  # @return [Boolean]
  def people?
    people.size.positive?
  end

  # Convert the log entry to YAML format.
  def to_yaml
    to_hash.to_yaml
  end

  # Compare two log entries for equality.
  #
  # @param other [LogEntry] The other log entry to compare against.
  # @return [Boolean] True if the log entries are equal, false otherwise.
  def ==(other)
    time == other.time && tags == other.tags && ticket == other.ticket && url == other.url &&
      epic == other.epic && message == other.message
  end
end

#project ⇒ String

Returns the project associated with the log entry.

Returns:

  • (String) —

    the project associated with the log entry.



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/log_entry.rb', line 24

class LogEntry
  PERSON_REGEX = /(?:\s|^)[~@](\w+)/

  include Hashify

  attr_accessor :time, :tags, :ticket, :url, :epic, :message, :project

  attr_reader :day

  def initialize(params = {})
    @time = params[:time]
    # If tags are nil, set to empty array.
    # This is similar to the CLI default value.
    @tags = params[:tags] || []
    @ticket = params[:ticket]
    @url = params[:url] || ''
    @epic = params[:epic]
    @message = params[:message]
    @project = params[:project]

    # Back reference to the day
    @day = params[:day] || nil
  end

  # Returns true if the entry is an epic, false otherwise.
  # @return [Boolean]
  def epic?
    @epic == true
  end

  # Returns the message string with formatting without the time.
  # @param known_people Hash[String, Person] A hash of people with their handles as keys.
  def message_string(known_people = nil)
    # replace all mentions of people with their names.
    msg = @message.dup
    people.each do |person|
      next unless known_people && known_people[person]

      msg.gsub!(/[~@]#{person}/) do |match|
        s = ''
        s += ' ' if match[0] == ' '
        s += "#{Rainbow(known_people[person].name).underline} (~#{person})" if known_people && known_people[person]
        s
      end
    end

    s = ''

    s += if epic
           Rainbow("[EPIC] #{msg}").bg(:white).fg(:black)
         else
           msg
         end

    s += "  [#{Rainbow(@ticket).fg(:blue)}]" if @ticket

    # Add tags in brackets if defined.
    s += '  [' + @tags.map { |tag| "#{tag}" }.join(', ') + ']' if @tags && @tags.size > 0

    # Add URL in brackets if defined.
    s += "  [#{@url}]" if @url && @url != ''

    s += "  [#{@project}]" if @project && @project != ''

    s
  end

  def people
    # Return people that are mentioned in the entry. People are defined as character sequences
    # starting with @ or ~. Whitespaces are used to separate people. Punctuation is ignored.
    # Empty set if no people are mentioned.
    # @return [Set<String>]
    @message.scan(PERSON_REGEX).flatten.uniq.sort.to_set
  end

  # Return true if there are people in the entry.
  #
  # @return [Boolean]
  def people?
    people.size.positive?
  end

  # Convert the log entry to YAML format.
  def to_yaml
    to_hash.to_yaml
  end

  # Compare two log entries for equality.
  #
  # @param other [LogEntry] The other log entry to compare against.
  # @return [Boolean] True if the log entries are equal, false otherwise.
  def ==(other)
    time == other.time && tags == other.tags && ticket == other.ticket && url == other.url &&
      epic == other.epic && message == other.message
  end
end

#tags ⇒ Array<String>

Returns the tags associated with the log entry.

Returns:

  • (Array<String>) —

    the tags associated with the log entry.



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/log_entry.rb', line 24

class LogEntry
  PERSON_REGEX = /(?:\s|^)[~@](\w+)/

  include Hashify

  attr_accessor :time, :tags, :ticket, :url, :epic, :message, :project

  attr_reader :day

  def initialize(params = {})
    @time = params[:time]
    # If tags are nil, set to empty array.
    # This is similar to the CLI default value.
    @tags = params[:tags] || []
    @ticket = params[:ticket]
    @url = params[:url] || ''
    @epic = params[:epic]
    @message = params[:message]
    @project = params[:project]

    # Back reference to the day
    @day = params[:day] || nil
  end

  # Returns true if the entry is an epic, false otherwise.
  # @return [Boolean]
  def epic?
    @epic == true
  end

  # Returns the message string with formatting without the time.
  # @param known_people Hash[String, Person] A hash of people with their handles as keys.
  def message_string(known_people = nil)
    # replace all mentions of people with their names.
    msg = @message.dup
    people.each do |person|
      next unless known_people && known_people[person]

      msg.gsub!(/[~@]#{person}/) do |match|
        s = ''
        s += ' ' if match[0] == ' '
        s += "#{Rainbow(known_people[person].name).underline} (~#{person})" if known_people && known_people[person]
        s
      end
    end

    s = ''

    s += if epic
           Rainbow("[EPIC] #{msg}").bg(:white).fg(:black)
         else
           msg
         end

    s += "  [#{Rainbow(@ticket).fg(:blue)}]" if @ticket

    # Add tags in brackets if defined.
    s += '  [' + @tags.map { |tag| "#{tag}" }.join(', ') + ']' if @tags && @tags.size > 0

    # Add URL in brackets if defined.
    s += "  [#{@url}]" if @url && @url != ''

    s += "  [#{@project}]" if @project && @project != ''

    s
  end

  def people
    # Return people that are mentioned in the entry. People are defined as character sequences
    # starting with @ or ~. Whitespaces are used to separate people. Punctuation is ignored.
    # Empty set if no people are mentioned.
    # @return [Set<String>]
    @message.scan(PERSON_REGEX).flatten.uniq.sort.to_set
  end

  # Return true if there are people in the entry.
  #
  # @return [Boolean]
  def people?
    people.size.positive?
  end

  # Convert the log entry to YAML format.
  def to_yaml
    to_hash.to_yaml
  end

  # Compare two log entries for equality.
  #
  # @param other [LogEntry] The other log entry to compare against.
  # @return [Boolean] True if the log entries are equal, false otherwise.
  def ==(other)
    time == other.time && tags == other.tags && ticket == other.ticket && url == other.url &&
      epic == other.epic && message == other.message
  end
end

#ticket ⇒ String

Returns the ticket associated with the log entry.

Returns:

  • (String) —

    the ticket associated with the log entry.



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/log_entry.rb', line 24

class LogEntry
  PERSON_REGEX = /(?:\s|^)[~@](\w+)/

  include Hashify

  attr_accessor :time, :tags, :ticket, :url, :epic, :message, :project

  attr_reader :day

  def initialize(params = {})
    @time = params[:time]
    # If tags are nil, set to empty array.
    # This is similar to the CLI default value.
    @tags = params[:tags] || []
    @ticket = params[:ticket]
    @url = params[:url] || ''
    @epic = params[:epic]
    @message = params[:message]
    @project = params[:project]

    # Back reference to the day
    @day = params[:day] || nil
  end

  # Returns true if the entry is an epic, false otherwise.
  # @return [Boolean]
  def epic?
    @epic == true
  end

  # Returns the message string with formatting without the time.
  # @param known_people Hash[String, Person] A hash of people with their handles as keys.
  def message_string(known_people = nil)
    # replace all mentions of people with their names.
    msg = @message.dup
    people.each do |person|
      next unless known_people && known_people[person]

      msg.gsub!(/[~@]#{person}/) do |match|
        s = ''
        s += ' ' if match[0] == ' '
        s += "#{Rainbow(known_people[person].name).underline} (~#{person})" if known_people && known_people[person]
        s
      end
    end

    s = ''

    s += if epic
           Rainbow("[EPIC] #{msg}").bg(:white).fg(:black)
         else
           msg
         end

    s += "  [#{Rainbow(@ticket).fg(:blue)}]" if @ticket

    # Add tags in brackets if defined.
    s += '  [' + @tags.map { |tag| "#{tag}" }.join(', ') + ']' if @tags && @tags.size > 0

    # Add URL in brackets if defined.
    s += "  [#{@url}]" if @url && @url != ''

    s += "  [#{@project}]" if @project && @project != ''

    s
  end

  def people
    # Return people that are mentioned in the entry. People are defined as character sequences
    # starting with @ or ~. Whitespaces are used to separate people. Punctuation is ignored.
    # Empty set if no people are mentioned.
    # @return [Set<String>]
    @message.scan(PERSON_REGEX).flatten.uniq.sort.to_set
  end

  # Return true if there are people in the entry.
  #
  # @return [Boolean]
  def people?
    people.size.positive?
  end

  # Convert the log entry to YAML format.
  def to_yaml
    to_hash.to_yaml
  end

  # Compare two log entries for equality.
  #
  # @param other [LogEntry] The other log entry to compare against.
  # @return [Boolean] True if the log entries are equal, false otherwise.
  def ==(other)
    time == other.time && tags == other.tags && ticket == other.ticket && url == other.url &&
      epic == other.epic && message == other.message
  end
end

#time ⇒ DateTime

Returns the date and time of the log entry.

Returns:

  • (DateTime) —

    the date and time of the log entry.



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/log_entry.rb', line 24

class LogEntry
  PERSON_REGEX = /(?:\s|^)[~@](\w+)/

  include Hashify

  attr_accessor :time, :tags, :ticket, :url, :epic, :message, :project

  attr_reader :day

  def initialize(params = {})
    @time = params[:time]
    # If tags are nil, set to empty array.
    # This is similar to the CLI default value.
    @tags = params[:tags] || []
    @ticket = params[:ticket]
    @url = params[:url] || ''
    @epic = params[:epic]
    @message = params[:message]
    @project = params[:project]

    # Back reference to the day
    @day = params[:day] || nil
  end

  # Returns true if the entry is an epic, false otherwise.
  # @return [Boolean]
  def epic?
    @epic == true
  end

  # Returns the message string with formatting without the time.
  # @param known_people Hash[String, Person] A hash of people with their handles as keys.
  def message_string(known_people = nil)
    # replace all mentions of people with their names.
    msg = @message.dup
    people.each do |person|
      next unless known_people && known_people[person]

      msg.gsub!(/[~@]#{person}/) do |match|
        s = ''
        s += ' ' if match[0] == ' '
        s += "#{Rainbow(known_people[person].name).underline} (~#{person})" if known_people && known_people[person]
        s
      end
    end

    s = ''

    s += if epic
           Rainbow("[EPIC] #{msg}").bg(:white).fg(:black)
         else
           msg
         end

    s += "  [#{Rainbow(@ticket).fg(:blue)}]" if @ticket

    # Add tags in brackets if defined.
    s += '  [' + @tags.map { |tag| "#{tag}" }.join(', ') + ']' if @tags && @tags.size > 0

    # Add URL in brackets if defined.
    s += "  [#{@url}]" if @url && @url != ''

    s += "  [#{@project}]" if @project && @project != ''

    s
  end

  def people
    # Return people that are mentioned in the entry. People are defined as character sequences
    # starting with @ or ~. Whitespaces are used to separate people. Punctuation is ignored.
    # Empty set if no people are mentioned.
    # @return [Set<String>]
    @message.scan(PERSON_REGEX).flatten.uniq.sort.to_set
  end

  # Return true if there are people in the entry.
  #
  # @return [Boolean]
  def people?
    people.size.positive?
  end

  # Convert the log entry to YAML format.
  def to_yaml
    to_hash.to_yaml
  end

  # Compare two log entries for equality.
  #
  # @param other [LogEntry] The other log entry to compare against.
  # @return [Boolean] True if the log entries are equal, false otherwise.
  def ==(other)
    time == other.time && tags == other.tags && ticket == other.ticket && url == other.url &&
      epic == other.epic && message == other.message
  end
end

#url ⇒ String

Returns the URL associated with the log entry.

Returns:

  • (String) —

    the URL associated with the log entry.



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/log_entry.rb', line 24

class LogEntry
  PERSON_REGEX = /(?:\s|^)[~@](\w+)/

  include Hashify

  attr_accessor :time, :tags, :ticket, :url, :epic, :message, :project

  attr_reader :day

  def initialize(params = {})
    @time = params[:time]
    # If tags are nil, set to empty array.
    # This is similar to the CLI default value.
    @tags = params[:tags] || []
    @ticket = params[:ticket]
    @url = params[:url] || ''
    @epic = params[:epic]
    @message = params[:message]
    @project = params[:project]

    # Back reference to the day
    @day = params[:day] || nil
  end

  # Returns true if the entry is an epic, false otherwise.
  # @return [Boolean]
  def epic?
    @epic == true
  end

  # Returns the message string with formatting without the time.
  # @param known_people Hash[String, Person] A hash of people with their handles as keys.
  def message_string(known_people = nil)
    # replace all mentions of people with their names.
    msg = @message.dup
    people.each do |person|
      next unless known_people && known_people[person]

      msg.gsub!(/[~@]#{person}/) do |match|
        s = ''
        s += ' ' if match[0] == ' '
        s += "#{Rainbow(known_people[person].name).underline} (~#{person})" if known_people && known_people[person]
        s
      end
    end

    s = ''

    s += if epic
           Rainbow("[EPIC] #{msg}").bg(:white).fg(:black)
         else
           msg
         end

    s += "  [#{Rainbow(@ticket).fg(:blue)}]" if @ticket

    # Add tags in brackets if defined.
    s += '  [' + @tags.map { |tag| "#{tag}" }.join(', ') + ']' if @tags && @tags.size > 0

    # Add URL in brackets if defined.
    s += "  [#{@url}]" if @url && @url != ''

    s += "  [#{@project}]" if @project && @project != ''

    s
  end

  def people
    # Return people that are mentioned in the entry. People are defined as character sequences
    # starting with @ or ~. Whitespaces are used to separate people. Punctuation is ignored.
    # Empty set if no people are mentioned.
    # @return [Set<String>]
    @message.scan(PERSON_REGEX).flatten.uniq.sort.to_set
  end

  # Return true if there are people in the entry.
  #
  # @return [Boolean]
  def people?
    people.size.positive?
  end

  # Convert the log entry to YAML format.
  def to_yaml
    to_hash.to_yaml
  end

  # Compare two log entries for equality.
  #
  # @param other [LogEntry] The other log entry to compare against.
  # @return [Boolean] True if the log entries are equal, false otherwise.
  def ==(other)
    time == other.time && tags == other.tags && ticket == other.ticket && url == other.url &&
      epic == other.epic && message == other.message
  end
end

Instance Method Details

#==(other) ⇒ Boolean

Compare two log entries for equality.

Parameters:

  • other (LogEntry) —

    The other log entry to compare against.

Returns:

  • (Boolean) —

    True if the log entries are equal, false otherwise.



115
116
117
118
 
# File 'lib/log_entry.rb', line 115

def ==(other)
  time == other.time && tags == other.tags && ticket == other.ticket && url == other.url &&
    epic == other.epic && message == other.message
end

#epic? ⇒ Boolean

Returns true if the entry is an epic, false otherwise.

Returns:

  • (Boolean) 


50
51
52
 
# File 'lib/log_entry.rb', line 50

def epic?
  @epic == true
end

#message_string(known_people = nil) ⇒ Object

Returns the message string with formatting without the time.

Parameters:

  • known_people (defaults to: nil) —

    Hash[String, Person] A hash of people with their handles as keys.



56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/log_entry.rb', line 56

def message_string(known_people = nil)
  # replace all mentions of people with their names.
  msg = @message.dup
  people.each do |person|
    next unless known_people && known_people[person]

    msg.gsub!(/[~@]#{person}/) do |match|
      s = ''
      s += ' ' if match[0] == ' '
      s += "#{Rainbow(known_people[person].name).underline} (~#{person})" if known_people && known_people[person]
      s
    end
  end

  s = ''

  s += if epic
         Rainbow("[EPIC] #{msg}").bg(:white).fg(:black)
       else
         msg
       end

  s += "  [#{Rainbow(@ticket).fg(:blue)}]" if @ticket

  # Add tags in brackets if defined.
  s += '  [' + @tags.map { |tag| "#{tag}" }.join(', ') + ']' if @tags && @tags.size > 0

  # Add URL in brackets if defined.
  s += "  [#{@url}]" if @url && @url != ''

  s += "  [#{@project}]" if @project && @project != ''

  s
end

#people ⇒ Object 



91
92
93
94
95
96
97
 
# File 'lib/log_entry.rb', line 91

def people
  # Return people that are mentioned in the entry. People are defined as character sequences
  # starting with @ or ~. Whitespaces are used to separate people. Punctuation is ignored.
  # Empty set if no people are mentioned.
  # @return [Set<String>]
  @message.scan(PERSON_REGEX).flatten.uniq.sort.to_set
end

#people? ⇒ Boolean

Return true if there are people in the entry.

Returns:

  • (Boolean) 


102
103
104
 
# File 'lib/log_entry.rb', line 102

def people?
  people.size.positive?
end

#to_yaml ⇒ Object

Convert the log entry to YAML format.



107
108
109
 
# File 'lib/log_entry.rb', line 107

def to_yaml
  to_hash.to_yaml
end