barabara 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5fc704ae054747cbedd0ddd81d1306b8fbb0f430839f80aaafda64cdf29225cd
+  data.tar.gz: 4357e8b018f5b770808f31b35747e30586289295e2b7834b39438608631a6103
+SHA512:
+  metadata.gz: 1ea2f0049b07c412363316266425db72818b56e5fbd3aa122a1006eae248ecbbaf51432964a2c8bc2920117900d610d3d92c1525137906ee1417ce7d591bad25
+  data.tar.gz: 5159919bf03b2314c5f8ae990a177dcd55b3ff84667de3db2a4446c6d2cbfb30a077fdd16088398bbb0c8818c043877086eb399b8fe7e3e5e429d87a1004032d

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/bin/barabara

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'barabara'
+
+# Don't panic on SIGINT
+trap('INT') do
+  puts 'Interrupt caught, exiting.'
+  exit 0
+end
+
+Barabara.run_app

data/lib/barabara.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'yaml'
+require 'wisper'
+require 'barabara/config'
+require 'barabara/app'
+
+module Barabara
+  DEFAULT_CONF = '~/.config/barabara.conf.yml'
+  @init = true
+
+  def self.run_app
+    require 'optimist'
+    opts = Optimist::options do
+      opt :config, "Path to config file",
+          type: :string, default: DEFAULT_CONF
+    end
+
+    config_path = check_config(opts[:config])
+    @app = App.new(config_path)
+    @app.run
+  end
+
+  private
+
+  def self.check_config(path)
+    config_path = File.expand_path path
+    if ! File.exists? config_path
+      if path == DEFAULT_CONF
+        warn 'Config file not found at default location!'
+        warn 'Will write a new one right now...'
+        # TODO dump default config to a file.
+        Configuration.dump_default_config(config_path)
+      else
+        warn "Config file \"#{path}\" not found!"
+        exit 1
+      end
+    end
+
+    config_path
+  end
+end

data/lib/barabara/app.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, 'modules/*.rb')].each { |lib| require lib }
+
+module Barabara
+  class App
+    attr_accessor :threads
+    def initialize(config_path)
+      @threads = []
+      @config = GlobalConfig.init(config_path)
+      bootstrap
+    end
+
+    def run
+      fill_threads
+      @threads.each(&:join)
+    end
+
+    private
+
+    def bootstrap
+      @modules = @config.modules
+      session  = @config.session
+      @modules << Modules::WindowName if session == 'bspwm'
+    end
+
+    def fill_threads
+      @threads << Thread.new do
+        Thread.current.name = 'Event Parser'
+        Wisper.subscribe(Modules::EventProcessor.new, on: :event)
+      end
+
+      @threads << Thread.new do
+        Thread.current.name = 'Panel Feed'
+        Wisper.subscribe(Modules::Lemonbar.new, on: :update_panel)
+      end
+
+      @modules.each do |mod|
+        @threads << Thread.new do
+          Thread.current.name = mod.to_s
+          mod.new.watch
+        end
+      end
+    end
+  end
+end

data/lib/barabara/config.rb

@@ -0,0 +1,108 @@
+# coding: utf-8
+# This file contains the definition of Configuration class,
+# which will store global Barabara configuration and make it
+# available to every entity as a singleton object.
+
+require 'barabara/modules/wm'
+
+module Barabara
+  # Load configuration from a file and store it as an object.
+  class Configuration
+    attr_reader :config, :modules, :session, :monitors
+
+    def initialize(config_file)
+      @config = YAML.load_file config_file
+      @modules = parse_module_list(@config['modules'])
+      @session  = ENV['XDG_SESSION_DESKTOP']
+      @monitors = Modules::WM.get_monitors(@session)
+    end
+
+    def colors; @config['colors']; end
+    def module_options; @config['module_options']; end
+
+    def module_config(mod_name)
+      return {} unless module_options.key?(mod_name)
+
+      module_options[mod_name]
+    end
+
+    def self.dump_default_config(path)
+      File.open(File.expand_path(path), 'w') do |f|
+        f.write default_config.to_yaml
+      end
+    end
+
+    private
+
+    def parse_module_list(list)
+      list.map do |mod|
+        begin
+          Object.const_get("Barabara::Modules::#{mod}")
+        rescue NameError
+          warn "Module \"#{mod}\" not found!"
+          next
+        end
+      end
+    end
+
+    def dump(default: false)
+      (default ? default_config : config).to_yaml
+    end
+
+    def self.default_config
+      {
+        "modules" => ["Battery", "WM", "Clock", "Wttr", "Volume"],
+        "colors"  => { al_winbi:   "#000000", in_framebr: "#101010",
+                       in_framebg: "#565656", in_winbr:   "#454545",
+                       ac_framebr: "#222222", ac_framebg: "#345F0C",
+                       ac_winbr:   "#9FBC00", ac_winbo:   "#3E4A00",
+                       ac_winbi:   "#3E4A00", ur_winbr:   "#FF0675",
+                       se_text:    "#101010", in_text:    "#909090",
+                       mi_text:    "#BCBCBC", ac_text:    "#EFEFEF" },
+        "module_options" => {
+          "lemonbar" => {
+            name: "barabara", height: 12,
+            format: "%%{S%<monitor>s}%%{l}%<tags>s%<sep>s %%{c} %<window_title>s %%{r} %<volume>s %<battery>s %<sep>s %<time>s %<sep>s %<weather>s\n",
+            fonts: {
+              text:   "-lucy-tewi-medium-*-normal-*-11-*-*-*-*-*-*-*",
+              glyphs: "-wuncon-siji-medium-r-normal-*-10-100-75-75-c-80-iso10646-1"
+            },
+            snippets:   { sep: "%%{B-}%%{F%<ac_winbr>s}|%%{F-}" },
+            extra_opts: ["| sh"]
+          },
+          "clock" => {
+            "format" => "%%H%%{F%<in_text>s}:%%{F-}%%M %%{F%<in_text>s}%%Y%%{F%<mi_text>s}%%m%%{F-}%%d"
+          },
+          "wm"      => {
+            "tag_icons" => {
+              "mail"  => "", "work" => "", "web" => "",
+              "im"    => "", "term" => "", "dev" => "",
+              "files" => "", "doc" => "", "docs" => "",
+              "misc"  => ""
+            }
+          },
+          "battery" => { "icons" => { 'low'  => "", 'med' => "", 'high' => "", 'full' => "", 'charge' => "" } },
+          "volume"  => { "icons" => { 'mute' => "", 'low' => "",  'med'  => "",  'max'  => "" } },
+          "weather" => {
+            "api_key" => "<YOUR API KEY HERE>", "location" => "London", "unit" => "c",
+            "format"  => "%%{F%<ac_winbr>s}%<icon>s%%{F-} %<temp>s°"
+          }
+        }
+      }
+    end
+  end
+
+  # Make configuration accessible as a Singleton object.
+  class GlobalConfig
+    class << self
+      def init(path)
+        @path = File.expand_path(path)
+        @config = Configuration.new(@path)
+      end
+
+      def config
+        @config ||= Configuration.new(@path)
+      end
+    end
+  end
+end

data/lib/barabara/modules/battery.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# This module provides battery status functionality.
+# At the moment it just reads a status file from kernel's sysfs,
+# so it only supports Linux.
+#
+# TODO Add Upower support and make it possible
+# to select the preferred mode from config.
+module Barabara
+  module Modules
+    class Battery
+      # Needed for message bus support
+      include Wisper::Publisher
+
+      # Predefined status icons:
+      ICONS = {
+        'low'    => "\ue034",
+        'med'    => "\ue036",
+        'high'   => "\ue037",
+        'full'   => "\ue09e",
+        'charge' => "\ue041"
+      }.freeze
+
+      # Initialize new Battery object.
+      #
+      # @param name [String] System battery name.
+      def initialize(config = GlobalConfig.config.module_config('battery'))
+        @name = config['name'] || ENV['BAT']
+        @path = "/sys/class/power_supply/#{@name}/uevent"
+        @capacity = 100
+        @power = 0.0
+        @status = 'U'
+        @icons = config['icons'] || ICONS
+      end
+
+      # Read battery status from sysfs.
+      # Only updates the object attributes, does not return anything.
+      def parse!
+        IO.readlines(@path).each do |line|
+          case line
+          when /POWER_SUPPLY_STATUS=/
+            @status = line.split('=')[1][0]
+          when /POWER_SUPPLY_CAPACITY=/
+            @capacity = line.split('=')[1].to_i
+          when /POWER_SUPPLY_POWER_NOW=/
+            @power = line.split('=')[1].to_f / 10**6
+          end
+        end
+      end
+
+      # Select battery status icon.
+      #
+      # @return [String] Battery status icon.
+      def icon
+        return 'U' unless @status == 'D'
+
+        case @capacity
+        when 0..35   then @icons['low']
+        when 36..65  then @icons['med']
+        when 66..100 then @icons['high']
+        else 'U'
+        end
+      end
+
+      # Prepare output format string.
+      #
+      # @return [String] Format string suitable for Kernel#printf.
+      def format_string
+        case @status
+        when 'F' then @icons['full']
+        when 'C' then @icons['charge'] + ' %<capacity>d%%'
+        else
+          if @power > 3.5
+            '%<icon>s %<capacity>d%%:%<power>.0fW'
+          else
+            '%<icon>s %<capacity>d%%:%<power>.1fW'
+          end
+        end
+      end
+
+      # Convert battery attributes to hash.
+      #
+      # @return [Hash] Attribute hash suitable for String#format.
+      def to_h
+        { icon: icon, capacity: @capacity, power: @power }
+      end
+
+      # Render battery status as a string.
+      #
+      # @return [String] Battery status (ready for sending to the panel).
+      def render
+        parse!
+        format(format_string, to_h)
+      end
+
+      # Enter event loop and feed the message bus with events.
+      def watch
+        loop do
+          publish(:event, 'battery', render)
+          sleep @status == 'C' ? 30 : 10
+        end
+      end
+    end
+  end
+end

data/lib/barabara/modules/clock.rb

@@ -0,0 +1,38 @@
+module Barabara
+  module Modules
+    class Clock
+      include Wisper::Publisher
+
+      def initialize
+        config = GlobalConfig.config.module_config('clock')
+        colors = GlobalConfig.config.colors
+        @format = format(config['format'], colors) || '%F %R'
+        @time = Time.now
+      end
+
+      attr_reader :time
+
+      def watch
+        loop do
+          update
+          push
+          sleep 5
+        end
+      end
+
+      private
+
+      def push
+        publish(:event, 'time', render)
+      end
+
+      def update
+        @time = Time.now
+      end
+
+      def render
+        @time.strftime(@format)
+      end
+    end
+  end
+end

data/lib/barabara/modules/event_processor.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+module Barabara
+  module Modules
+    class EventProcessor
+      include Wisper::Publisher
+
+      def event(command, args)
+        return false if command == ''
+
+        # STDERR.puts "Got command \"#{command}\": #{args.inspect}."
+        out = case command
+              when 'tagline', 'battery', 'weather', 'time', 'volume'
+                { command.to_sym => args }
+              when /^(focus|window_title)_changed$/
+                { window_title: Modules::WindowName.limit(args[1] || '') }
+              when 'window_title'
+                { window_title: sanitize_window_title(args || '') }
+              else
+                warn "Unknown event \"#{command}\": " + args.inspect
+                {}
+              end
+        publish(:update_panel, out)
+      end
+
+      def sanitize_window_title(title)
+        title.gsub('%{', '%%{')
+      end
+    end
+  end
+end

data/lib/barabara/modules/lemonbar.rb

@@ -0,0 +1,80 @@
+require 'pty'
+
+module Barabara
+  module Modules
+    class Lemonbar
+      attr_reader :panel_pid, :panel_clicks
+      attr_accessor :panel_out, :panel_data
+
+      def initialize
+        options = GlobalConfig.config.module_config('lemonbar')
+        @colors = GlobalConfig.config.colors
+        @monitors = GlobalConfig.config.monitors
+        @format = options[:format].chomp
+        @snippets = fill_snippets(options[:snippets])
+        @cmd = ['lemonbar', *bar_options(options)].join(' ')
+        @panel_data = bootstrap_panel
+
+        run_panel
+      end
+
+      def fill_snippets(snippets)
+        Hash[snippets.map { |k, v| [k, v % @colors] }]
+      end
+
+      def run_panel
+        @panel_clicks, slave = PTY.open
+        read, @panel_out = IO.pipe
+        @panel_pid = spawn(@cmd, in: read, out: slave)
+        slave.close
+        read.close
+      end
+
+      def bar_options(options)
+        cmd_opts = [
+          "-B '#{@colors[:in_framebr]}'",
+          "-F '#{@colors[:ac_text]}'",
+          "-g x#{options[:height]}+0+0",
+          "-n #{options[:name]}", '-a 30',
+          "-f #{options[:fonts][:text]}",
+          "-f #{options[:fonts][:glyphs]}"
+        ]
+        cmd_opts << options[:extra_opts] if options.key?(:extra_opts)
+        cmd_opts
+      end
+
+      def bootstrap_panel
+        @snippets.merge(
+          window_title: 'Welcome home.',
+          tagline: {},
+          battery: 'U',
+          weather: '',
+          time: '',
+          volume: Volume.new.update
+        )
+      end
+
+      def fill_panel
+        string = ''
+        # STDERR.puts 'Panel data:' + @panel_data.inspect
+        @monitors.each do |monitor|
+          string << format(@format,
+                           @panel_data.merge(
+                             tags: @panel_data.dig(:tagline, monitor) || '',
+                             monitor: monitor
+                           ))
+        end
+        string
+      end
+
+      def render
+        @panel_out.puts fill_panel + "\n"
+      end
+
+      def update_panel(data)
+        @panel_data.merge!(data)
+        render
+      end
+    end
+  end
+end

data/lib/barabara/modules/volume.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Barabara
+  module Modules
+    class Volume
+      include Wisper::Publisher
+      # Class constants (Icons) here.
+      ICONS = {
+        'mute' => "\ue04f",
+        'low'  => "\ue04e",
+        'med'  => "\ue050",
+        'max'  => "\ue05d"
+      }.freeze
+      CMD_WATCH = 'pactl subscribe'.freeze
+      CMD_SET   = 'amixer -q set Master'.freeze
+
+      def initialize
+        options = GlobalConfig.config.module_config('volume')
+        @colors = GlobalConfig.config.colors
+        @icons = options['icons'] || ICONS
+
+        @icon = 'mute'
+        @color = :ac_text
+        @mute = true
+        @level = 0
+        fetch
+      end
+
+      def parse
+        return [:in_text, 'mute'] if @mute
+
+        case @level
+        when 60..100 then [:ac_text, 'max']
+        when 30..60 then  [:mi_text, 'med']
+        when 0..30 then   [:in_text, 'low']
+        end
+      end
+
+      def watch
+        PTY.spawn(CMD_WATCH) do |read, _write, pid|
+          read.each { |line| parse_line(line.chomp) }
+          Process.wait pid
+        end
+      end
+
+      def parse_line(line)
+        publish(:event, 'volume', update) if line.match?(/^Event 'change' on sink/)
+      end
+
+      def fetch
+        sleep 0.01
+        raw_data = `amixer get Master`
+        keys = raw_data
+                 .match(/Front Left:.* \[(?<level>\d+)%\] \[(?<state>[onf]+)\]/)
+                 .named_captures
+
+        @level = keys['level'].to_i
+        @mute = keys['state'] == 'off'
+        @color, @icon = parse
+        self
+      end
+
+      def mute
+        spawn(CMD_SET + ' toggle')
+        fetch
+      end
+
+      def up
+        spawn(CMD_SET + ' 2%+ unmute')
+        fetch
+      end
+
+      def down
+        spawn(CMD_SET + ' 2%- unmute')
+        fetch
+      end
+
+      def format_string
+        if @mute
+          '%%{F%<color>s}%<icon>s%%{F-}'
+        else
+          '%%{F%<color>s}%<icon>s %<level>s%%%%%%{F-}'
+        end
+      end
+
+      def to_h
+        { icon: @icons[@icon], color: @colors[@color], level: @level }
+      end
+
+      def render
+        format(format_string, to_h)
+      end
+
+      def update
+        fetch
+        render
+      end
+    end
+  end
+end

data/lib/barabara/modules/weather.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Barabara
+  module Modules
+    class Weather
+      include Wisper::Publisher
+      require 'net/http'
+      require 'json'
+
+      def initialize
+        options = GlobalConfig.config.module_config('weather')
+        @colors = GlobalConfig.config.colors
+
+        @api_key = options['api_key'] || '0'
+        @location = options['location'] || 'London'
+        @uri = format_uri(@api_key, @location)
+        @raw_data = fetch
+        @temp = 0
+        @unit = options['unit'] || 'c'
+        @icon = '?'
+        @format = options['format']
+      end
+
+      def format_uri(api_key, location)
+        uri = URI('http://api.apixu.com/v1/current.json')
+        query = URI.encode_www_form(key: api_key, q: location)
+        uri.query = query
+        uri
+      end
+
+      def fetch
+        Net::HTTP.get_response(@uri)
+      rescue SocketError
+        '⌚'
+      end
+
+      def cond_icon(condition)
+        case condition
+        when /cloudy|cast|fog|mist/i then '☁'
+        when /clear|sunny/i then '☀'
+        when /outbreaks|rain|drizzle|thunder/i then '☂'
+        when /sleet|ice|snow/i then '☃'
+        else '?'
+        end
+      end
+
+      def parse!
+        weatherdata = JSON.parse(@raw_data.body)['current']
+        @temp, condition = weatherdata.fetch_values("temp_#{@unit}", 'condition')
+        @icon = cond_icon(condition['text'])
+      end
+
+      def render
+        @raw_data = fetch
+        return '⌚' unless @raw_data.is_a?(Net::HTTPSuccess)
+
+        parse!
+        sign = '+' if @temp.positive?
+        format(@format,
+               { temp: "#{sign}#{@temp.to_i}", icon: @icon }.merge(@colors))
+      end
+
+      def watch
+        loop do
+          publish(:event, 'weather', render)
+          sleep 900
+        end
+      end
+    end
+  end
+end

data/lib/barabara/modules/wm.rb

@@ -0,0 +1,136 @@
+require 'pty'
+
+module Barabara
+  module Modules
+    class WM
+      include Wisper::Publisher
+
+      def initialize
+        @tag_icons = GlobalConfig.config.module_config('wm')['tag_icons'] || {}
+        @colors = GlobalConfig.config.colors
+        @monitors = GlobalConfig.config.monitors
+        @cmd, @wm = detect_wm(GlobalConfig.config.session)
+      end
+
+      def detect_wm(wmname)
+        case wmname
+        when 'herbstluftwm'
+          ['herbstclient --idle', 'hlwm']
+        when 'bspwm'
+          ['bspc subscribe report', 'bspwm']
+        else
+          raise NameError, 'Unknown WM!'
+        end
+      end
+
+      attr_reader :cmd, :wm
+
+      def parse_line(line)
+        case @wm
+        when 'hlwm'
+          command, *args = line.split("\t")
+          if command == 'tag_changed'
+            publish(:event, 'tagline', hlwm_tagline)
+          else
+            publish(:event, command, args)
+          end
+        when 'bspwm'
+          # We remove first char here, because it's insignificant in our case.
+          tags = line[1..-1].split(':')
+          publish(:event, 'tagline', parse_bspwm_tags(tags))
+        end
+      end
+
+      def watch
+        if @wm == 'hlwm'
+          publish(:event, 'tagline', hlwm_tagline)
+        else
+          parse_line(`bspc wm -g`.chomp)
+        end
+        PTY.spawn(@cmd) do |read, _write, pid|
+          read.each { |line| parse_line(line.chomp) }
+          Process.wait pid
+        end
+      end
+
+      def tag_color(status)
+        ## Tag statuses:
+        #  '#' -- Tag is active and focused on current monitor;
+        #  '+' -- Tag is active on current monitor,
+        #         but another monitor is focused;
+        #  ':' -- Tag is not active, but contains windows;
+        #  '!' -- Tag contains an urgent window.
+        case status
+        when /[#OF]/ then { bg: @colors[:ac_winbr], fg: @colors[:se_text] }
+        when /[+M]/ then { bg: '#9CA668', fg: @colors[:se_text] }
+        when /[:o]/ then { bg: @colors[:in_framebr], fg: @colors[:ac_text] }
+        when /[!uU]/ then { bg: @colors[:ur_winbr], fg: @colors[:se_text] }
+        when /[-%m]/ then { bg: @colors[:in_text], fg: @colors[:in_framebr] }
+        else { bg: @colors[:in_framebr], fg: @colors[:in_text] }
+        end
+      end
+
+      def hlwm_tagline
+        tagline = {}
+        @monitors.each do |monitor|
+          # Switch the font to glyphs:
+          tagline[monitor] = '%{T2}'
+          # Read the tag list:
+          tags = `herbstclient tag_status #{monitor}`.chomp.split("\t").drop(1)
+          tagline[monitor] << parse_hlwm_tags(tags, monitor) << '%{T1}'
+        end
+        tagline
+      end
+
+      def parse_hlwm_tags(tags, monitor)
+        line = ''
+        tags.each do |tag|
+          status, name = tag.slice!(0), tag
+          vars = { monitor: monitor, tag: name,
+                   icon: @tag_icons[name] }.merge(tag_color(status))
+          line << format('%%{B%<bg>s}%%{F%<fg>s}%%{A:herbstclient chain .-. '\
+                         'focus_monitor %<monitor>s .-. use %<tag>s:}'\
+                         ' %<icon>s %%{A}', vars)
+        end
+        line
+      end
+
+      def parse_bspwm_tags(tags)
+        tagline = {}
+        monitor = ''
+        tags.each do |tag|
+          next if tag[0] =~ /[LTG]/
+
+          status, name = tag.slice!(0), tag
+          if status.casecmp?('m')
+            monitor = name
+            tagline[monitor] = ''
+            next unless @monitors.count > 1
+
+            vars = { name: name }.merge(tag_color(status))
+            tagline[monitor] << format('%%{B%<bg>s}%%{F%<fg>s}'\
+                                       '%%{A:bspc monitor -f %<name>s:}'\
+                                       ' %<name>s %%{A}', vars)
+          else
+            vars = { name: name, icon: @tag_icons[name] || name }.merge(tag_color(status))
+            tagline[monitor] << format('%%{B%<bg>s}%%{F%<fg>s}'\
+                                       '%%{A:bspc desktop -f %<name>s:}'\
+                                       ' %<icon>s %%{A}', vars)
+          end
+        end
+        tagline
+      end
+
+      def self.get_monitors(wmname = ENV['XDG_SESSION_DESKTOP'])
+        case wmname
+        when 'herbstluftwm'
+          `herbstclient list_monitors`.scan(/^\d+/)
+        when 'bspwm'
+          `bspc query -M --names`.split("\n")
+        else
+          raise NameError, 'Unknown WM!'
+        end
+      end
+    end
+  end
+end

data/lib/barabara/modules/wname.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+module Barabara
+  module Modules
+    class WindowName
+      include Wisper::Publisher
+
+      def initialize
+        @cmd = 'xtitle -sf "%s\n"'
+      end
+
+      def self.limit(line)
+        line.length > 80 ? line[0..60].gsub(/\s\w+\s*$/, '…') : line
+      end
+
+      def watch
+        PTY.spawn(@cmd) do |stdout, _stdin, pid|
+          stdout.each do |line|
+            title = WindowName.limit(line.chomp)
+            publish(:event, 'window_title', title)
+          end
+          Process.wait pid
+        end
+      end
+    end
+  end
+end

data/lib/barabara/modules/wttr.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Barabara
+  module Modules
+    class Wttr
+      include Wisper::Publisher
+      require 'net/http'
+
+      def initialize
+        options = GlobalConfig.config.module_config('weather')
+        @colors = GlobalConfig.config.colors
+        @location = options['location'] || 'London'
+        @unit = (options['unit'] || 'c') == 'c' ? 'm' : 'u'
+        @format = options['format']
+        @uri = format_uri
+      end
+
+      def format_uri
+        uri = URI("https://wttr.in/#{@location}")
+        query = URI.encode_www_form(@unit => nil, 'format' => "%c\t%t")
+        uri.query = query
+        uri
+      end
+
+      def fetch
+        Net::HTTP.get_response(@uri)
+      rescue SocketError
+        '⌚'
+      end
+
+      def parse!
+        @icon, rawtemp = @raw_data.body.split("\t")
+        @temp = rawtemp.to_i
+      end
+
+      def render
+        @raw_data = fetch
+        return '⌚' unless @raw_data.is_a?(Net::HTTPSuccess)
+
+        parse!
+        sign = '+' if @temp.positive?
+        format(
+          @format,
+          { temp: "#{sign}#{@temp}", icon: @icon }.merge(@colors)
+        ).force_encoding('utf-8')
+      end
+
+      def watch
+        loop do
+          publish(:event, 'weather', render)
+          sleep 900
+        end
+      end
+    end
+  end
+end

data/lib/barabara/version.rb

@@ -0,0 +1,3 @@
+module Barabara
+  VERSION = '0.0.3'.freeze
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: barabara
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Serge Tkatchouk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: wisper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: optimist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email: 
+executables:
+- barabara
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- bin/barabara
+- lib/barabara.rb
+- lib/barabara/app.rb
+- lib/barabara/config.rb
+- lib/barabara/modules/battery.rb
+- lib/barabara/modules/clock.rb
+- lib/barabara/modules/event_processor.rb
+- lib/barabara/modules/lemonbar.rb
+- lib/barabara/modules/volume.rb
+- lib/barabara/modules/weather.rb
+- lib/barabara/modules/wm.rb
+- lib/barabara/modules/wname.rb
+- lib/barabara/modules/wttr.rb
+- lib/barabara/version.rb
+homepage: https://github.com/spijet/barabara
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- lemonbar
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Bar brains for standalone WMs
+test_files: []