kanrisuru 0.1.0 → 0.2.1

data/lib/kanrisuru/core/file.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Kanrisuru
+  module Core
+    module File
+      extend OsPackage::Define
+
+      os_define :linux, :touch
+      os_define :linux, :cp
+      os_define :linux, :copy
+      os_define :linux, :mkdir
+      os_define :linux, :mv
+      os_define :linux, :move
+
+      os_define :linux, :link
+      os_define :linux, :symlink
+      os_define :linux, :ln
+      os_define :linux, :ln_s
+
+      os_define :linux, :chmod
+      os_define :linux, :chown
+
+      os_define :linux, :unlink
+      os_define :linux, :rm
+      os_define :linux, :rmdir
+
+      os_define :linux, :wc
+
+      FileCount = Struct.new(:lines, :words, :characters)
+
+      def cp(source, dest, opts = {})
+        backup = opts[:backup]
+        command = Kanrisuru::Command.new('cp')
+
+        command.append_flag('-R', opts[:recursive])
+        command.append_flag('-x', opts[:one_file_system])
+        command.append_flag('-u', opts[:update])
+        command.append_flag('-L', opts[:follow])
+        command.append_flag('-n', opts[:no_clobber])
+        command.append_flag('--strip-trailing-slashes', opts[:strip_trailing_slashes])
+
+        if backup.instance_of?(TrueClass)
+          command.append_flag('-b')
+        elsif Kanrisuru::Util.present?(backup)
+          raise ArgumentError, 'invalid backup control value' unless backup_control_valid?(backup)
+
+          command << "--backup=#{backup}"
+        end
+
+        if opts[:preserve].instance_of?(TrueClass)
+          command.append_flag('-p')
+        elsif Kanrisuru::Util.present?(opts[:preserve])
+          preserve =
+            (opts[:preserve].join(',') if opts[:preserve].instance_of?(Array))
+
+          command << "--preserve=#{preserve}"
+        end
+
+        if opts[:no_target_directory]
+          command.append_flag('-T')
+          command << source
+          command << dest
+        elsif opts[:target_directory]
+          command.append_arg('-t', dest)
+
+          source = source.instance_of?(String) ? [source] : source
+          command << source.join(' ')
+        else
+          source = source.instance_of?(String) ? [source] : source
+          command << source.join(' ')
+          command << dest
+        end
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command)
+      end
+
+      def copy(source, dest, opts = {})
+        cp(source, dest, opts)
+      end
+
+      def mv(source, dest, opts = {})
+        backup = opts[:backup]
+        command = Kanrisuru::Command.new('mv')
+
+        command.append_flag('--strip-trailing-slashes', opts[:strip_trailing_slashes])
+
+        if opts[:force]
+          command.append_flag('-f')
+        elsif opts[:no_clobber]
+          command.append_flag('-n')
+        end
+
+        if backup.instance_of?(TrueClass)
+          command.append_flag('-b')
+        elsif Kanrisuru::Util.present?(backup)
+          raise ArgumentError, 'invalid backup control value' unless backup_control_valid?(backup)
+
+          command << "--backup=#{backup}"
+        end
+
+        if opts[:no_target_directory]
+          command.append_flag('-T')
+          command << source
+          command << dest
+        elsif opts[:target_directory]
+          command.append_arg('-t', dest)
+
+          source = source.instance_of?(String) ? [source] : source
+          command << source.join(' ')
+        else
+          source = source.instance_of?(String) ? [source] : source
+
+          command << source.join(' ')
+          command << dest
+        end
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command)
+      end
+
+      def move(source, dest, opts = {})
+        mv(source, dest, opts)
+      end
+
+      def link(src, dest, opts = {})
+        ln(src, dest, opts)
+      end
+
+      def symlink(src, dest, opts = {})
+        ln_s(src, dest, opts)
+      end
+
+      def ln(src, dest, opts = {})
+        ## Can't hardlink dirs
+        return false if dir?(src)
+
+        command = Kanrisuru::Command.new("ln #{src} #{dest}")
+        command.append_flag('-f', opts[:force])
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do
+          stat(dest).data
+        end
+      end
+
+      def ln_s(src, dest, opts = {})
+        return if src == dest
+
+        ## Use absolute path for source
+        real_src = realpath(src).path
+
+        ## Not valid if no real path, not an existing inode, or root
+        raise ArgumentError, 'Invalid path' if Kanrisuru::Util.blank?(real_src) || !inode?(real_src) || real_src == '/'
+
+        dest_is_dir = dir?(dest)
+
+        ## Don't symlink inside an already existing symlink
+        return if symlink?(dest) && dest_is_dir
+
+        real_dest =
+          if dest_is_dir
+            ## Use real path for destination
+            realpath(dest).path
+          else
+            ## Use standard path
+            dest
+          end
+
+        return unless real_dest
+
+        command = Kanrisuru::Command.new("ln -s #{real_src} #{real_dest}")
+        command.append_flag('-f', opts[:force])
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do
+          stat(real_dest).data
+        end
+      end
+
+      def unlink(path)
+        command = Kanrisuru::Command.new("unlink #{path}")
+        execute_shell(command)
+        Kanrisuru::Result.new(command)
+      end
+
+      def rm(paths, opts = {})
+        paths = [paths] if paths.instance_of?(String)
+
+        paths.each do |path|
+          raise ArgumentError, "Can't delete root path" if path == '/' || realpath(path).path == '/'
+        end
+
+        command = Kanrisuru::Command.new("rm #{paths.join(' ')} --preserve-root")
+        command.append_flag('-f', opts[:force])
+        command.append_flag('-r', opts[:recursive])
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command)
+      end
+
+      def rmdir(path)
+        return false unless dir?(path)
+
+        rm(path, force: true, recursive: true)
+      end
+
+      def mkdir(path, opts = {})
+        owner     = opts[:owner]
+        group     = opts[:group]
+        recursive = opts[:recursive]
+
+        command = Kanrisuru::Command.new("mkdir #{path}")
+        command.append_flag('-p', opts[:silent])
+        command.append_arg('-m', opts[:mode])
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do
+          if Kanrisuru::Util.present?(owner) || Kanrisuru::Util.present?(group)
+            chown(path, owner: owner, group: group, recursive: recursive)
+          end
+
+          stat(path).data
+        end
+      end
+
+      def touch(paths, opts = {})
+        date    = opts[:date]
+
+        paths = [paths] if paths.instance_of?(String)
+        command = Kanrisuru::Command.new("touch #{paths.join(' ')}")
+
+        command.append_flag('-a', opts[:atime])
+        command.append_flag('-m', opts[:mtime])
+        command.append_flag('-c', opts[:nofiles])
+
+        if Kanrisuru::Util.present?(date)
+          date = Date.parse(date) if date.instance_of?(String)
+          command.append_arg('-d', date)
+        end
+
+        command.append_arg('-r', opts[:reference])
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do
+          paths.map do |path|
+            stat(path).data
+          end
+        end
+      end
+
+      def chmod(path, mode, opts = {})
+        recursive = opts[:recursive]
+
+        command =
+          if mode.instance_of?(String) && (mode.include?(',') || /[=+-]/.match(mode))
+            Kanrisuru::Command.new("chmod #{mode} #{path}")
+          elsif mode.instance_of?(Kanrisuru::Mode)
+            Kanrisuru::Command.new("chmod #{mode.numeric} #{path}")
+          else
+            mode = Kanrisuru::Mode.new(mode)
+            Kanrisuru::Command.new("chmod #{mode.numeric} #{path}")
+          end
+
+        command.append_flag('-R', recursive)
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do
+          stat(path).data
+        end
+      end
+
+      def chown(path, opts = {})
+        owner     = opts[:owner]
+        group     = opts[:group]
+
+        uid = get_uid(owner).to_i if Kanrisuru::Util.present?(owner)
+        gid = get_gid(group).to_i if Kanrisuru::Util.present?(group)
+
+        ## Don't chown a blank owner and group.
+        return false if Kanrisuru::Util.blank?(uid) && Kanrisuru::Util.blank?(gid)
+
+        command = Kanrisuru::Command.new('chown')
+
+        arg = ''
+        arg = uid.to_s if Kanrisuru::Util.present?(uid)
+        arg += ":#{gid}" if Kanrisuru::Util.present?(gid)
+
+        command.append_value(arg)
+        command.append_flag('-R', opts[:recursive])
+
+        command << path
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do
+          stat(path).data
+        end
+      end
+
+      def wc(file)
+        command = Kanrisuru::Command.new("wc #{file}")
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          items = cmd.to_a
+          FileCount.new(items[0].to_i, items[1].to_i, items[2].to_i)
+        end
+      end
+
+      private
+
+      def backup_control_valid?(backup)
+        opts = %w[
+          none off numbered t existing nil simple never
+        ]
+
+        opts.include?(backup)
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/find.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Kanrisuru
+  module Core
+    module Find
+      extend OsPackage::Define
+
+      os_define :linux, :find
+
+      FilePath = Struct.new(:path)
+
+      def find(opts = {})
+        paths      = opts[:paths]
+        type       = opts[:type]
+        regex      = opts[:regex]
+        size       = opts[:size]
+
+        command = Kanrisuru::Command.new('find')
+
+        case opts[:follow]
+        when 'never'
+          command.append_flag('-P')
+        when 'always'
+          command.append_flag('-L')
+        when 'command'
+          command.append_flag('-H')
+        end
+
+        if Kanrisuru::Util.present?(paths)
+          if paths.instance_of?(Array)
+            paths = paths.join(' ')
+          elsif paths.class != String
+            raise 'Invalid paths type'
+          end
+
+          command << paths
+        end
+
+        command.append_flag('-executable', opts[:executable])
+        command.append_flag('-empty', opts[:empty])
+        command.append_flag('-readable', opts[:readable])
+        command.append_flag('-writable', opts[:writable])
+        command.append_flag('-nogroup', opts[:nogroup])
+        command.append_flag('-nouser', opts[:nouser])
+        command.append_flag('-mount', opts[:mount])
+
+        command.append_arg('-path', opts[:path])
+        command.append_arg('-name', opts[:name])
+        command.append_arg('-gid', opts[:gid])
+        command.append_arg('-uid', opts[:uid])
+        command.append_arg('-user', opts[:user])
+        command.append_arg('-group', opts[:group])
+        command.append_arg('-inum', opts[:inode])
+        command.append_arg('-links', opts[:links])
+        command.append_arg('-maxdepth', opts[:maxdepth])
+        command.append_arg('-mindepth', opts[:mindepth])
+
+        command.append_arg('-atime', opts[:atime])
+        command.append_arg('-ctime', opts[:ctime])
+        command.append_arg('-mtime', opts[:mtime])
+        command.append_arg('-amin', opts[:amin])
+        command.append_arg('-cmin', opts[:cmin])
+        command.append_arg('-mmin', opts[:mmin])
+
+        command.append_arg('-regex', "'#{regex}'") if Kanrisuru::Util.present?(regex)
+
+        if size.instance_of?(String)
+          match = Regexp.new(/^([-+]+)\s*?(\d+)([bcwkMG])$/).match(size)
+
+          raise ArgumentError, "invalid size string: '#{@size}'" if match.nil? || match.captures.include?(nil)
+
+          command.append_arg('-size', size)
+        elsif size.instance_of?(Integer)
+          command.append_arg('-size', size)
+        end
+
+        case type
+        when 'directory'
+          command.append_arg('-type', 'd')
+        when 'file'
+          command.append_arg('-type', 'f')
+        when 'symlinks'
+          command.append_arg('-type', 'l')
+        when 'block'
+          command.append_arg('-type', 'b')
+        when 'character'
+          command.append_arg('-type', 'c')
+        when 'pipe'
+          command.append_arg('-type', 'p')
+        when 'socket'
+          command.append_arg('-type', 's')
+        end
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          rows = cmd.to_a
+
+          rows.map do |row|
+            FilePath.new(row)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/group.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module Group
+      extend OsPackage::Define
+
+      os_define :linux, :group?
+      os_define :linux, :get_gid
+      os_define :linux, :get_group
+      os_define :linux, :create_group
+      os_define :linux, :update_group
+      os_define :linux, :delete_group
+
+      Group = Struct.new(:gid, :name, :users)
+      GroupUser = Struct.new(:uid, :name)
+
+      def group?(group)
+        result = get_gid(group)
+        return false if result.failure?
+
+        Kanrisuru::Util.present?(result.data) && result.data.instance_of?(Integer)
+      end
+
+      def get_gid(group)
+        command = Kanrisuru::Command.new("getent group #{group}")
+
+        execute(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          cmd.to_s.split(':')[2].to_i
+        end
+      end
+
+      def get_group(group)
+        command = Kanrisuru::Command.new("getent group #{group} | cut -d: -f4")
+
+        execute(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          ## Get group id
+          result = get_gid(group)
+          break if result.failure?
+
+          gid = result.to_i
+
+          array = cmd.to_s.split(',')
+          users = array.map do |user|
+            uid = get_uid(user)
+            GroupUser.new(uid.to_i, user)
+          end
+
+          Group.new(gid, group, users)
+        end
+      end
+
+      def create_group(group, opts = {})
+        gid = opts[:gid]
+
+        command = Kanrisuru::Command.new("groupadd #{group}")
+        command.append_arg('-g', gid)
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do
+          gid = Kanrisuru::Util.present?(gid) ? gid : get_gid(group).data
+          Group.new(gid, group)
+        end
+      end
+
+      def update_group(group, opts = {})
+        gid = opts[:gid]
+        return if Kanrisuru::Util.blank?(gid) || Kanrisuru::Util.blank?(opts[:new_name])
+
+        command = Kanrisuru::Command.new("groupmod #{group}")
+        command.append_arg('-g', gid)
+        command.append_arg('-n', opts[:new_name])
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do
+          gid = Kanrisuru::Util.present?(gid) ? gid : get_gid(group).data
+          Group.new(gid, group)
+        end
+      end
+
+      def delete_group(group)
+        return false unless group?(group)
+
+        command = Kanrisuru::Command.new("groupdel #{group}")
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command)
+      end
+    end
+  end
+end