cejo 0.0.5

data/lib/cejo/media/play.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Cejo
+  # Provide system media interaction.
+  module Media
+    # Play file, random media in folder or with url.
+    class Play
+      PLAYER = 'mpv'.freeze
+      PLAYER_CONFIG = '--no-config --no-audio-display'.freeze
+      PLAYER_FORMAT = '--ytdl-format="bestvideo[height<=?1080]+bestaudio/best"'.freeze
+
+      attr_reader :media
+
+      def initialize(media)
+        @media = media
+      end
+
+      def pick_random_media_in_folder(folder)
+        file = folder.children.sample
+        folder.join(file).to_path
+      end
+
+      def pick_media
+        filepath = Pathname.new(media)
+        return filepath.to_path if filepath.file?
+        return pick_random_media_in_folder(filepath) if filepath.directory?
+        return media
+      end
+
+      public
+
+      def player_settings
+        "#{PLAYER} #{PLAYER_CONFIG} #{PLAYER_FORMAT}"
+      end
+
+      def final_command
+        "#{player_settings} #{pick_media}"
+      end
+
+      def run
+        system final_command
+      end
+    end
+  end
+end

data/lib/cejo/ops/brightness.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Cejo
+  module Ops
+    # Manage System brightness.
+    class Brightness
+      STEP = 5
+      BRIGHTER = 'brightnessctl'
+
+      attr_reader :state, :step
+
+      def initialize(state)
+        @state = state
+      end
+
+      def states
+        {
+          up: "set #{STEP}%+",
+          down: "set #{STEP}%-",
+        }
+      end
+
+      def action
+        states[state.to_sym]
+      end
+
+      def final_command
+        "#{BRIGHTER} #{action}"
+      end
+
+      def run
+        @state = state.to_sym if %w[up down].include? state
+        system(action)
+      end
+    end
+  end
+end

data/lib/cejo/ops/dots.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'find'
+
+module Cejo
+  module Ops
+    # Mirror Lar files in $HOME.
+    class Dots
+      attr_reader :root, :ignore_these, :utils, :home, :target_link
+
+      def initialize(utils, root)
+        @utils = utils
+        @root = Pathname.new root if root
+        @home = Pathname.new(Dir.home)
+        @target_link = {}
+      end
+
+      def root_files_folders
+        files = []
+        folders = []
+
+        Find.find(root) do |file|
+          file = Pathname.new file
+          next if file.to_path.include? '.git'
+          next if file == root
+
+          files << file if file.file?
+          folders << file if file.directory?
+        end
+
+        { folders: folders, files: files }
+      end
+
+      # transform origin file absolute path with home as its root instead
+      # /a/b/c.tar --> /home/b/c.tar
+      def to_home(this)
+        origin = this.to_path
+        homey = home.to_path.concat('/')
+        result = origin.gsub(root.to_path, homey)
+        Pathname.new(result)
+      end
+
+      # Create only the folders, if those do not exist
+      def make_folders
+        root_files_folders[:folders].each do |fld|
+          folder = to_home fld
+          next if folder.exist?
+
+          puts folder
+          folder.mkdir
+        end
+      end
+
+      def feed_target_link
+        root_files_folders[:files].each do |target|
+          next if ignored_ones.include? target.basename.to_s
+
+          symlink_name = to_home target
+          target_link.store(target, symlink_name)
+        end
+      end
+
+      # Move file from home to a /home/backup/{file}
+      # or delete it if the file it is pointing does not exist
+      def backup_this(this)
+        warn "WARNING: #{this} found! Deleting/Moving it."
+        this.delete if this.exist? # TODO: if file exist back/delete up it
+      end
+
+      def backup_files
+        target_link.each do |target, link_name|
+          puts "#{target} ❯ #{link_name}"
+          backup_this link_name
+        end
+      end
+
+      def symlink_files
+        target_link.each do |target, link_name|
+          puts "#{target} ❯ #{link_name}"
+          link_name.make_symlink target # As enumerator yielding folder to symlink
+        end
+      end
+
+      # ignore these ones
+      def ignored_ones
+        ['LICENSE', root.join('.git').to_path.to_s].freeze
+      end
+
+      def run
+        feed_target_link
+        make_folders
+        backup_files
+        symlink_files
+      end
+    end
+  end
+end

data/lib/cejo/ops/homey.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Cejo
+  module Ops
+    # Mirror user DATA partition folders to $HOME
+    class Homey
+      IGNORE_THESE = %w[.Trash-1000 lost+found].freeze
+
+      attr_reader :root, :target_link
+
+      def initialize(root)
+        @root = root
+      end
+
+      # Confirms if root is a folder or return w/ exeception
+      def root_exist?
+        r = Pathname.new root
+        r.exist?
+      end
+
+      def folders_found
+        folders_found = {}
+        home = Pathname.new(Dir.home)
+
+        root.each_child do |folder|
+          next if IGNORE_THESE.include? folder.basename.to_s
+
+          folders_found[folder] = home.join(folder.basename)
+        end
+
+        folders_found
+      end
+
+      # Remove $HOME folders found in DATA
+      def cleanup_home
+        target_link.each_key do |link_name|
+          link_name.delete if link_name.exist?
+        end
+      end
+
+      def symlink_folders
+        target_link.each do |target, link_name|
+          File.symlink(target, link_name)
+        end
+      end
+
+      # def show_info
+      #   print "root folder".blue, ": ", root, "\n\n"
+
+      #   cleanup_home do |link_name|
+      #     print "Warning".red, ": ", "#{link_name}".green, " folder found, removing it!", "\n"
+      #   end
+
+      #   puts
+
+      #   symlink_folders do |target, link_name|
+      #     print "#{target}".yellow, " --> ", "#{link_name}".green, "\n"
+      #   end
+      # end
+
+      def run
+        unless root_exist?
+          print "No such a directory '#{root}' exist! Exiting."
+          exit!
+        end
+        @root = Pathname root
+        @target_link = folders_found
+        # show_info
+        cleanup_home
+        symlink_folders
+      end
+
+      public :run
+    end
+  end
+end

data/lib/cejo/ops/screenshot.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Cejo
+  module Ops
+    # Take a shot of the marvelous screen
+    class Screenshot
+      def self.folder
+        Pathname.new(Dir.home).join('Pictures') # TODO: Check if folder exist
+      end
+
+      def self.current_time
+        Time.new.strftime('%d-%m-%y-%k-%M')
+      end
+
+      attr_reader :utils, :mode
+
+      def initialize(utils, mode)
+        @utils = utils
+        @mode = mode.to_sym if mode
+      end
+
+      def shotters
+        [flameshot, scrot, maim]
+      end
+
+      def shotters_available
+        shotters.find { |shotter| utils.which?(shotter[:exec]) }
+      end
+
+      def shotter
+        shotters_available.first
+      end
+
+      def scrot
+        {
+          exec: 'scrot',
+          full: '--focused --silent',
+          partial: '--select --silent',
+          folder: folder.join(screenshot_name),
+        }
+      end
+
+      def flameshot
+        {
+          exec: 'flameshot',
+          full: 'full -p',
+          partial: 'gui -p',
+          folder: folder.to_path,
+        }
+      end
+
+      def maim
+        {
+          exec: 'maim',
+          full: '',
+          partial: '--select',
+          folder: folder.join(screenshot_name),
+        }
+      end
+
+      def screenshot_format
+        'png'
+      end
+
+      def screenshot_name
+        "screenshot-#{current_time}.#{screenshot_format}"
+      end
+
+      def final_command
+        "#{shotter[:exec]} #{shotter[mode]} #{shotter[:folder]}"
+      end
+
+      def run
+        system(final_command)
+      end
+    end
+  end
+end

data/lib/cejo/ops/sysinfo.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Cejo
+  module Ops
+    # Display System Hardware Information.
+    class Sysinfo
+      attr_reader :services, :command
+
+      DEPS = %w[pulseaudio amixer ping sensors ryzen vega].freeze
+
+      def initialize(services, command)
+        @services = services
+        @command = command
+      end
+
+      public
+
+      def run_args
+        DEPS
+      end
+
+      def run
+        puts(run_args)
+      end
+    end
+  end
+end

data/lib/cejo/ops/volume/sound_manager.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Cejo
+  module Ops
+    # Sound manager information
+    class SoundManager
+      attr_reader :utils
+
+      def initialize(utils)
+        @utils = utils
+      end
+
+      # Find the running Pactl sink
+      def pactl_sink
+        `pactl list sinks`.split('Sink #').each do |sink|
+          sink_id = sink[0]
+          return sink_id if sink.include? 'State: RUNNING'
+        end
+      end
+
+      def sink
+        {
+          pactl: pactl_sink
+        }
+      end
+
+      def sound_managers
+        %w[pactl amixer mixer]
+      end
+
+      def sound_manager
+        sound_managers.first { |manager| utils.which?(manager) }.to_sym
+      end
+
+      ALL = Struct.new(:name, :sink)
+      def info
+        ALL.new(sound_manager, sink[sound_manager])
+      end
+
+      def to_s
+        "#{sound_manager} #{sink}"
+      end
+    end
+  end
+end

data/lib/cejo/ops/volume/volume.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Cejo
+  module Ops
+    # Manage System Volume.
+    class Volume
+      STEP = 3
+
+      attr_reader :state, :utils
+      attr_accessor :info
+
+      def initialize(utils, state)
+        @utils = utils
+        @state = state.to_sym if state
+        @info = SoundManager.new(utils).info
+      end
+
+      def states
+        {
+          up: '+',
+          down: '-',
+          toggle: ''
+        }
+      end
+
+      # * PACTL
+
+      def pactl_toggle
+        [pactl[:name], pactl[:toggle]].join(' ')
+      end
+
+      def pactl_updown
+        [pactl[:name], pactl[:updown]].join(' ')
+      end
+
+      def pactl
+        {
+          name: 'pactl',
+          toggle: "set-sink-mute #{info.sink} toggle",
+          updown: "set-sink-volume #{info.sink} #{states[state]}#{STEP}%"
+        }
+      end
+
+      # * AMIXER
+
+      def amixer_toggle
+        [amixer[:name], amixer[:toggle]].join(' ')
+      end
+
+      def amixer_updown
+        [amixer[:name], amixer[:updown]].join(' ')
+      end
+
+      def amixer
+        {
+          name: 'amixer',
+          toggle: '-q sset Master toggle',
+          updown: "set Master #{STEP}%#{states[state]}"
+        }
+      end
+
+      # * BSD MIXER
+
+      def mixer_toggle
+        [mixer[:name], mixer[:toggle]].join(' ')
+      end
+
+      def mixer_updown
+        [mixer[:name], mixer[:updown]].join(' ')
+      end
+
+      def mixer
+        {
+          name: 'mixer',
+          toggle: '',
+          updown: "mixer vol #{states[state]}#{STEP}"
+        }
+      end
+
+      # * MODES
+
+      def toggle
+        {
+          pactl: pactl_toggle,
+          amixer: amixer_toggle,
+          mixer: mixer_toggle
+        }
+      end
+
+      def updown
+        {
+          pactl: pactl_updown,
+          amixer: amixer_updown,
+          mixer: mixer_updown
+        }
+      end
+
+      def mode
+        {
+          toggle: toggle[info.name],
+          up: updown[info.name],
+          down: updown[info.name]
+        }
+      end
+
+      def final_command
+        mode[state]
+      end
+
+      def run
+        return unless %i[up down toggle].include?(state)
+
+        system(final_command)
+      end
+    end
+  end
+end