string_dot_gradient 0.1.0 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8dd54d9133693ce1125e621ea28e03b0fcc0e8229885be3a6853777470c89416
-  data.tar.gz: 3d4e18250a1b7bfd787f0e5778ade008ac5ff95d94ea38e48cb9632d38a90037
+  metadata.gz: 107ebffe10579b889cfe5b6bd0ebbc774375674fd7e9db1998f3fc4561d86b12
+  data.tar.gz: 26588857b88ff2f8a732a840a3807d7d327448b55cc02eb385294e21c718d71b
 SHA512:
-  metadata.gz: 20c9b1a12caf24baa79eb704652c67836bca3497494696bb00d746baf1f3900c5cef33abc4d2e381315ac731541053dda1c871e96d049190fecddbd9a5896b99
-  data.tar.gz: 96b9d15b159911df728f641f35bf41b64744701fc8226ffa5e3f3ba7950a06998d6ce7ff875a247a4808418ec53d9c6104abf367a7167bdf4f64231acf9b3964
+  metadata.gz: 5c40057440f5a6d8c3d1855c3defa40e878a1aeadaefb3e7fda49fd95521135d0c3c418b10dfe3ffabb8b743e25bce3962cafebfb1b4725392619287c67f1938
+  data.tar.gz: 668f2212665a28aeabcc58cfd823d5a0995617f785a93d10ab6c301a714328dc057f9d3dade654a3021296a596de8fadec3dd30104681aaa3215426d89cf0493

data/lib/string_dot_gradient/gradient.rb

@@ -1,58 +1,170 @@
 class String
-	def gradient(colour_start, colour_stop, bg: false, rotate: false)
+	##
+	# = gradient(*arg_colours, bg: false, exclude_spaces: true)    # => string or nil
+	#
+	# Prettifies your string by adding gradient colours.
+	#
+	# This method accept a lot of colours. For example:
+	#
+	# 1. puts "Hello".gradient('#f55', '#55f')
+	# This will add #f55 (red) to #55f (blue) gradient colours to your texts.
+	#
+	# 2. puts "Hello\nWorld".gradient('#f55', '#55f')
+	# This will add #f55 (red) to #55f (blue) gradient colours to your texts, spanning multiple lines.
+	#
+	# 3. puts "Hello\nWorld!\nColours\nare\nrotated here".gradient('f55','55f', '3eb' 'ff5')
+	# This will add #ff5555 (red) to #5555ff (blue) gradient colours to the first line,
+	# 5555ff to 33eebb colour to the 2nd line,
+	# 33eebb to ffff55 to the third line
+	# And then back to ffff55 to ff5555 to the fourth line,
+	# And it will continue to rotate between these colours.
+	#
+	# To stop rotating, just don't give more than two arguments to this method.
+	#
+	# Passing blocks is also optional, and is handy for animating text. For example:
+	#    "Hello\nWorld!\nColours\nare\nrotated here".gradient('f55','55f', '3eb' 'ff5', bg:true) { |x| print x ; sleep 0.05 }
+	#
+	# This will pass the values to the block itself, and will draw the colourful text slowly.
+	# Passing block will return nil from the method because the values will be passed to the block variable instead.
+	#
+	# Adding the option bg will change the background colour, but will keep the foreground colour
+	# defined in the terminal settings.
+	#
+	# The option exclude_spaces, is expected to set either true or false.
+	# By default it's set to true.
+	# Enabling this option will not waste colours on white-spaces.
+	# White spaces only include: \s, \t
+	#
+	# Please do note that \u0000 and \r in the middle of the string will not be
+	# counted as a white space, but as a character instead.
+	# This is because \r wipes out the previous characters, and using \u0000 in
+	# a string is uncommon, and developers are requested to delete
+	# \u0000 from string if such situations arise.
+	def gradient(*arg_colours, bg: false, exclude_spaces: true)
 		colours, line_length = [], -1
 		temp = ''
+		flatten_colours = arg_colours.flatten
+
+		raise ArgumentError, "Wrong numeber of colours (given #{flatten_colours.length}, expected minimum 2)" if flatten_colours.length < 2
+		raise ArgumentError, "Given argument for colour is neither a String nor an Integer" if flatten_colours.any? { |x| !(x.is_a?(String) || x.is_a?(Integer)) }
+
+		all_rgbs = flatten_colours.map!(&method(:hex_to_rgb))
+		block_given = block_given?
+
+		r, g, b = all_rgbs[0]
+		r2, g2, b2 = all_rgbs[1]
+		rotate = all_rgbs.length > 2
 
-		r, g, b = hex_to_rgb(colour_start)
-		r2, g2, b2 = hex_to_rgb(colour_stop)
 		init = bg ? 48 : 38
 
 		each_line do |c|
 			_r, _g, _b = r, g, b
 			n = c.length
+			n_variable = exclude_spaces ? c.dup.delete("\t\s".freeze).length : n
+
+			r_op = r_val = r_max = r_min = nil
+			g_op = g_val = g_max = g_min = nil
+			b_op = b_val = b_max = b_min = nil
+
+			r_comp_op = r_comp_val = nil
+			g_comp_op = g_comp_val = nil
+			b_comp_op = b_comp_val = nil
+
+			if r2 > r
+				r_op, r_val, r_max, r_min = :+, r2.fdiv(n_variable), r2, r
+				r_comp_op, r_comp_val = :<=, r_max
+			elsif r2 < r
+				r_op, r_val, r_max, r_min = :-, r.fdiv(n_variable), r, r2
+				r_comp_op, r_comp_val = :>=, r_min
+			end
+
+			if g2 > g
+				g_op, g_val, g_max, g_min = :+, g2.fdiv(n_variable), g2, g
+				g_comp_op, g_comp_val = :<=, g_max
+			elsif g2 < g
+				g_op, g_val, g_max, g_min = :-, g.fdiv(n_variable), g, g2
+				g_comp_op, g_comp_val = :>=, g_min
+			end
 
-			r_meth = r == r2 ? :itself : r2 > r ? [:+, r2.fdiv(n)] : [:-, r.fdiv(n)]
-			g_meth = g == g2 ? :itself : g2 > g ? [:+, g2.fdiv(n)] : [:-, g.fdiv(n)]
-			b_meth = b == b2 ? :itself : b2 > b ? [:+, b2.fdiv(n)] : [:-, b.fdiv(n)]
+			if b2 > b
+				b_op, b_val, b_max, b_min = :+, b2.fdiv(n_variable), b2, b
+				b_comp_op, b_comp_val = :<=, b_max
+			elsif b2 < b
+				b_op, b_val, b_max, b_min = :-, b.fdiv(n_variable), b, b2
+				b_comp_op, b_comp_val = :>=, b_min
+			end
 
-			if line_length != n
+			if line_length != n || rotate
 				line_length = n
 				colours.clear
 
 				i = -1
 				while (i += 1) < n
-					_r = _r.send(*r_meth)
-					_g = _g.send(*g_meth)
-					_b = _b.send(*b_meth)
+					if exclude_spaces
+						_c = c[i]
+
+						if !(_c == ?\s.freeze || _c == ?\t.freeze)
+							_r = _r.send(r_op, r_val) if r_comp_op && _r.send(r_comp_op, r_comp_val)
+							_g = _g.send(g_op, g_val) if g_comp_op && _g.send(g_comp_op, g_comp_val)
+							_b = _b.send(b_op, b_val) if b_comp_op && _b.send(b_comp_op, b_comp_val)
+						end
+					else
+						# We also have duplication above,
+						# But we are not going to remove this code unless
+						# we find some efficient solution. Using a proc or method
+						# for setting these values and calling that is a way
+						# to make code slower.
+						_r = _r.send(r_op, r_val) if r_comp_op && _r.send(r_comp_op, r_comp_val)
+						_g = _g.send(g_op, g_val) if g_comp_op && _g.send(g_comp_op, g_comp_val)
+						_b = _b.send(b_op, b_val) if b_comp_op && _b.send(b_comp_op, b_comp_val)
+					end
+
+					r_to_i = _r.to_i
+					g_to_i = _g.to_i
+					b_to_i = _b.to_i
 
 					colours << [
-						(_r < 0 ? 0 : _r > 255 ? 255 : _r.to_i),
-						(_g < 0 ? 0 : _g > 255 ? 255 : _g.to_i),
-						_b < 0 ? 0 : _b > 255 ? 255 : _b.to_i
+						r_to_i < 0 ? 0 : r_to_i > 255 ? 255 : r_to_i,
+						g_to_i < 0 ? 0 : g_to_i > 255 ? 255 : g_to_i,
+						b_to_i < 0 ? 0 : b_to_i > 255 ? 255 : b_to_i,
 					]
 				end
 			end
 
 			i = -1
 			while (i += 1) < n
-				temp.concat(
-					"\e[#{init};2;#{colours[i][0]};#{colours[i][1]};#{colours[i][2]}m#{c[i]}"
-				)
+				if block_given
+					yield "\e[#{init};2;#{colours[i][0]};#{colours[i][1]};#{colours[i][2]}m#{c[i]}"
+				else
+					temp.concat(
+						"\e[#{init};2;#{colours[i][0]};#{colours[i][1]};#{colours[i][2]}m#{c[i]}"
+					)
+				end
+			end
+
+			if block_given
+				yield "\e[0m".freeze
+			else
+				temp << "\e[0m".freeze
 			end
-			colours.rotate! if rotate
 
-			temp << "\e[0m".freeze
+			if rotate
+				all_rgbs.rotate!
+				r, g, b = all_rgbs[0]
+				r2, g2, b2 = all_rgbs[1]
+			end
 		end
 
-		temp
+		block_given ? nil : temp
 	end
 
 	private
 	def hex_to_rgb(hex)
-		colour = hex.dup.to_s
+		# Duplicate colour, even if colour is nil
+		colour = hex && hex.dup.to_s || ''
 		colour.strip!
 		colour.downcase!
-		colour[0] = ''.freeze if colour.start_with?(?#.freeze)
+		colour[0] = ''.freeze if colour[0] == ?#.freeze
 
 		# out of range
 		oor = colour.scan(/[^a-f0-9]/)
@@ -66,12 +178,14 @@ class String
 			raise ArgumentError
 		end
 
-		if colour.length == 3
+		clen = colour.length
+		if clen == 3
 			colour.chars.map { |x| x.<<(x).to_i(16) }
-		elsif colour.length == 6
+		elsif clen == 6
 			colour.chars.each_slice(2).map { |x| x.join.to_i(16) }
 		else
-			raise ArgumentError, "Invalid Hex Colour ##{colour}"
+			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/string_dot_gradient/version.rb

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

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: string_dot_gradient
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.5
 platform: ruby
 authors:
 - Sourav Goswami
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-07 00:00:00.000000000 Z
+date: 2021-01-09 00:00:00.000000000 Z
 dependencies: []
-description: An itty-bitty extension that adds gradient method to String class, for
-  Linux terminals
+description: An itty-bitty extension that adds gradient method to String class that
+  supports any hex colour, for Linux | Unix terminals only
 email:
 - souravgoswami@protonmail.com
 executables: []
@@ -33,7 +33,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -43,6 +43,6 @@ requirements: []
 rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
-summary: An itty-bitty extension that adds gradient method to String class, for Linux
-  terminals
+summary: An itty-bitty extension that adds gradient method to String class that supports
+  any hex colour, for Linux | Unix terminals only
 test_files: []