easysuite 1.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ce68c493c22986c2c08f2443778f6de32c365eeeed0b64e24182a01b162cd295
+  data.tar.gz: ababc499754f35cec1e70a68f577ca172b60a2fcab9112059a8b0b779429581d
+SHA512:
+  metadata.gz: 9030154a5e7c000c3ca1742590b88a4fb02a39b029ea0fae635b48a26978904062530efe8ea8c393c16bce92a3dead707fd16710bc61082ae2c06b9e6ba8037c
+  data.tar.gz: '08f47c288a9f622de954df439c313e417b7fb4760637464aa34582f4e9cc4792f2935807b87d96b14d2edd4802bb263386389b85652caf60549b5e7c2d3dda69'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Masafumi Kiribayashi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/exe/easysuite

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+
+if (ARGV.size >= 2) && (ARGV[0] == "new")
+  proj = ARGV[1]
+  $stderr.puts("Deploying easytools to '#{proj}'...")
+
+  ["app", "config", "lib", "log", "tmp"].each do |dir|
+    unless File.exist?(path = File.join(proj, dir))
+      $stderr.puts("%12s  %s" % ["create", path])
+      FileUtils.mkpath(path)
+    end
+  end
+
+  paths = []
+  paths << File.join(proj, "lib", "easytools.rb")
+  paths << File.join(proj, "app", "common.rb")
+  paths << File.join(proj, "app", "sample.rb")
+
+  paths.each do |path|
+    unless File.exist?(path)
+      $stderr.puts("%12s  %s" % ["create", path])
+      src = File.expand_path("../../sample/#{File.basename(path)}", __FILE__)
+      FileUtils.cp(src, path)
+    end
+  end
+else
+  $stderr.puts("SYNOPSIS: easysuite new [Project]")
+end

data/lib/easysuite/config.rb

@@ -0,0 +1,243 @@
+require 'yaml'
+
+module EasySuite
+  #--
+  # Config
+  #++
+  # Class to config easily.
+  class Config
+    class << self
+      #--
+      # load_yaml
+      #++
+      # Load object from YAML file.
+      def load_yaml(path)
+        yaml = binread(path).to_s
+        YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(yaml) : YAML.load(yaml)
+      end
+
+      alias_method :load, :load_yaml
+
+      #--
+      # dump_yaml
+      #++
+      # Dump object to YAML file.
+      def dump_yaml(path, obj)
+        binwrite(path, YAML.dump(obj))
+      end
+
+      alias_method :dump, :dump_yaml
+
+      #--
+      # read
+      #++
+      # Read string from file.
+      def read(path)
+        IO.read(path) rescue nil
+      end
+
+      #--
+      # write
+      #++
+      # Write string to file.
+      def write(path, str)
+        IO.write(path, str)
+      end
+
+      #--
+      # binread
+      #++
+      # Read string from file.(binary mode)
+      def binread(path)
+        IO.binread(path) rescue nil
+      end
+
+      #--
+      # binwrite
+      #++
+      # Write string to file.(binary mode)
+      def binwrite(path, str)
+        IO.binwrite(path, str)
+      end
+
+      #--
+      # set_values
+      #++
+      # Set values from Hash or YAML file.
+      def set_values(obj, src, *keys)
+        values = case src
+          when Hash
+            src
+          when String
+            load_yaml(src) rescue nil
+          end
+
+        if values.kind_of?(Hash)
+          keys = values.keys if keys.empty?
+
+          keys.each do |key|
+            writer = key.to_s + "="
+            obj.__send__(writer, values[key]) if obj.respond_to?(writer)
+          end
+        end
+
+        obj
+      end
+
+      #--
+      # encode
+      #++
+      # Encode strings (in Hash and Array).
+      def encode(obj, &proc)
+        proc ||= lambda {|s| s.encode }
+
+        case obj
+        when Hash
+          {}.tap {|x| obj.each {|k, v| x[encode(k, &proc)] = encode(v, &proc) }}
+        when Array
+          [].tap {|x| obj.each {|v| x << encode(v, &proc) }}
+        when String
+          proc.call(obj)
+        when Symbol
+          proc.call(obj.to_s).to_sym
+        else
+          obj
+        end
+      end
+
+      #--
+      # keys_to_symbol
+      #++
+      # Convert Hash keys into Symbol from String (in Hash and Array).
+      def keys_to_symbol(obj)
+        keys_to_something(obj) do |x, k, v|
+          if k.kind_of?(String)
+            x[k.to_sym] ||= keys_to_symbol(v)
+          else
+            x[k] = keys_to_symbol(v)
+          end
+        end
+      end
+
+      #--
+      # keys_to_string
+      #++
+      # Convert Hash keys into String from Symbol (in Hash and Array).
+      def keys_to_string(obj)
+        keys_to_something(obj) do |x, k, v|
+          if k.kind_of?(Symbol)
+            x[k.to_s] ||= keys_to_string(v)
+          else
+            x[k] = keys_to_string(v)
+          end
+        end
+      end
+
+      private
+
+      #--
+      # keys_to_something
+      #++
+      # Convert Hash keys (in Hash and Array).
+      def keys_to_something(obj, &proc)
+        return obj unless proc
+
+        case obj
+        when Hash
+          {}.tap {|x| obj.each {|k, v| proc.call(x, k, keys_to_something(v, &proc)) }}
+        when Array
+          [].tap {|x| obj.each {|v| x << keys_to_something(v, &proc) }}
+        else
+          obj
+        end
+      end
+    end
+
+    attr_accessor :config_dir
+
+    #--
+    # initialize
+    #++
+    # [config_dir]
+    #   Default directory of instance.
+    def initialize(config_dir = nil)
+      @config_dir = config_dir
+    end
+
+    #--
+    # load_yaml
+    #++
+    # Load object from YAML file.
+    def load_yaml(filename)
+      path = expand_path(filename)
+      Config.load_yaml(path)
+    end
+
+    alias_method :load, :load_yaml
+
+    #--
+    # dump_yaml
+    #++
+    # Dump object to YAML file.
+    def dump_yaml(filename, obj)
+      path = expand_path(filename)
+      Config.dump_yaml(path, obj)
+    end
+
+    alias_method :dump, :dump_yaml
+
+    #--
+    # read
+    #++
+    # Read string from file.
+    def read(filename)
+      path = expand_path(filename)
+      Config.read(path)
+    end
+
+    #--
+    # write
+    #++
+    # Write string to file.
+    def write(filename, str)
+      path = expand_path(filename)
+      Config.write(path, str)
+    end
+
+    #--
+    # binread
+    #++
+    # Read string from file.(binary mode)
+    def binread(filename)
+      path = expand_path(filename)
+      Config.binread(path)
+    end
+
+    #--
+    # binwrite
+    #++
+    # Write string to file.(binary mode)
+    def binwrite(filename, str)
+      path = expand_path(filename)
+      Config.binwrite(path, str)
+    end
+
+    #--
+    # set_values
+    #++
+    # Set values from Hash or YAML file.
+    def set_values(obj, src, *keys)
+      src = expand_path(src) if src.kind_of?(String)
+      Config.set_values(obj, src, *keys)
+    end
+
+    private
+
+    #--
+    # expand_path
+    #++
+    def expand_path(filename)
+      File.expand_path(filename, @config_dir)
+    end
+  end
+end

data/lib/easysuite/lock.rb

@@ -0,0 +1,135 @@
+require 'fileutils'
+require 'timeout'
+
+module EasySuite
+  #--
+  # Lock
+  #++
+  # Class to lock easily.
+  class Lock
+    attr_accessor :lock_dir
+
+    #--
+    # initialize
+    #++
+    # [lock_dir]
+    #   This class uses files in the directory.
+    def initialize(lock_dir = nil)
+      @lock_dir = lock_dir
+    end
+
+    #--
+    # lock
+    #++
+    # Make lock file in @lock_dir.
+    def lock(name)
+      result = create_lock_file(name)
+
+      if result && block_given?
+        begin
+          result = yield
+        ensure
+          delete_lock_file(name)
+        end
+      end
+
+      result
+    end
+
+    #--
+    # wait
+    #++
+    # Make lock file in @lock_dir until success.
+    def wait(name, sec = nil)
+      result = nil
+
+      begin
+        Timeout.timeout(sec) {
+          sleep(1) until result = create_lock_file(name)
+        }
+      rescue Timeout::Error
+      end
+
+      if result && block_given?
+        begin
+          result = yield
+        ensure
+          delete_lock_file(name)
+        end
+      end
+
+      result
+    end
+
+    #--
+    # unlock
+    #++
+    # Delete lock file in @lock_dir.
+    def unlock(name)
+      delete_lock_file(name)
+    end
+
+    private
+
+    #--
+    # lock_file(name)
+    #++
+    def lock_file(name)
+      File.expand_path("#{name}.lock", @lock_dir.to_s)
+    end
+
+    #--
+    # owner_pid(name)
+    #++
+    def owner_pid(name)
+      IO.read(lock_file(name)).to_i rescue 0
+    end
+
+    #--
+    # is_valid?(name)
+    #++
+    def is_valid?(name)
+      ((pid = owner_pid(name)) > 0) && ((Process.kill(0, pid) rescue 0) == 1)
+    end
+
+    #--
+    # create_lock_file
+    #++
+    def create_lock_file(name)
+      return false unless @lock_dir
+
+      if is_valid?(name)
+        return (owner_pid(name) == Process.pid)
+      end
+
+      begin
+        FileUtils.mkpath(@lock_dir)
+        IO.write(lock_file(name), "#{Process.pid}\n")
+      rescue
+        return false
+      end
+
+      true
+    end
+
+    #--
+    # delete_lock_file
+    #++
+    def delete_lock_file(name)
+      return false unless @lock_dir
+      return true unless File.exist?(lock_file(name))
+
+      if is_valid?(name) && (owner_pid(name) != Process.pid)
+        return false
+      end
+
+      begin
+        FileUtils.rm(lock_file(name))
+      rescue
+        return false
+      end
+
+      true
+    end
+  end
+end

data/lib/easysuite/logger.rb

@@ -0,0 +1,97 @@
+require 'easysuite/thread'
+require 'fileutils'
+require 'logger'
+
+module EasySuite
+  #--
+  # Logger
+  #++
+  # Class to log easily.
+  class Logger < ThreadSafe
+    #--
+    # initialize
+    #++
+    def initialize(log_dir = nil, log_file = nil)
+      super()
+      @log_dir = log_dir
+      @log_file = log_file
+      reset
+    end
+
+    #--
+    # log_dir=
+    #++
+    def log_dir=(log_dir)
+      reutrn if (@log_dir == log_dir)
+      @log_dir = log_dir
+      reset
+    end
+
+    #--
+    # log_dir
+    #++
+    def log_dir
+      @log_dir || "."
+    end
+
+    #--
+    # log_file=
+    #++
+    def log_file=(log_file)
+      return if (@log_file == log_file)
+      @log_file = log_file
+      reset
+    end
+
+    #--
+    # log_file
+    #++
+    def log_file
+      s = @log_file || ""
+      s = "common.log" if s.empty?
+      Time.now.strftime(s)
+    end
+
+    #--
+    # puts
+    #++
+    def puts(*args)
+      current = Time.now
+      reset unless @last_time &&
+        (@last_time.yday == current.yday) && (@last_time.year == current.year)
+      @last_time = current
+      prepare
+      args.flatten.each {|arg| arg.to_s.each_line {|l| @logger.debug(l.chomp) }}
+    end
+
+    private
+
+    #--
+    # log_format
+    #++
+    def log_format(severity, datetime, progname, msg)
+      datetime.strftime("[%Y-%m-%d %H:%M:%S] #{msg}\n")
+    end
+
+    #--
+    # reset
+    #++
+    def reset
+      return unless @logger
+      @logger.close
+      @logger = nil
+    end
+
+    #--
+    # prepare
+    #++
+    def prepare
+      return if @logger
+      log_path = File.join(self.log_dir, self.log_file)
+      FileUtils.mkpath(self.log_dir)
+      FileUtils.touch(log_path) unless File.exist?(log_path)
+      @logger = ::Logger.new(log_path)
+      @logger.formatter = method(:log_format)
+    end
+  end
+end

data/lib/easysuite/smtp.rb

@@ -0,0 +1,178 @@
+require 'net/smtp'
+require 'base64'
+
+module EasySuite
+  #--
+  # SMTP
+  #++
+  # Class to send mail easily.
+  class SMTP
+    attr_accessor :address, :port, :helo_domain, :account, :password, :authtype,
+      :from, :to, :cc, :bcc
+
+    #--
+    # initialize
+    #++
+    def initialize
+      @port = Net::SMTP.default_port
+      @helo_domain = "localhost"
+    end
+
+    #--
+    # send_mail
+    #++
+    def send_mail(subject, message)
+      smtp = Net::SMTP.new(@address, @port)
+
+      case @port
+      when Net::SMTP.default_port
+      when Net::SMTP.default_tls_port
+        smtp.enable_tls
+      when Net::SMTP.default_submission_port
+        smtp.enable_starttls
+      else
+        raise "Not supported port: #{@port}"
+      end
+
+      body, charset, transfer_encoding = make_body(message)
+      headers = []
+      headers << make_header("From", @from) if @from
+      headers << make_header("To", @to) if @to
+      headers << make_header("Cc", @cc) if @cc
+      headers << make_header("Bcc", @bcc) if @bcc
+      headers << make_header("Subject", subject)
+      headers << make_header("Date", Time.now.strftime("%a, %d %b %Y %X %z"))
+      headers << make_header("Mime-Version", "1.0")
+      headers << make_header("Content-Type", "text/plain; charset=#{charset}")
+      headers << make_header("Content-Transfer-Encoding", transfer_encoding)
+      mailsrc = headers.join("\n")
+      mailsrc += "\n\n#{body}"
+
+      smtp.start(@helo_domain, @account, @password, @authtype) do |smtp|
+        smtp.send_mail(mailsrc, mail_from, rcpt_to)
+      end
+    end
+
+    #--
+    # mail_from
+    #++
+    def mail_from
+      extract_address(@from)
+    end
+
+    #--
+    # rcpt_to
+    #++
+    def rcpt_to
+      addrs = []
+
+      ([@to].flatten + [@cc].flatten + [@bcc].flatten).each do |addr|
+        next unless addr
+        addrs << extract_address(addr)
+      end
+
+      addrs.uniq
+    end
+
+    private
+
+    #--
+    # make_header
+    #++
+    def make_header(key, val)
+      items = []
+
+      encode = lambda {|x|
+          Base64.encode64(x.encode(Encoding::UTF_8)).
+            lines.map {|l| "=?UTF-8?B?#{l.chomp}?=" }.join(" ")
+        }
+
+      # Make 7bit strings.
+      [val].flatten.each do |obj|
+        src = obj.to_s.gsub("\n", "")
+        dst = ""
+        buf = ""
+        space = ""
+
+        loop do
+          a = src.partition(/\s+/)
+
+          if a[0].ascii_only?
+            unless buf.empty?
+              dst += encode.call(buf)
+              buf = ""
+            end
+
+            dst += space
+            dst += a[0]
+          else
+            if buf.empty?
+              dst += space
+              buf = a[0]
+            else
+              buf += space
+              buf += a[0]
+            end
+          end
+
+          break if a[1].empty? && a[2].empty?
+          space, src = a[1], a[2]
+        end
+
+        unless buf.empty?
+          dst += encode.call(buf)
+          buf = ""
+        end
+
+        items << dst unless dst.empty?
+      end
+
+      # Each line of characters SHOULD be no more than 78 characters.
+      src = "#{key}: " + items.join(", ")
+      dst = ""
+      buf = ""
+      space = ""
+
+      loop do
+        a = src.partition(/\s+/)
+
+        if (buf.size + space.size + a[0].size > 78)
+          dst += buf + "\n"
+          buf = space + a[0]
+        else
+          buf += space + a[0]
+        end
+
+        break if a[1].empty? && a[2].empty?
+        space, src = a[1], a[2]
+      end
+
+      dst += buf
+    end
+
+    #--
+    # make_body
+    #++
+    def make_body(obj)
+      body = obj.to_s
+      charset = "US-ASCII"
+      transfer_encoding = "7bit"
+
+      unless body.ascii_only?
+        body = Base64.encode64(body.encode(Encoding::UTF_8))
+        charset = "UTF-8"
+        transfer_encoding = "base64"
+      end
+
+      return body, charset, transfer_encoding
+    end
+
+    #--
+    # extract_address
+    #++
+    def extract_address(addr)
+      addr = addr.to_s.strip
+      (addr =~ /<(.+)>$/) ? $1 : addr
+    end
+  end
+end

data/lib/easysuite/thread.rb

@@ -0,0 +1,97 @@
+require 'monitor'
+
+module EasySuite
+  #--
+  # ThreadPool
+  #++
+  # Class for thread pooling.
+  class ThreadPool
+    #--
+    # initialize
+    #++
+    # [size]
+    #   Maximum size of worker threads.
+    #   If the value is not positive, there is no limit.
+    def initialize(size)
+      @size = size
+      @queue = Queue.new
+      @workers = []
+    end
+
+    #--
+    # execute
+    #++
+    # Execute block on worker thread.
+    def execute(&block)
+      if (@size > 0)
+        while (@queue.size >= @size)
+          sleep(0.01)
+        end
+      end
+
+      @queue.push(block)
+
+      if (@size <= 0) || (@workers.size < @size)
+        @workers << create_worker
+      end
+    end
+
+    #--
+    # shutdown
+    #++
+    # Wait for active worker threads.
+    def shutdown
+      until @queue.empty? && (@queue.num_waiting == @workers.size)
+        sleep(0.01)
+      end
+
+      @workers.each {|t| t.kill }
+      nil
+    end
+
+    private
+
+    #--
+    # create_worker
+    #++
+    # create worker thread.
+    def create_worker
+      Thread.new(@queue) do |q|
+        loop do
+          begin
+            q.pop.call
+          rescue Exception => e
+            $stderr.puts("#{e.backtrace[0]}: #{e.message} (#{e.class.name})")
+            e.backtrace[1..-1].each {|bt| $stderr.puts("\tfrom #{bt}") }
+          end
+        end
+      end
+    end
+  end
+
+  #--
+  # ThreadSafe
+  #++
+  # Class for thread safe.
+  class ThreadSafe
+    include MonitorMixin
+    @@thread_safe_instance_methods = []
+
+    private
+
+    def ThreadSafe.method_added(name)
+      fullname = "#{self}##{name}"
+      return if @@thread_safe_instance_methods.include?(fullname)
+      return unless public_method_defined?(name)
+      @@thread_safe_instance_methods << fullname
+      orig_method = instance_method(name)
+      undef_method(name)
+
+      define_method(name) do |*args|
+        synchronize { orig_method.bind(self).call(*args) }
+      end
+
+      public(name)
+    end
+  end
+end

data/lib/easysuite/version.rb

@@ -0,0 +1,3 @@
+module EasySuite
+  VERSION = "1.2.1"
+end

data/lib/easysuite.rb

@@ -0,0 +1,73 @@
+raise "REQUIREMENTS: Ruby 1.9.3 or later." if (RUBY_VERSION < '1.9.3')
+require "easysuite/version"
+require "easysuite/config"
+require "easysuite/lock"
+require "easysuite/logger"
+require "easysuite/smtp"
+require "easysuite/thread"
+
+#--
+# File
+#++
+# Redefine some methods.
+class File
+  class << self
+    # Replace File::ALT_SEPARATOR to File::SEPARATOR.
+    if ALT_SEPARATOR
+      [:dirname, :join].each do |method|
+        orig_method = instance_method(method)
+        undef_method(method)
+
+        define_method(method) do |*args|
+          orig_method.bind(self).call(*args).gsub(ALT_SEPARATOR, SEPARATOR)
+        end
+      end
+    end
+  end
+end
+
+#--
+# UseEasyLogger
+#++
+# Module to use EasySuite::Logger#puts.
+module UseEasyLogger
+  #--
+  # puts
+  #++
+  def puts(*args)
+    if @logger.kind_of?(EasySuite::Logger)
+      @logger.puts(*args) rescue nil
+    end
+
+    super
+  end
+end
+
+#--
+# Enumerable
+#++
+# Add method.
+module Enumerable
+  #--
+  # peach
+  #++
+  # Parallel each method.
+  # Each block is run on worker threads.
+  #
+  # [pool_size]
+  #   Maximum size of worker threads.(default: 2)
+  #   If the value is not positive, there is no limit.
+  def peach(pool_size = 2)
+    if block_given?
+      pool = EasySuite::ThreadPool.new(pool_size)
+
+      self.each do |args|
+        pool.execute { yield(args) }
+      end
+
+      pool.shutdown
+    else
+      self.each
+    end
+  end
+end

data/sample/common.rb

@@ -0,0 +1,3 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'easytools'

data/sample/easytools.rb

@@ -0,0 +1,57 @@
+require 'easysuite'
+
+#
+# Tools for EasySuite
+#
+module EasyTools
+  class << self
+    #
+    # get home directory path
+    #
+    def home_dir
+      @home_dir ||= File.expand_path("../..", __FILE__)
+    end
+
+    #
+    # create instance
+    #
+    def create(key)
+      case(key)
+      when :config
+        EasySuite::Config.new(EasyTools.config_dir)
+      when :lock
+        EasySuite::Lock.new(EasyTools.tmp_dir)
+      when :logger
+        EasySuite::Logger.new(EasyTools.log_dir, "%Y-%m-%d.log")
+      when :smtp
+        EasySuite::SMTP.new
+      end
+    end
+
+    #
+    # method_missing
+    #
+    def method_missing(name, *args)
+      # get sub directory path
+      if (name.to_s =~ /^(.+)_dir$/)
+        return File.join(self.home_dir, $1)
+      end
+
+      # default
+      super
+    end
+
+    #
+    # respond_to?
+    #
+    def respond_to?(name, include_private = false)
+      # get sub directory path
+      if (name.to_s =~ /^(.+)_dir$/)
+        return true
+      end
+
+      # default
+      super
+    end
+  end
+end

data/sample/sample.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../common.rb', __FILE__)
+
+if __FILE__ == $0
+  puts "Hello, World!"
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: easysuite
+version: !ruby/object:Gem::Version
+  version: 1.2.1
+platform: ruby
+authors:
+- Masafumi Kiribayashi
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-07-18 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+executables:
+- easysuite
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- exe/easysuite
+- lib/easysuite.rb
+- lib/easysuite/config.rb
+- lib/easysuite/lock.rb
+- lib/easysuite/logger.rb
+- lib/easysuite/smtp.rb
+- lib/easysuite/thread.rb
+- lib/easysuite/version.rb
+- sample/common.rb
+- sample/easytools.rb
+- sample/sample.rb
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Programming for easygoing.
+test_files: []