ykutils 0.1.0 → 0.1.1

data/bin/makegrid

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "ykutils"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+#require "irb"
+#IRB.start(__FILE__)
+#puts( make_grid(1 , 2) )
+
+#puts Ykutils::Erubyx::make_grid_list()
+min_row = ARGV[0].to_i
+max_row = ARGV[1].to_i
+min_colum = ARGV[2].to_i
+max_colum = ARGV[3].to_i
+puts Ykutils::Gridlist::make_grid_list_x(min_row, max_row, min_colum, max_colum)

data/bin/setup

@@ -1,6 +1,7 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -euo pipefail
 IFS=$'\n\t'
+set -vx
 
 bundle install
 

data/lib/ykutils/datastructop.rb

@@ -0,0 +1,58 @@
+module Ykutils
+  module DataStructOp
+    def exchange(target_ary, hash, item_key, index_key, content)
+      v = hash[item_key]
+      if v
+        target_ary[v[index_key]] = content
+      else
+        target_ary << content
+      end
+    end
+
+    def select_array(ary, num, &block)
+      ret_ary = []
+      if block
+        ary.each do |line|
+          ret_ary << [line, num] if block.call(line, num)
+          num += 1
+        end
+      else
+        ary.each do |line|
+          ret_ary << [line, num]
+          num += 1
+        end
+      end
+      ret_ary
+    end
+
+    def make_array(ary, num, &block)
+      ret_ary = []
+      if block
+        ary.each do |line|
+          ary = block.call(line, num)
+          ret_ary += ary if ary
+          num += 1
+        end
+      else
+        ret_ary = ary
+      end
+
+      ret_ary
+    end
+
+    def make_hash(ary, num, &block)
+      kv_ary = []
+      if block
+        ary.each do |line|
+          ary = block.call(line, num)
+          kv_ary += ary if ary
+          num += 1
+        end
+      else
+        kv_ary = ary.collect { |line| [line, nil] }.flatten
+      end
+
+      Hash[*kv_ary]
+    end
+  end
+end

data/lib/ykutils/debugutils.rb

@@ -1,32 +1,29 @@
-require 'pp'
+require "pp"
 
 module Ykutils
   module DebugUtils
     class DebugMes
-      def DebugMes.init( debug = false )
+      def self.init(debug = false)
         @@debug = debug
         @@buf = []
       end
 
-      def DebugMes.set_debug( debug )
+      def self.set_debug(debug)
         @@debug = debug
       end
 
-      def DebugMes.puts_x( mes )
+      def self.puts_x(mes)
         @@buf ||= []
         @@buf << mes
-        #      puts "#{@@buf.size} |#{mes}" 
-
+        #      puts "#{@@buf.size} |#{mes}"
       end
 
-      def DebugMes.get
-        buf = @@buf
+      def self.get
+        @@buf
         #      DebugMes.clear
-
-        buf
       end
 
-      def DebugMes.clear
+      def self.clear
         @@buf ||= []
         @@buf.clear
       end
@@ -37,7 +34,7 @@ module Ykutils
     end
 
     def puts_d(mes)
-      DebugMes.puts_x( mes )
+      DebugMes.puts_x(mes)
       #    puts mes
     end
 
@@ -56,22 +53,22 @@ module Ykutils
     end
 
     def debug_utils_init
-      set_debug( false )
-      set_warn( 0 )
+      set_debug(false)
+      set_warn(0)
 
-      DebugMes.init( false )
+      DebugMes.init(false)
     end
 
-    def set_debug( val )
+    def set_debug(val)
       @debugutils = val
-      DebugMes.set_debug( val )
+      DebugMes.set_debug(val)
     end
 
     def get_debug
       @debugutils
     end
 
-    def set_warn( val )
+    def set_warn(val)
       @warn = val
     end
 
@@ -79,45 +76,41 @@ module Ykutils
       @debugutils
     end
 
-    def d_exit( num )
-      exit( num ) if @debugutils
+    def d_exit(num)
+      exit(num) if @debugutils
     end
 
-    def d_puts( str )
+    def d_puts(str)
       puts(str) if @debugutils
     end
 
-    def w1_puts( str )
-      unless @warn
-        set_warn( 0 )
-      end
+    def w1_puts(str)
+      set_warn(0) unless @warn
       puts(str) if @debugutils or @warn >= 1
     end
 
-    def w2_puts( str )
-      unless @warn
-        set_warn( 0 )
-      end
+    def w2_puts(str)
+      set_warn(0) unless @warn
       puts(str) if @debugutils or @warn >= 2
     end
 
-    def d_caller( num )
-      pp caller( 0 ) if @debugutils
+    def d_caller(_num)
+      pp caller(0) if @debugutils
     end
 
-    def puts_no_empty( mes )
+    def puts_no_empty(mes)
       puts mes if mes != ""
     end
 
-    def d_puts_no_empty( mes )
+    def d_puts_no_empty(mes)
       puts mes if mes != "" and @debugutils
     end
 
-    def d_p( it )
+    def d_p(it)
       p it if @debugutils
     end
 
-    def d_pp( it )
+    def d_pp(it)
       if @debugutils
         pp "@debugutils=#{@debugutils}"
         pp caller(0)

data/lib/ykutils/erubyx.rb

@@ -0,0 +1,14 @@
+require 'tilt'
+
+module Ykutils
+  module Erubyx
+    module_function
+
+    def erubi_render(template_hash, scope, value_hash)
+      unless template_hash[:OBJ]
+        template_hash[:OBJ] = Tilt::ErubiTemplate.new{ template_hash[:TEMPLATE] }
+      end
+      template_hash[:OBJ].render( scope, value_hash )
+    end
+  end
+end

data/lib/ykutils/fileoputils.rb

@@ -0,0 +1,401 @@
+require "ykutils/stringutils"
+require "ykutils/retcodex"
+require "ykutils/debugutils"
+
+module Ykutils
+  module FileOpUtils
+    include StringUtils
+    include DebugUtils
+
+    WRITABLE_FILE_PATH = 11
+    VALID_FILE_PATH = 10
+    ABNORMAL_STRING = -5
+    INVALID_FILE_PATH = -10
+    NOT_WRITABLE_FILE_PATH = -11
+
+    VALID_PATH = 20
+    INVALID_PATH = -20
+
+    def valid?
+      @valid
+    end
+
+    def valid_fpath(fname)
+      ret = VALID_FILE_PATH
+      if normal_string?(fname)
+        ret = INVALID_FILE_PATH unless File.file?(fname)
+      else
+        ret = ABNORMAL_STRING
+      end
+      ret
+    end
+
+    def valid_path(path)
+      ret = VALID_PATH
+      if normal_string?(path)
+        ret = INVALID_PATH unless File.exist?(path)
+      else
+        ret = ABNORMAL_STRING
+      end
+      ret
+    end
+
+    def valid_fpath_with_message(fname)
+      d_puts("valid_fpath_with_message|fname=#{fname}")
+
+      mes = ""
+      ret = valid_fpath(fname)
+      ret_bool = (ret == VALID_FILE_PATH)
+
+      case ret
+      when ABNORMAL_STRING
+        mes = "abnormal string|#{fname}"
+        @valid = false
+
+        d_puts("1 fname=#{fname}")
+        d_caller(0)
+      when INVALID_PATH
+        mes = "Can't find #{fname}"
+        d_caller(0)
+        @valid = false
+
+        d_puts("2 fname=#{fname}")
+        d_caller(0)
+      else
+        mes = ""
+        d_puts("3 fname=#{fname}")
+      end
+      RetCode2.new(ret, ret_bool, mes)
+    end
+
+    def valid_fname?(fname)
+      ret = false
+      if normal_string?(fname)
+        if File.file?(fname)
+          ret = true
+        else
+          d_puts("FileOpUtils:valid_fname? 2")
+        end
+      else
+        d_puts("FileOpUtils:valid_fname? 1")
+      end
+      ret
+    end
+
+    def valid_readable_fname?(fname)
+      ret = false
+      ret = true if normal_string?(fname) and File.file?(fname) and File.readable?(fname)
+      ret
+    end
+
+    def valid_writable_fpath_with_message(fname)
+      mes = ""
+
+      ret = valid_fpath(fname)
+
+      ret_bool = (ret == VALID_FILE_PATH)
+
+      case ret
+      when ABNORMAL_STRING
+        mes = "abnormal string|#{fname}"
+        @valid = false
+        d_puts("1 fname=#{fname}")
+        d_caller(0)
+      when INVALID_FILE_PATH
+        mes = "Can't find #{fname}"
+        d_caller(0)
+        @valid = false
+        d_puts("2 fname=#{fname}")
+        d_caller(0)
+      else
+        if File.writable?(fname)
+          mes = ""
+          ret = WRITABLE_FILE_PATH
+        else
+          mes = "Can't write #{fname}"
+          @valid = false
+          ret = NOT_WRITABLE_FILE_PATH
+          ret_bool = false
+          d_puts("3 fname=#{fname}")
+          d_caller(0)
+        end
+      end
+      RetCode2.new(ret, ret_bool, mes)
+    end
+
+    def valid_writable_fname?(fname)
+      ret = false
+      if normal_string?(fname)
+        if File.file?(fname)
+          ret = true if File.writable?(fname)
+        else
+          unless File.directory?(fname)
+            dir, filename = File.split(fname)
+            ret = valid_writable_directory?(dir)
+          end
+        end
+      end
+      ret
+    end
+
+    def valid_readable_directory?(path)
+      ret = false
+      ret = true if File.directory?(path) && File.readable?(path)
+      ret
+    end
+
+    def valid_writable_directory?(path)
+      ret = false
+      ret = true if File.directory?(path) && File.writable?(path)
+      ret
+    end
+
+    def write_file_with_template(input_file_path, output_file)
+      ary = []
+      begin
+        File.open(input_file_path, "r") do |file|
+          while line = file.gets
+            line.chomp!
+            ary << file_content_process(line)
+          end
+        end
+      rescue StandardError => e
+        pp e
+        pp e.traceback
+        @valid = false
+      end
+      if @valid
+        content = ary.join("\n")
+        begin
+          output_file.write(content)
+        rescue StandardError => e
+          pp e
+          pp e.traceback
+          @valid = false
+        end
+      end
+    end
+
+    def rewrite_file(from_path_1, from_path_2, to_path_1, to_path_2)
+      d_p("rewrite_file")
+      d_p("from_path_1=#{from_path_1}")
+      d_p("from_path_2=#{from_path_2}")
+      d_p("to_path_1=#{to_path_1}")
+      d_p("to_path_2=#{to_path_2}")
+
+      mes = prepare_file_copy(from_path_1, from_path_2, to_path_1, to_path_2)
+
+      puts_no_empty(mes)
+
+      return false unless @valid
+
+      from_path = File.join(from_path_1, from_path_2)
+      to_path = File.join(to_path_1, to_path_2)
+      ary = []
+      begin
+        File.open(from_path, "r") do |file|
+          while line = file.gets
+            line.chomp!
+            ary << file_content_process(line)
+          end
+        end
+      rescue StandardError => e
+        pp e
+        pp e.traceback
+        @valid = false
+      end
+
+      return false unless @valid
+
+      content = ary.join("\n")
+
+      begin
+        File.write(to_path, content)
+      rescue StandardError => e
+        pp e
+        pp e.traceback
+        @valid = false
+      end
+    end
+
+    def prepare_file_copy(from_path_1, from_path_2, to_path_1, to_path_2)
+      mes = ""
+
+      d_p("prepare_file_copy")
+      d_p("from_path_1=#{from_path_1}")
+      d_p("from_path_2=#{from_path_2}")
+      d_p("to_path_1=#{to_path_1}")
+      d_p("to_path_2=#{to_path_2}")
+
+      if prepare_source_dir(from_path_1, from_path_2)
+        unless prepare_dest_dir(to_path_1, to_path_2)
+          mes = "Can't write #{to_path_1}/#{to_path_1}"
+          d_caller(0)
+          @valid = false
+        end
+      else
+        mes = "Can't read #{from_path_1}/#{from_path_2}"
+        @valid = false
+      end
+
+      mes
+    end
+
+    def prepare_source_dir(from_path_1, from_path_2)
+      state = false
+      from_path = File.join(from_path_1, from_path_2)
+      if valid_readable_directory?(from_path_1)
+        dirname, filename = File.split(from_path)
+        state = true if valid_readable_directory?(dirname) && valid_readable_fname?(from_path)
+      end
+      state
+    end
+
+    def prepare_dest_dir(to_path_1, to_path_2)
+      state = true
+      unless valid_writable_directory?(to_path_1)
+        if File.exist?(to_path_1)
+          d_caller(0)
+          return false
+        end
+
+        begin
+          FileUtils.mkdir_p(to_path_1)
+        rescue StandardError => e
+          state = false
+          pp e
+          pp e.traceback
+        end
+      end
+      unless valid_writable_directory?(to_path_1)
+        d_caller(0)
+        return false
+      end
+
+      to_path = File.join(to_path_1, to_path_2)
+      dirname, filename = File.split(to_path)
+      unless File.exist?(dirname)
+        begin
+          FileUtils.mkdir_p(dirname)
+        rescue StandardError => e
+          state = false
+          pp caller(0)
+        end
+      end
+
+      unless state
+        d_caller(0)
+        return false
+      end
+
+      unless valid_writable_directory?(dirname)
+        d_caller(0)
+        return false
+      end
+
+      if File.file?(to_path) && !valid_writable_fname?(to_path)
+        d_caller(0)
+        return false
+      end
+
+      true
+    end
+
+    def copy_file(from_path_1, from_path_2, to_path_1, to_path_2)
+      retry_flag = false
+      begin
+        from_path = File.join(from_path_1, from_path_2)
+        to_path = File.join(to_path_1, to_path_2)
+        FileUtils.cp(from_path, to_path)
+        d_puts("Copy #{from_path} -> #{to_path}")
+      rescue StandardError => e
+        retry_flag = prepare_file_copy(from_path_1, from_path_2, to_path_1, to_path_2)
+      end
+
+      if retry_flag
+        begin
+          FileUtils.cp(from_path, to_path)
+          d_puts("Copy #{from_path} -> #{to_path}")
+        rescue StandardError => e
+          @valid = false
+        end
+      end
+
+      d_puts("Don't Copy #{from_path} -> #{to_path}") unless @valid
+    end
+
+    def find_file(path, dirname, filename)
+      ret = false
+      ary = path.split(File::SEPARATOR)
+      left = ary.index(dirname)
+      d_p(ary)
+      d_p(left)
+      if left
+        sub_ary = ary[(left + 1)..-1]
+        ret = true if sub_ary && sub_ary.index(filename)
+      end
+
+      ret
+    end
+
+    def check_filepath(fname_ary)
+      ret = RetCode2.new(ret, false, "")
+      mes_ary = []
+      fname_ary.each do |fname|
+        ret2 = valid_fpath_with_message(fname)
+        d_puts("==check_filepath")
+        d_puts_no_empty(ret2.mes)
+        d_p(ret2)
+        if ret2.bool
+          ret.ret = fname
+          ret.bool = true
+          break
+        elsif ret2.ret == FileOpUtils::ABNORMAL_STRING
+          ret.ret = ret2.ret
+          mes_ary << "Can't find common (#{common_fname})"
+        end
+      end
+      ret.mes = mes_ary.join("\n") unless ret.bool
+      ret
+    end
+
+    def make_fpath_list(fname, parent_dir_ary)
+      ary = [fname]
+      parent_dir_ary.each do |dir|
+        ary << File.join(dir, fname) if dir
+      end
+      ary
+    end
+
+    def reform_filename(fname, add_string)
+      path = Pathname(fname)
+      basename = path.basename(".*")
+      dirname = path.dirname
+      extname = path.extname
+
+      dirname.join(basename.to_s + add_string + extname.to_s)
+    end
+
+    def determine_encoding(pn)
+      encodings = [Encoding::UTF_8, Encoding::EUC_JP, Encoding::Shift_JIS, Encoding::CP932]
+
+      valid_enc = nil
+      encodings.each do |enc|
+        next if valid_enc
+
+        s = pn.expand_path.read(encoding: enc)
+        next unless s.valid_encoding?
+
+        begin
+          cs = s.encode(Encoding::CP932)
+          valid_enc = enc
+        rescue StandardError => e
+          #        puts "Conversion Error! #{y}"
+          #            puts y
+        end
+      end
+
+      valid_enc
+    end
+  end
+end

data/lib/ykutils/filepermision.rb

@@ -1,9 +1,9 @@
 module Ykutils
   class FilePermision
     attr_reader :owner, :group, :other
-    
+
     class PermisionEntry
-      def initialize( str )
+      def initialize(str)
         @read = str[0].chr
         @write = str[1].chr
         @exec = str[2].chr
@@ -14,14 +14,14 @@ module Ykutils
       end
 
       def to_hash
-        { "read" => @read , "write" => @write , "exec" => @exec }
+        { "read" => @read, "write" => @write, "exec" => @exec }
       end
     end
 
-    def initialize( str )
-      @owner = PermisionEntry.new( str[0..2] )
-      @group = PermisionEntry.new( str[3..5] )
-      @other = PermisionEntry.new( str[6..8] )
+    def initialize(str)
+      @owner = PermisionEntry.new(str[0..2])
+      @group = PermisionEntry.new(str[3..5])
+      @other = PermisionEntry.new(str[6..8])
     end
 
     def to_s
@@ -29,8 +29,7 @@ module Ykutils
     end
 
     def to_hash
-      h = { "owner" => @owner.to_hash , "group" => @group.to_hash , "other" => @other.to_hash }
+      h = { "owner" => @owner.to_hash, "group" => @group.to_hash, "other" => @other.to_hash }
     end
   end
-
 end