Outputs a formatted-blue informational message.
 @param [String] m The message to output
 @return [void]
343953
def info(m)
      puts _word_wrap(m, '# ').blue
      @targets.each { |_, t| t.info(m) }
    end
882244
def display(message, wpm, element_duration, word_ref, strip=False):
    
    fmt = "{0:>8s}: '{1}'"
    key = "text"
    if strip:
        print(fmt.format(key, message.strip()))
    else:
        print(fmt.format(key, message.strip()))
    print(fmt.format("morse", mtalk.encode(message, strip=strip)))
    print(fmt.format("bin", mtalk.encode(message, encoding_type='binary', strip=strip)))
    print("")
    print("{0:>8s}:".format("timing"))
    print(_timing_representation(message))
    print("")
    print("{0:>8s}:".format("spoken reprentation"))
    print(_spoken_representation(message))
    print("")
    print("code speed : %s wpm" % wpm)
    print("element_duration : %s s" % element_duration)
    print("reference word : %r" % word_ref)
    print("")
354622
def colorize(str, sev: :normal_s)
      return str unless color_enabled?

      cc = COLOR_CODE
      color = cc.key?(sev) ? cc[sev] : ''
      "#{color}#{str.sub(cc[:esc_m], color)}#{cc[:esc_m]}"
    end
854615
def colorize_message(message)
      message = message.sub('MONGODB', color('MONGODB', odd? ? CYAN : MAGENTA)).
        sub(%r{(?<=\[')([^']+)}) {|m| color(m, BLUE)}.
        sub(%r{(?<=\]\.)\w+}) {|m| color(m, YELLOW)}
      message.sub('MOPED:', color('MOPED:', odd? ? CYAN : MAGENTA)).
        sub(/\{.+?\}\s/) { |m| color(m, BLUE) }.
        sub(/COMMAND|QUERY|KILL_CURSORS|INSERT|DELETE|UPDATE|GET_MORE|STARTED/) { |m| color(m, YELLOW) }.
        sub(/SUCCEEDED/) { |m| color(m, GREEN) }.
        sub(/FAILED/) { |m| color(m, RED) }.
        sub(/[\d\.]+(s|ms)/) { |m| color(m, GREEN) }
    end
160925
def show(self, msg, indent=0, style="", **kwargs):
        
        if self.enable_verbose:
            new_msg = self.MessageTemplate.with_style.format(
                indent=self.tab * indent,
                style=style,
                msg=msg,
            )
            print(new_msg, **kwargs)
665750
def show_message(
            self,
            text_string,
            scroll_speed=.1,
            text_colour=[255, 255, 255],
            back_colour=[0, 0, 0]
        ):
        

        # We must rotate the pixel map left through 90 degrees when drawing
        # text, see _load_text_assets
        previous_rotation = self._rotation
        self._rotation -= 90
        if self._rotation < 0:
            self._rotation = 270
        dummy_colour = [None, None, None]
        string_padding = [dummy_colour] * 64
        letter_padding = [dummy_colour] * 8
        # Build pixels from dictionary
        scroll_pixels = []
        scroll_pixels.extend(string_padding)
        for s in text_string:
            scroll_pixels.extend(self._trim_whitespace(self._get_char_pixels(s)))
            scroll_pixels.extend(letter_padding)
        scroll_pixels.extend(string_padding)
        # Recolour pixels as necessary
        coloured_pixels = [
            text_colour if pixel == [255, 255, 255] else back_colour
            for pixel in scroll_pixels
        ]
        # Shift right by 8 pixels per frame to scroll
        scroll_length = len(coloured_pixels) // 8
        for i in range(scroll_length - 8):
            start = i * 8
            end = start + 64
            self.set_pixels(coloured_pixels[start:end])
            time.sleep(scroll_speed)
        self._rotation = previous_rotation
172606
function(m) {
	console.log([m.a, m.b, m.c, m.d, m.e, m.f]);
}
1243252
def info(message):
        
        message = message or ""
        if Console.color:
            Console.cprint('OKBLUE', "INFO: ", message)
        else:
            print(Console.msg("INFO: " + message))
1310191
def _printM(self, messages):
        """"""
        if len(messages) == 2:
            print(Style.BRIGHT + messages[0] + Style.RESET_ALL +
                  Fore.BLUE + messages[1] + Style.RESET_ALL)
        else:
            print("Not implemented")
858704
def report(output)
      sortings = output.options[:sort] || [:sum, :mean]
      sortings.each do |sorting|
        report_table(output, sorting, title: "#{title} - by #{sorting}")
      end

      if options[:total]
        output.puts
        output.puts "#{output.colorize(title, :white, :bold)} - total: " + output.colorize(display_value(sum_overall), :brown, :bold)
      end
    end
751447
def warn(m)
      puts _word_wrap(m, '# ').yellow
      @targets.each { |_, t| t.warn(m) }
    end
898941
def write( event )
      title = ''
      priority = 0
      message = if event.instance_of?(::Logsly::Logging182::LogEvent)
          priority = @map[event.level]
          @layout.format(event)
        else
          event.to_s
        end
      return if message.empty?

      message = message.gsub(ColoredRegexp, '')
      if @title_sep
        title, message = message.split(@title_sep)
        title, message = '', title if message.nil?
      end

      growl(title.strip, message.strip, priority)
      self
    end
535564
def text(self):
        
        if self.m_name == -1 or self.m_event != const.TEXT:
            return u''

        return self.sb[self.m_name]
305150
def message_me(msg)
			@msg = msg
			mail from: @msg.email, subject: @msg.subject, body: @msg.content
		end
436100
def action a
      text a.name
      mnemonic a.mnemonic unless a.mnemonic.nil?
      command { a.call }
    end
1279908
def _print_message(self, flag_message=None, color=None, padding=None,
                       reverse=False):
        
        if flag_message:
            flag_message = stdout_encode(flag(flag_message,
                                              color=color if self.pretty else None,
                                              show=False))
            if not reverse:
                print(padd(flag_message, padding),
                      self.format_messages(self.message))
            else:
                print(self.format_messages(self.message),
                      padd(flag_message, padding))
        else:
            print(self.format_messages(self.message))
        self.message = []
557438
def log(message, type = nil)
      unless Alchemy::Shell.silenced?
        case type
        when :skip
          puts "#{color(:yellow)}== Skipping! #{message}#{color(:clear)}"
        when :error
          puts "#{color(:red)}!! ERROR: #{message}#{color(:clear)}"
        when :message
          puts "#{color(:clear)}#{message}"
        else
          puts "#{color(:green)}== #{message}#{color(:clear)}"
        end
      end
    end