ykutils 0.1.0 → 0.1.4

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "bundler/setup"
 require "ykutils"
@@ -11,4 +12,4 @@ require "ykutils"
 # Pry.start
 
 require "irb"
-IRB.start
+IRB.start(__FILE__)

data/bin/erubix

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "ykutils"
+
+template_file_path = ARGV[0]
+value_file_path_array = [ARGV[1]]
+ind = 2
+while ARGV.size > ind
+  value_file_path_array << ARGV[ind]
+  ind += 1
+end
+
+scope = nil
+content = Ykutils::Erubyx::erubi_render_with_file(template_file_path, scope, value_file_path_array)
+puts content

data/bin/erubix2

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "ykutils"
+require 'yaml'
+require 'find'
+
+ncf = Ykutils::Nginxconfigfiles.new
+re = /base.yml$/
+start_dir = ARGV[0]
+file_list = ncf.get_file_list(start_dir, re)
+ncf.output(file_list)

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,41 @@
+require 'tilt'
+require 'yaml'
+
+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
+
+##
+# `erubi_render_with_file` takes a template file path, a scope, and a value file path, reads the
+# template file, loads the value file, and then calls `erubi_render` with the template hash, scope,
+# and value hash
+# 
+# Args:
+#   template_file_path: The path to the template file.
+#   scope: the scope of the template. This is the name of the directory that the template is in.
+#   value_file_path: The path to the YAML file that contains the values to be used in the template.
+    def erubi_render_with_file(template_file_path, scope, value_file_path_array)
+      template_text = File.read(template_file_path)
+      template_hash = { TEMPLATE: template_text,
+                        OBJ: nil
+                      }
+      value_hash = value_file_path_array.reduce({}){ |hash, path|
+        #p path
+        hash0 = YAML.load_file(path)
+        #p hash0
+        hash = hash.merge(hash0)
+        #p hash
+        hash
+      }
+      #puts value_hash
+      erubi_render(template_hash, 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