benry-config 0.1.0 → 0.2.0

data/lib/benry/config.rb

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 
 ###
-### $Release: 0.1.0 $
-### $Copyright: copyright(c) 2016 kuwata-lab.com all rights reserved $
+### $Release: 0.2.0 $
+### $Copyright: copyright(c) 2016 kwatch@gmail.com $
 ### $License: MIT License $
 ###
 
@@ -14,69 +14,62 @@ module Benry
   end
 
 
-  ##
-  ## Configuration class.
-  ##
-  ## ex:
-  ##
-  ##     #----- config/common.rb -----
-  ##     require 'benry/config'
-  ##     class CommonConfig < Benry::BaseConfig
-  ##       add :db_user            , "user1"
-  ##       add :db_pass            , ABSTRACT
-  ##       add :session_cooie      , "SESS"
-  ##       add :session_secret     , SECRET
-  ##     end
-  ##
-  ##     #----- config/development.rb -----
-  ##     require 'config/common'
-  ##     class Config < TestCommonConfig
-  ##       set :db_pass            , "pass1"
-  ##     end
-  ##
-  ##     #----- config/development.private -----
-  ##     class Config
-  ##       set :session_secret     , "abc123"
-  ##     end
-  ##
-  ##     #----- main.rb -----
-  ##     rack_env = ENV['RACK_ENV']  or raise "$RACK_ENV required."
-  ##     require "./config/#{rack_env}.rb"
-  ##     load    "./config/#{rack_env}.private"
-  ##     #
-  ##     $config = Config.new.freeze
-  ##     p $config.db_user             #=> "user1"
-  ##     p $config.db_pass             #=> "pass1"
-  ##     p $config.session_cookie      #=> "SESS"
-  ##     p $config.session_secret      #=> "abc123"
-  ##     #
-  ##     p $config.get_all(:db_)       #=> {:user=>"user1", :pass=>"pass1"}
-  ##     p $config.get_all(:session_)  #=> {:cookie=>"SESS", :secret=>"abc123"}
-  ##
-  class BaseConfig
+  class Config
 
     class AbstractValue
+
+      def initialize(envvar=nil)
+        #; [!6hcf9] accepts environment variable name.
+        @envvar = envvar
+      end
+
+      attr_reader :envvar
+
+      def [](envvar)
+        #; [!p0acp] returns new object with environment variable name.
+        return self.class.new(envvar)
+      end
+
+    end
+
+    class SecretValue < AbstractValue
     end
 
     ABSTRACT = AbstractValue.new  # represents 'should be set in subclass'
-    SECRET   = AbstractValue.new  # represents 'should be set in private config file'
+    SECRET   = SecretValue.new    # represents 'should be set in private config file'
 
     def initialize
       #; [!7rdq4] traverses parent class and gathers config values.
-      pr = proc {|cls|
-        pr.call(cls.superclass) if cls.superclass
-        d = cls.instance_variable_get('@__dict')
-        d.each {|k, v| instance_variable_set("@#{k}", v) } if d
-      }
-      pr.call(self.class)
-      #; [!z9mno] raises ConfigError when ABSTRACT or SECRET is not overriden.
+      _traverse(self.class) {|k, v| instance_variable_set("@#{k}", v) }
       instance_variables().each do |ivar|
         val = instance_variable_get(ivar)
-        ! val.is_a?(AbstractValue)  or
+        next unless val.is_a?(AbstractValue)
+        #; [!v9f3k] when envvar name not specified...
+        if val.envvar == nil
+          #; [!z9mno] raises ConfigError if ABSTRACT or SECRET is not overriden.
           raise ConfigError.new("config ':#{ivar.to_s[1..-1]}' should be set, but not.")
+        #; [!ida3r] when envvar name specified...
+        else
+          #; [!txl88] raises ConfigError when envvar not set.
+          envvar = val.envvar
+          begin
+            val = ENV.fetch(envvar.to_s)
+          rescue KeyError
+            raise ConfigError.new("environment variable '$#{envvar}' should be set for config item ':#{ivar.to_s[1..-1]}'.")
+          end
+          #; [!y47ul] sets envvar value as config value if envvar provided.
+          instance_variable_set(ivar, val)
+        end
       end
     end
 
+    def _traverse(cls, &b)
+      _traverse(cls.superclass, &b) if cls.superclass && cls.superclass < BaseConfig
+      dict = cls.instance_variable_get(:@__dict)
+      dict.each(&b) if dict
+    end
+    private :_traverse
+
     ## Add new config. Raises ConfigError when already defined.
     def self.add(key, value, desc=nil)
       #; [!m7w96] raises ConfigError when already added.
@@ -134,7 +127,56 @@ module Benry
       return d
     end
 
+    def defined?(key)
+      #; [!y1fsh] returns true if config key defined.
+      #; [!k1b5q] returns false if config key not defined.
+      return instance_variable_defined?("@#{key}")
+    end
+
+    def each(sort=false, &b)
+      #; [!f4ljv] returns Enumerator object if block not given.
+      return to_enum(:each, sort) unless block_given?()
+      #; [!4wqpu] yields each key and val with hiding secret values.
+      #; [!a9glw] sorts keys if 'true' specified as the first argument.
+      _each(sort, true, &b)
+      #; [!wggik] returns self if block given.
+      return self
+    end
+
+    def each!(sort=false, &b)
+      #; [!zd9lk] returns Enumerator object if block not given.
+      return to_enum(:each!, sort) unless block_given?()
+      #; [!7i5p2] yields each key and val without hiding secret values.
+      #; [!aib7c] sorts keys if 'true' specified as the first argument.
+      _each(sort, false, &b)
+      #; [!2abgb] returns self if block given.
+      return self
+    end
+
+    private
+
+    def _each(sort, hide_secret, &b)
+      keys_d    = {}
+      secrets_d = {}
+      _traverse(self.class) do |key, val|
+        keys_d[key]    = true
+        secrets_d[key] = val if val.is_a?(SecretValue)
+      end
+      #; [!6yvgd] sorts keys if 'sort' is true.
+      keys = keys_d.keys()
+      keys.sort!() if sort
+      keys.each do |key|
+        #; [!5ledb] hides value if 'hide_secret' is true and value is Secretvalue object.
+        hide_p = hide_secret && secrets_d.key?(key)
+        val = hide_p ? "(secret)" : instance_variable_get("@#{key}".intern)
+        yield key, val
+      end
+    end
+
   end
 
 
+  BaseConfig = Config   # for backward compatibility
+
+
 end

data/task/common-task.rb

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+
+
+defined? PROJECT    or abort "PROJECT required."
+defined? RELEASE    or abort "RELEASE required."
+defined? COPYRIGHT  or abort "COPYRIGHT required."
+defined? LICENSE    or abort "LICENSE required."
+
+RELEASE =~ /\A\d+\.\d+\.\d+/  or abort "RELEASE=#{RELEASE}: invalid release number."
+
+
+require 'rake/clean'
+CLEAN << "build"
+CLEAN.concat Dir.glob("#{PROJECT}-*.gem").collect {|x| x.sub(/\.gem$/, '') }
+CLOBBER.concat Dir.glob("#{PROJECT}-*.gem")
+
+
+task :default do
+  sh "rake -T", verbose: false
+end unless Rake::Task.task_defined?(:default)
+
+
+desc "show release guide"
+task :guide do
+  do_guide()
+end
+
+def do_guide()
+  RELEASE != '0.0.0'  or abort "** ERROR: 'RELEASE=X.X.X' required."
+  puts guide_message(PROJECT, RELEASE)
+end
+
+def guide_message(project, release)
+  target = "#{project}-#{release}"
+  tag    = "#{project}-#{release}"
+  puts <<END
+How to release:
+
+  $ git diff .
+  $ git status .
+  $ which ruby
+  $ rake test
+  $ rake test:all
+  $ rake doc
+  $ rake doc:export RELEASE=#{release}
+  $ rake readme:execute			# optional
+  $ rake readme:toc			# optional
+  $ rake package RELEASE=#{release}
+  $ rake package:extract		# confirm files in gem file
+  $ (cd #{target}/data; find . -type f)
+  $ gem install #{target}.gem	# confirm gem package
+  $ gem uninstall #{project}
+  $ gem push #{target}.gem	# publish gem to rubygems.org
+  $ git tag #{tag}		# or: git tag ruby-#{tag}
+  $ git push --tags
+  $ rake clean
+  $ mv #{target}.gem archive/
+  $ cd ../docs/
+  $ git add #{target}.html
+  $ git commit -m "[main] docs: update '#{target}.html'"
+  $ git push
+END
+end
+
+
+desc "create 'README.md' and 'doc/*.html'"
+task :doc do
+  x = PROJECT
+  cd "doc" do
+    sh "../../docs/md2 --md #{x}.mdx > ../README.md"
+    sh "../../docs/md2 #{x}.mdx > #{x}.html"
+  end
+end
+
+desc "copy 'doc/*.html' to '../docs/'"
+task 'doc:export' do
+  RELEASE != '0.0.0'  or abort "** ERROR: 'RELEASE=X.X.X' required."
+  x = PROJECT
+  cp "doc/#{x}.html", "../docs/"
+  edit_file!("../docs/#{x}.html")
+end
+
+
+desc "edit metadata in files"
+task :edit do
+  do_edit()
+end
+
+def do_edit()
+  target_files().each do |fname|
+    edit_file!(fname)
+  end
+end
+
+def target_files()
+  $_target_files ||= begin
+    spec_src = File.read("#{PROJECT}.gemspec", encoding: 'utf-8')
+    spec = eval spec_src
+    spec.name == PROJECT  or
+      abort "** ERROR: '#{PROJECT}' != '#{spec.name}' (project name in gemspec file)"
+    spec.files + Dir.glob("doc/*.mdx")
+  end
+  return $_target_files
+end
+
+def edit_file!(filename, verbose: true)
+  changed = edit_file(filename) do |s|
+    s = s.gsub(/\$Release[:].*?\$/,   "$"+"Release: #{RELEASE} $")
+    s = s.gsub(/\$Copyright[:].*?\$/, "$"+"Copyright: #{COPYRIGHT} $")
+    s = s.gsub(/\$License[:].*?\$/,   "$"+"License: #{LICENSE} $")
+    s
+  end
+  if verbose
+    puts "[C] #{filename}"     if changed
+    puts "[U] #{filename}" unless changed
+  end
+  return changed
+end
+
+def edit_file(filename)
+  File.open(filename, 'rb+') do |f|
+    s1 = f.read()
+    s2 = yield s1
+    if s1 != s2
+      f.rewind()
+      f.truncate(0)
+      f.write(s2)
+      true
+    else
+      false
+    end
+  end
+end
+
+
+desc nil
+task :'relink' do
+  Dir.glob("task/*.rb").each do |x|
+    src = "../" + x
+    next if File.identical?(src, x)
+    rm x
+    ln src, x
+  end
+end

data/task/package-task.rb

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+
+
+desc "create package (*.gem)"
+task :package do
+  do_package()
+end
+
+def do_package()
+  RELEASE != '0.0.0'  or abort "** ERROR: 'RELEASE=X.X.X' required."
+  ## copy
+  dir = "build"
+  rm_rf dir if File.exist?(dir)
+  mkdir dir
+  target_files().each do |file|
+    dest = File.join(dir, File.dirname(file))
+    mkdir_p dest, :verbose=>false unless File.exist?(dest)
+    cp file, "#{dir}/#{file}"
+  end
+  ## edit
+  Dir.glob("#{dir}/**/*").each do |file|
+    next unless File.file?(file)
+    edit_file!(file, verbose: false)
+  end
+  ## build
+  chdir dir do
+    sh "gem build #{PROJECT}.gemspec"
+  end
+  mv "#{dir}/#{PROJECT}-#{RELEASE}.gem", "."
+  rm_rf dir
+end
+
+
+desc "extract latest gem file"
+task :'package:extract' do
+  do_package_extract()
+end
+
+def do_package_extract()
+  gemfile = Dir.glob("#{PROJECT}-*.gem").sort_by {|x| File.mtime(x) }.last
+  dir = gemfile.sub(/\.gem$/, '')
+  rm_rf dir if File.exist?(dir)
+  mkdir dir
+  mkdir "#{dir}/data"
+  cd dir do
+    sh "tar xvf ../#{gemfile}"
+    sh "gunzip *.gz"
+    cd "data" do
+      sh "tar xvf ../data.tar"
+    end
+  end
+end
+
+
+desc "upload gem file to rubygems.org"
+task :publish do
+  do_publish()
+end
+
+def do_publish()
+  RELEASE != '0.0.0'  or abort "** ERROR: 'RELEASE=X.X.X' required."
+  gemfile = "#{PROJECT}-#{RELEASE}.gem"
+  print "** Are you sure to publish #{gemfile}? [y/N]: "
+  answer = $stdin.gets().strip()
+  if answer.downcase == "y"
+    sh "gem push #{gemfile}"
+    #sh "git tag ruby-#{PROJECT}-#{RELEASE}"
+    sh "git tag #{PROJECT}-#{RELEASE}"
+    sh "#git push"
+    sh "#git push --tags"
+  end
+end

data/task/readme-task.rb

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+
+README_FILE      = "README.md"       unless defined? README_FILE
+README_EXTRACT   = /^[Ff]ile: +(\S+)/ unless defined? README_EXTRACT
+README_CODESTART = /^```\w+$/        unless defined? README_CODESTART
+README_CODEEND   = /^```$/           unless defined? README_CODEEND
+README_DESTDIR   = "tmp/readme"      unless defined? README_DESTDIR
+
+require 'rake/clean'
+CLEAN << "README.html"
+
+
+def readme_extract_callback(filename, str)
+  return str
+end
+
+
+namespace :readme do
+
+
+  desc "retrieve scripts from #{README_FILE}"
+  task :retrieve do
+    do_readme_retrieve()
+  end
+
+  def do_readme_retrieve()
+    dir = README_DESTDIR
+    rm_rf dir if File.exist?(dir)
+    mkdir_p dir
+    s = File.read(README_FILE, encoding: 'utf-8')
+    filename = nil
+    buf = nil
+    s.each_line do |line|
+      case line
+      when README_EXTRACT
+        filename = $1
+        next
+      when README_CODESTART
+        if filename
+          buf = []
+        end
+        next
+      when README_CODEEND
+        if filename && buf
+          newfile = "#{dir}/#{filename}"
+          unless File.exist?(File.dirname(newfile))
+            mkdir_p File.dirname(newfile)
+          end
+          str = readme_extract_callback(filename, buf.join())
+          File.write(newfile, str, encoding: 'utf-8')
+          puts "[retrieve] #{newfile}"
+        end
+        filename = nil
+        buf = nil
+        next
+      end
+      #
+      if buf
+        buf << line
+      end
+    end
+  end
+
+
+  desc "execute code in readme file"
+  task :execute => :retrieve do
+    do_readme_execute()
+  end
+
+  def do_readme_execute()
+    Dir.glob(README_DESTDIR+'/**/*.rb').sort.each do |fpath|
+      puts "========================================"
+      sh "ruby -I lib #{fpath}" do end
+    end
+  end
+
+
+  desc "builds table of contents"
+  task :toc do
+    do_readme_toc()
+  end
+
+  def do_readme_toc()
+    url = ENV['README_URL']  or abort "$README_URL required."
+    mkdir "tmp" unless Dir.exist?("tmp")
+    htmlfile = "tmp/README.html"
+    sh "curl -s -o #{htmlfile} #{url}"
+    #rexp = /<h(\d) dir="auto"><a id="(.*?)" class="anchor".*><\/a>(.*)<\/h\1>/
+    rexp = /<h(\d) id="user-content-.*?" dir="auto"><a class="heading-link" href="#(.*?)">(.*)<svg/
+    html_str = File.read(htmlfile, encoding: 'utf-8')
+    buf = []
+    html_str.scan(rexp) do
+      level = $1.to_i
+      id = $2
+      title = $3
+      next if title =~ /Table of Contents/
+      title = title.gsub(/<\/?code>/, '`')
+      anchor = id.sub(/^user-content-/, '')
+      indent = "  " * (level - 1)
+      buf << "#{indent}* <a href=\"##{anchor}\">#{title}</a>\n"
+    end
+    buf.shift() if buf[0] && buf[0] =~ /^\* /
+    toc_str = buf.join()
+    #
+    mdfile = README_FILE
+    changed = File.open(mdfile, "r+", encoding: 'utf-8') do |f|
+      s1 = f.read()
+      s2 = s1.sub(/(<!-- TOC -->\n).*(<!-- \/TOC -->\n)/m) {
+        [$1, toc_str, $2].join("\n")
+      }
+      if s1 != s2
+        f.rewind()
+        f.truncate(0)
+        f.write(s2)
+        true
+      else
+        false
+      end
+    end
+    puts "[changed] #{mdfile}"          if changed
+    puts "[not changed] #{mdfile}"  unless changed
+  end
+
+
+end

data/task/test-task.rb

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+
+
+unless defined?(RUBY_VERSIONS)
+  RUBY_VERSIONS = (
+    if ENV['RUBY_VERSIONS']
+      ENV['RUBY_VERSIONS'].split()
+    else
+      ["3.2", "3.1", "3.0", "2.7", "2.6", "2.5", "2.4", "2.3"]
+    end
+  )
+end
+
+
+desc "run test"
+task :test do
+  do_test()
+end
+
+def do_test()
+  run_test()
+end
+
+def run_test(ruby=nil, &b)
+  run_oktest(ruby, &b)
+end
+
+def run_minitest(ruby=nil, &b)
+  files = File.exist?("test/run_all.rb") \
+          ? ["test/run_all.rb"] \
+          : Dir.glob("test/**/*_test.rb")
+  if ruby
+    sh(ruby, *files, &b)
+  else
+    ruby(*files, &b)
+  end
+end
+
+def run_oktest(ruby=nil, &b)
+  argstr = "-r oktest -e Oktest.main -- test -sp"
+  if ruby
+    sh("#{ruby} #{argstr}", &b)
+  else
+    ruby(argstr, &b)
+  end
+end
+
+
+desc "run test in different ruby versions"
+task :'test:all' do
+  do_test_all()
+end
+
+def do_test_all()
+  ENV['VS_HOME']  or
+    abort "[ERROR] rake test:all: '$VS_HOME' environment var required."
+  vs_home = ENV['VS_HOME'].split(/[:;]/).first
+  ruby_versions = RUBY_VERSIONS
+  test_all(vs_home, ruby_versions)
+end
+
+def test_all(vs_home, ruby_versions)
+  header = proc {|s| "\033[0;36m=============== #{s} ===============\033[0m" }
+  error  = proc {|s| "\033[0;31m** #{s}\033[0m" }
+  comp   = proc {|x, y| x.to_s.split('.').map(&:to_i) <=> y.to_s.split('.').map(&:to_i) }
+  ruby_versions.each do |ver|
+    dir = Dir.glob("#{vs_home}/ruby/#{ver}.*/").sort_by(&comp).last
+    puts ""
+    if dir
+      puts header.("#{ver} (#{dir})")
+      run_test("#{dir}/bin/ruby") do |ok, res|
+        $stderr.puts error.("test failed") unless ok
+      end
+      sleep 0.2
+    else
+      puts header.(ver)
+      $stderr.puts error.("ruby #{ver} not found")
+      sleep 1.0
+    end
+  end
+end