termclock 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 035cd03641bd125a2b3da03fe051103d6ce9a8ee75917a6f5c7e6e97a568cfb8
+  data.tar.gz: 466cce8b4ef31fd357191aeada4ff8c5fda0584e21ef0dfc50ca1c2f3886d1ac
+SHA512:
+  metadata.gz: 9dac45de1be6e3d805a73c429948c7435b2f3b34b9080ff33616d3b1a51f000f35f5a423fa4cfb187119f1f97a8a6c69fc25fe7bc1c9a342506652cf0c43d62f
+  data.tar.gz: 3690251100766cd071af66baba728bfe07f6636c657b3f4ee7a529f656f30fafc2984805d252fb342251d5278cb852297d0bc93935aeb7008436121bc73732d3

data/exe/termclock

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require 'termclock'
+
+$-v = true
+
+begin
+	print "\e[?25l"
+
+	arg_col = ARGV.find { |x| x[/\A\-(\-colour|\-color|c|)=.*\z/] } &.split(?=) &.at(1) &.split(?,)
+
+	colours = if arg_col
+		abort("4 colours are needed. Example: -c=f55,55f,55f,3eb") if arg_col.length != 4
+		arg_col
+	else
+		%w(ff5555 5555ff 5555ff 33eebb)
+	end
+
+	colours.map! { |x|
+		begin
+			Termclock.hex2rgb(x)
+		rescue ArgumentError
+			abort $!.to_s
+		end
+	}
+
+	chars = ARGV.find { |x| x[/\A\-(\-character|char)=.*\z/] } &.split(?=) &.at(1)
+	Termclock::ParseCharacters.transform_characters!(chars[0]) if chars
+
+	Termclock.main(*colours)
+rescue Interrupt, SignalException
+	print "\e[H\e[2J\e[3J"
+ensure
+	print "\e[?25h"
+end

data/lib/termclock.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+COLOURTERM = ENV.key?('COLORTERM')
+CLEAR = COLOURTERM ? "\e[H\e[2J\e[3J" : "\e[H"
+$-n, $-s = ?\n, ?\s
+
+require 'linux_stat'
+require 'io/console'
+require_relative "termclock/string"
+require_relative "termclock/parse_characters"
+require_relative "termclock/main"
+require_relative "termclock/hex2rgb"
+require_relative "termclock/version"

data/lib/termclock/hex2rgb.rb

@@ -0,0 +1,30 @@
+module Termclock
+	def self.hex2rgb(hex)
+		colour = hex.dup.to_s
+		colour.strip!
+		colour.downcase!
+		colour[0] = ''.freeze if colour[0] == ?#.freeze
+
+		# out of range
+		oor = colour.scan(/[^a-f0-9]/)
+
+		unless oor.empty?
+			invalids = colour.chars.map { |x|
+				oor.include?(x) ? "\e[1;31m#{x}\e[0m" : x
+			}.join
+
+			puts "Hex Colour ##{invalids} is Out of Range"
+			raise ArgumentError
+		end
+
+		clen = colour.length
+		if clen == 3
+			colour.chars.map { |x| x.<<(x).to_i(16) }
+		elsif clen == 6
+			colour.chars.each_slice(2).map { |x| x.join.to_i(16) }
+		else
+			sli = clen > 6 ? 'too long'.freeze : clen < 3 ? 'too short'.freeze : 'invalid'.freeze
+			raise ArgumentError, "Invalid Hex Colour ##{colour} (length #{sli})"
+		end
+	end
+end

data/lib/termclock/main.rb

@@ -0,0 +1,166 @@
+module Termclock
+	def self.main(colour1, colour2, colour3, colour4, sleep = 0.1)
+		newline = ?\n.freeze
+		space = ?\s.freeze
+
+		generate = proc do |start, stop, n = 5|
+			r_op = r_val = nil
+			ary = []
+
+			if start > stop
+				r_op, r_val = :-, start.-(stop).fdiv(n - 1)
+			elsif start < stop
+				r_op, r_val = :+, stop.-(start).fdiv(n - 1)
+			end
+
+			_r = r_op ? start.send(r_op, r_val * -1) : start
+			n.times {
+				_r = _r.send(r_op, r_val) if r_op
+				ary << _r.clamp(0, 255).to_i
+			}
+
+			ary
+		end
+
+		gc_compact, gc_compacted = GC.respond_to?(:compact), Time.now.to_i + 7200
+		print "\e[H\e[2J\e[3J" unless COLOURTERM
+
+		r1, g1, b1 = *colour1
+		r2, g2, b2 = *colour2
+		r3, g3, b3 = *colour3
+		r4, g4, b4 = *colour4
+
+		# colour1 -> colour3
+		rs1 = generate.(r1, r3)
+		gs1 = generate.(g1, g3)
+		bs1 = generate.(b1, b3)
+
+		# colour2 -> colour4
+		rs2 = generate.(r2, r4)
+		gs2 = generate.(g2, g4)
+		bs2 = generate.(b2, b4)
+
+		# All Gradient Colours
+		colours = [rs1, gs1, bs1].transpose.zip([rs2, gs2, bs2].transpose)
+		colours.unshift(colours[0])
+		colours.push(colours[-1])
+		cpu_usage = 0
+		cpu_usage_t = Thread.new { }
+		message_time = Time.now.to_i - 5
+		message = ''
+		message_temp = ''
+		caret = "\u2588"
+
+		get_message = proc {
+			case Time.now.hour
+			when 6...12
+				"\u{1F304} Good Morning..."
+			when 12...16
+				"\u26C5 Good Afternoon..."
+			when 16...19
+				"\u{1F306} Good Evening..."
+			when 19...22
+				"\u{1F303} Good Night..."
+			else
+				"\u{1F30C} Good Night..."
+			end
+		}
+
+		i = -1
+
+		while true
+			i += 1
+			time_now = Time.now
+			height, width = *STDOUT.winsize
+
+			message_align = width - i % width + message.length / 2 - 4
+
+			if (width - i % width <= message.length)
+				message.replace(message[1..-1])
+				message_align = width - i % width + 4
+			else
+				message.clear if width - i % width == width
+				message_temp = get_message.call
+
+				if message_temp != message
+					message << message_temp[message.length..message.length  + 1]
+
+				end
+			end
+
+			if time_now.to_f./(0.5).to_i.even?
+				splitter = ?:.freeze
+				_caret = caret
+			else
+				splitter = ?$.freeze
+				_caret = ''
+			end
+
+			time = time_now.strftime("%H %M %S %2N").split.join(splitter)
+			art = Termclock::ParseCharacters.display(time)
+
+			art_aligned = art.lines.each_with_index do |x, i|
+				chomped = x.chomp(''.freeze).+(newline)
+				gr = chomped.gradient(*colours[i])
+				x.replace(space.*(width./(2.0).-(chomped.length / 2.0).abs.to_i + 1) + gr)
+			end.join
+
+			horizontal_gap = "\e[#{height./(2.0).-(art.lines.length / 2.0).to_i + 1}H"
+
+			unless cpu_usage_t.alive?
+				cpu_usage_t = Thread.new { cpu_usage = LS::CPU.usage(0.25) }
+			end
+
+			cpu = "\u{1F9E0} CPU: #{cpu_usage}% (#{LS::CPU.count_online} / #{LS::CPU.count})"
+
+			battery = if LS::Battery.present?
+				stat = LS::Battery.stat
+				emoji = LS::Battery.charging? ? "\u{1F4A1}" : "\u{1F50B}"
+				"#{emoji} Battery: #{stat[:charge].to_i}% (#{stat[:status]})"
+			else
+				''.freeze
+			end
+
+			_m = LS::Net.total_bytes
+			ip = "\u{1F30F} IP: #{LS::Net.ipv4_private}"
+			net_usage = "\u{1F4C8} D/L | U/L: #{LS::PrettifyBytes.convert_short_binary _m[:received]}"\
+			" | #{LS::PrettifyBytes.convert_short_binary _m[:transmitted]}"
+
+			_m = LS::Memory.stat
+			memory = "\u{1F3B0} Mem: #{LS::PrettifyBytes.convert_short_binary(_m[:used].to_i * 1024)}"\
+			" / #{LS::PrettifyBytes.convert_short_binary(_m[:total].to_i * 1024)}"\
+			" (#{_m[:percent_used]}%)"
+
+			_m = LS::Swap.stat
+			swap = "\u{1F300} Swap: #{LS::PrettifyBytes.convert_short_binary(_m[:used].to_i * 1024)}"\
+			" / #{LS::PrettifyBytes.convert_short_binary(_m[:total].to_i * 1024)}"\
+			" (#{_m[:percent_used]}%)"
+
+			_m = LS::Filesystem.stat
+			fs = "\u{1F4BD} FS: #{LS::PrettifyBytes.convert_short_binary(_m[:used].to_i)}"\
+			" / #{LS::PrettifyBytes.convert_short_binary(_m[:total].to_i)}"\
+			" (#{_m[:used].*(100).fdiv(_m[:total]).round(2)}%)"
+
+			process = "\u{1F9EE} Process: #{LS::Process.count}"
+
+			max_l = [process, ip, battery, net_usage].map(&:length).max
+
+			info = <<~EOF.gradient(*colours[2], exclude_spaces: true)
+				\s#{cpu}#{?\s.*(width.-(cpu.length + max_l + 4).abs)}#{battery}
+				\s#{memory}#{?\s.*(width.-(memory.length + max_l + 4).abs)}#{ip}
+				\s#{swap}#{?\s.*(width.-(swap.length + max_l + 4).abs)}#{net_usage}
+				\s#{fs}#{?\s.*(width.-(fs.length + max_l + 4).abs)}#{process}
+			EOF
+
+			print "#{CLEAR}#{info}#{horizontal_gap}#{art_aligned}\n"\
+			"#{message.rjust(message_align).+(_caret).gradient(*colours[1], exclude_spaces: true)}"
+
+			if gc_compact && time_now.to_i > gc_compacted
+				GC.compact
+				gc_compacted = time_now.to_i + 7200
+			end
+
+			sleep(sleep)
+		end
+	end
+end

data/lib/termclock/parse_characters.rb

@@ -0,0 +1,307 @@
+module Termclock
+	module ParseCharacters
+		NEWLINE = ?\n.freeze
+		CHARACTERS = <<~EOF.freeze
+		# 0
+		```````
+		``   ``
+		``   ``
+		``   ``
+		```````
+
+		# 1
+		   ``
+		 ````
+		   ``
+		   ``
+		```````
+
+		# 2
+		```````
+		     ``
+		```````
+		``
+		```````
+
+		# 3
+		```````
+		     ``
+		```````
+		     ``
+		```````
+
+		# 4
+		``   ``
+		``   ``
+		```````
+		     ``
+		     ``
+
+		# 5
+		```````
+		``
+		```````
+		     ``
+		```````
+
+		# 6
+		```````
+		``
+		```````
+		``   ``
+		```````
+
+		# 7
+		```````
+		     ``
+		     ``
+		     ``
+		     ``
+
+		# 8
+		```````
+		``   ``
+		```````
+		``   ``
+		```````
+
+		# 9
+		```````
+		``   ``
+		```````
+		     ``
+		```````
+
+		# :
+		⬩⬩
+		⬩⬩
+
+		⬩⬩
+		⬩⬩
+
+		# $
+		\s\s
+		\s\s
+
+		\s\s
+		\s\s
+		# A
+		```````
+		``   ``
+		```````
+		``   ``
+		``   ``
+
+		# B
+		``````
+		``   ``
+		``````
+		``   ``
+		``````
+
+		# C
+		```````
+		``
+		``
+		``
+		```````
+
+		# D
+		`````
+		``   ``
+		``    ``
+		``   ``
+		`````
+
+		# E
+		```````
+		``
+		```````
+		``
+		```````
+
+		# F
+		```````
+		``
+		```````
+		``
+		``
+
+		# G
+		```````
+		``
+		``
+		``   ```
+		````````
+
+		# H
+		``   ``
+		``   ``
+		```````
+		``   ``
+		``   ``
+
+		# I
+		```````
+		   `
+		   `
+		   `
+		```````
+
+		# J
+		```````
+		     ``
+		     ``
+		 ``  ``
+		 ``````
+
+		# K
+		``   ``
+		`` ``
+		````
+		`` ``
+		``   ``
+
+		# L
+		``
+		``
+		``
+		``
+		``````
+
+		# M
+		```  ```
+		`` `` ``
+		``    ``
+		``    ``
+		``    ``
+
+		# N
+		````    ``
+		``  `   ``
+		``   `  ``
+		``    ` ``
+		``     ```
+
+		# O
+		````````
+		``    ``
+		``    ``
+		``    ``
+		````````
+
+		# P
+		````````
+		``    ``
+		````````
+		``
+		``
+
+		# Q
+		```````
+		``   ``
+		```````
+		     ``
+		     ``
+
+		# R
+		```````
+		``   ``
+		```````
+		````
+		``  ``
+
+		# S
+		```````
+		``
+		```````
+		     ``
+		```````
+
+		# T
+		````````
+		   ``
+		   ``
+		   ``
+		   ``
+
+		# U
+		``   ``
+		``   ``
+		``   ``
+		``   ``
+		```````
+
+		# V
+		``   ``
+		``   ``
+		``   ``
+		 `` ``
+		   `
+
+		# W
+		``     ``
+		``     ``
+		``     ``
+		``  `  ``
+		`````````
+
+		# X
+		``      ``
+		  ``  ``
+		    ``
+		  ``  ``
+		``      ``
+
+		# Y
+		``    ``
+		``    ``
+		````````
+		   ``
+		   ``
+
+		# Z
+		````````
+		     ``
+		   ``
+		 ``
+		````````
+		EOF
+
+		class << self
+			@@characters ||= CHARACTERS.gsub(?`.freeze, ?\u2588).strip.split(/#+/).reduce({}) do |x, y|
+				y.lstrip!
+				lines = y[1..-1]
+				next x unless y && lines
+				max = lines.lines.max_by(&:length).length + 1
+
+				hash = {
+					y[0] => lines.lines.each { |z| z.replace(z.chomp.ljust(max) + NEWLINE) }.join
+				}
+
+				x.merge!(hash)
+			end.freeze
+
+			def transform_characters!(arg)
+				@@characters.values.each { |x|
+					stripped = x.strip[0]
+					x.gsub!(stripped, arg) if stripped
+				}
+			end
+
+			def display(c)
+				j = ['', '']
+
+				c.upcase.chars.map! { |x|
+					@@characters.fetch(x, x).split(?\n.freeze)
+					.each_with_index { |z, i|
+						_j = j[i]
+						_j && _j << z || j[i] = z
+					}
+				}
+
+				j.join(?\n.freeze)
+			end
+		end
+	end
+end

data/lib/termclock/string.rb

@@ -0,0 +1,87 @@
+class String
+	def gradient(*all_rgbs, bg: false, exclude_spaces: false)
+		temp = ''
+
+		r, g, b = all_rgbs[0]
+		r2, g2, b2 = all_rgbs[1]
+		rotate = all_rgbs.length > 2
+
+		init = bg ? 48 : 38
+
+		each_line do |c|
+			_r, _g, _b = r, g, b
+			chomped = !!c.chomp!(''.freeze)
+
+			len = c.length
+			n_variable = exclude_spaces ? c.delete("\t\s".freeze).length : len
+			n_variable -= 1
+			n_variable = 1 if n_variable < 1
+
+			# colour operator, colour value
+			r_op = r_val  = nil
+			g_op = g_val = nil
+			b_op = b_val = nil
+
+			if r2 > r
+				r_op, r_val = :+, r2.-(r).fdiv(n_variable)
+			elsif r2 < r
+				r_op, r_val = :-, r.-(r2).fdiv(n_variable)
+			end
+
+			if g2 > g
+				g_op, g_val = :+, g2.-(g).fdiv(n_variable)
+			elsif g2 < g
+				g_op, g_val = :-, g.-(g2).fdiv(n_variable)
+			end
+
+			if b2 > b
+				b_op, b_val = :+, b2.-(b).fdiv(n_variable)
+			elsif b2 < b
+				b_op, b_val = :-, b.-(b2).fdiv(n_variable)
+			end
+
+			# To avoid the value getting adding | subtracted from the initial character
+			_r = _r.send(r_op, r_val * -1) if r_op
+			_g = _g.send(g_op, g_val * -1) if g_op
+			_b = _b.send(b_op, b_val * -1) if b_op
+
+			i = -1
+			while (i += 1) < len
+				_c = c[i]
+
+				if !exclude_spaces || (exclude_spaces && !(_c == ?\s.freeze || _c == ?\t.freeze))
+					_r = _r.send(r_op, r_val) if r_op
+					_g = _g.send(g_op, g_val) if g_op
+					_b = _b.send(b_op, b_val) if b_op
+				end
+
+				r_to_i = _r.to_i
+				g_to_i = _g.to_i
+				b_to_i = _b.to_i
+
+				f_r = r_to_i < 0 ? 0 : r_to_i > 255 ? 255 : r_to_i
+				f_g = g_to_i < 0 ? 0 : g_to_i > 255 ? 255 : g_to_i
+				f_b = b_to_i < 0 ? 0 : b_to_i > 255 ? 255 : b_to_i
+
+				ret = "\e[#{init};2;#{f_r};#{f_g};#{f_b}m#{_c}"
+				temp << ret
+			end
+
+			ret = if !c.empty?
+				chomped ? "\e[0m\n".freeze : "\e[0m".freeze
+			elsif chomped
+				?\n.freeze
+			end
+
+			temp << ret
+
+			if rotate
+				all_rgbs.rotate!
+				r, g, b = all_rgbs[0]
+				r2, g2, b2 = all_rgbs[1]
+			end
+		end
+
+		temp
+	end
+end

data/lib/termclock/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Termclock
+	VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: termclock
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sourav Goswami
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-01-12 00:00:00.000000000 Z
+dependencies: []
+description: A clock for Linux VTE
+email:
+- souravgoswami@protonmail.com
+executables:
+- termclock
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/termclock
+- lib/termclock.rb
+- lib/termclock/hex2rgb.rb
+- lib/termclock/main.rb
+- lib/termclock/parse_characters.rb
+- lib/termclock/string.rb
+- lib/termclock/version.rb
+homepage: https://github.com/souravgoswami/termclock
+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.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: A clock for Linux VTE
+test_files: []