ykutils 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e9bf4a1496614553e8da4558a59f381ca144e99c
+  data.tar.gz: 3cdd60d495a1479f954f7d918131f3a0de74b56f
+SHA512:
+  metadata.gz: 45b7af05299dffc72a8a494ef9183176dff1b85243efa27774e3cc75b6478c7e56a06926128888a412206a22cfa858cd9bb42d05526deb0340bea549d572eff2
+  data.tar.gz: 107de770406966509cb4016d3a4842dcf651dfe7f19e61932bb8c639b1c3ea14499b7575d389432ec93b15e1d6e033abf6de07a759378adab8d6910cebe6aae4

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ykutils.gemspec
+gemspec

data/README.md

@@ -0,0 +1,39 @@
+# Ykutils
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/ykutils`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ykutils'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ykutils
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/ykutils/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+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

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ykutils.rb

@@ -0,0 +1,5 @@
+require "ykutils/version"
+
+module Ykutils
+  # Your code goes here...
+end

data/lib/ykutils/debugutils.rb

@@ -0,0 +1,129 @@
+require 'pp'
+
+module Ykutils
+  module DebugUtils
+    class DebugMes
+      def DebugMes.init( debug = false )
+        @@debug = debug
+        @@buf = []
+      end
+
+      def DebugMes.set_debug( debug )
+        @@debug = debug
+      end
+
+      def DebugMes.puts_x( mes )
+        @@buf ||= []
+        @@buf << mes
+        #      puts "#{@@buf.size} |#{mes}" 
+
+      end
+
+      def DebugMes.get
+        buf = @@buf
+        #      DebugMes.clear
+
+        buf
+      end
+
+      def DebugMes.clear
+        @@buf ||= []
+        @@buf.clear
+      end
+    end
+
+    def clear_d
+      DebugMes.clear
+    end
+
+    def puts_d(mes)
+      DebugMes.puts_x( mes )
+      #    puts mes
+    end
+
+    def get_d
+      DebugMes.get
+    end
+
+    def puts_current_method
+      d_puts (caller(1)[0].split)[-1]
+    end
+
+    def error_exit(n)
+      puts "error(#{n})"
+      pp caller(0)
+      exit(n)
+    end
+
+    def debug_utils_init
+      set_debug( false )
+      set_warn( 0 )
+
+      DebugMes.init( false )
+    end
+
+    def set_debug( val )
+      @debugutils = val
+      DebugMes.set_debug( val )
+    end
+
+    def get_debug
+      @debugutils
+    end
+
+    def set_warn( val )
+      @warn = val
+    end
+
+    def debug
+      @debugutils
+    end
+
+    def d_exit( num )
+      exit( num ) if @debugutils
+    end
+
+    def d_puts( str )
+      puts(str) if @debugutils
+    end
+
+    def w1_puts( str )
+      unless @warn
+        set_warn( 0 )
+      end
+      puts(str) if @debugutils or @warn >= 1
+    end
+
+    def w2_puts( str )
+      unless @warn
+        set_warn( 0 )
+      end
+      puts(str) if @debugutils or @warn >= 2
+    end
+
+    def d_caller( num )
+      pp caller( 0 ) if @debugutils
+    end
+
+    def puts_no_empty( mes )
+      puts mes if mes != ""
+    end
+
+    def d_puts_no_empty( mes )
+      puts mes if mes != "" and @debugutils
+    end
+
+    def d_p( it )
+      p it if @debugutils
+    end
+
+    def d_pp( it )
+      if @debugutils
+        pp "@debugutils=#{@debugutils}"
+        pp caller(0)
+        exit
+      end
+      pp it if @debugutils
+    end
+  end
+end

data/lib/ykutils/fileoputils2.rb

@@ -0,0 +1,443 @@
+require 'ykutils/stringutils'
+require 'ykutils/retcodex'
+require 'ykutils/debugutils'
+require 'ykutils/fileoputils2'
+
+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 ) 
+        unless File.file?( fname )
+          ret = INVALID_FILE_PATH
+        end
+      else
+        ret = ABNORMAL_STRING
+      end
+      ret
+    end
+
+    def valid_path( path )
+      ret = VALID_PATH
+      if normal_string?( path ) 
+        unless File.exist?( path )
+          ret = INVALID_PATH
+        end
+      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 ? true : false )
+
+      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
+      if normal_string?( fname ) and File.file?( fname ) and File.readable?( fname )
+        ret = true
+      end
+      ret
+    end
+
+    def valid_writable_fpath_with_message( fname )
+      mes = ""
+
+      ret = valid_fpath(fname)
+
+      ret_bool = (ret == VALID_FILE_PATH ? true : false )
+
+      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 ) 
+          if File.writable?( fname )
+            ret = true
+          end
+        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
+      if File.directory?(path)
+        if File.readable?(path)
+          ret = true
+        end
+      end
+      ret
+    end
+
+    def valid_writable_directory?( path )
+      ret = false
+      if File.directory?(path)
+        if File.writable?(path)
+          ret = true
+        end
+      end
+      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 => ex
+        pp ex
+        pp ex.traceback
+        @valid = false
+      end
+      if @valid
+        content = ary.join("\n")
+        begin
+          output_file.write( content )
+        rescue => ex
+          pp ex
+          pp ex.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 )
+
+
+      unless @valid
+        return false
+      end
+
+      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 => ex
+        pp ex
+        pp ex.traceback
+        @valid = false
+      end
+      
+      unless @valid
+        return false
+      end
+
+      content = ary.join("\n")
+
+      begin
+        File.open( to_path , "w") do |file|
+          file.write( content )
+        end
+      rescue => ex
+        pp ex
+        pp ex.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}" )
+
+      unless prepare_source_dir( from_path_1, from_path_2 )
+        mes = "Can't read #{from_path_1}/#{from_path_2}"
+        @valid = false
+      else
+        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
+      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 )
+        if valid_readable_directory?( dirname )
+          if valid_readable_fname?( from_path )
+            state = true
+          end
+        end
+      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 => ex
+          state = false
+          pp ex
+          pp ex.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 => ex
+          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 )
+        unless valid_writable_fname?( to_path )
+          d_caller(0)
+          return false
+        end
+      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 => ex
+        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 => ex
+          @valid = false
+        end
+      end
+
+      unless @valid
+        d_puts( "Don't Copy #{from_path} -> #{to_path}" )
+      end
+    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]
+        if sub_ary
+          if sub_ary.index( filename )
+            ret = true
+          end
+        end
+      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
+        else
+          if ret2.ret == FileOpUtils::ABNORMAL_STRING
+            ret.ret = ret2.ret
+            mes_ary << "Can't find common (#{common_fname})"
+          end
+        end
+      end
+      unless ret.bool
+        ret.mes = mes_ary.join("\n")
+      end
+      ret
+    end
+
+    def make_fpath_list( fname , parent_dir_ary )
+      ary = [ fname ]
+      parent_dir_ary.each do |dir|
+        if dir
+          ary << File.join( dir , fname )
+        end
+      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| 
+        unless valid_enc
+          s = pn.expand_path.read(:encoding => enc)
+          if s.valid_encoding?
+            begin
+              cs = s.encode(Encoding::CP932)
+              valid_enc = enc
+            rescue => ex
+              #        puts "Conversion Error! #{y}"
+              #            puts y
+            end
+          end
+        end
+      end
+
+      valid_enc
+    end
+  end
+end