xot 0.1.21 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f77c894412ab67f7e6b9859e907eedf0f391335c90e82ec8010f166d7dfb844f
-  data.tar.gz: 26308967ff7d5b66b73066867b0eec0a7f688d7992802ebc62f636e48b5ecb5e
+  metadata.gz: eabd6145d88568b824890e37239195d443c6f0f0d45d8aac09aefbf5950307dc
+  data.tar.gz: 02775f8af00f140f99b64a7d03b204e78046548bb81c86b062bf26f9bdef5de3
 SHA512:
-  metadata.gz: 394093cf97d126818caf660c7cfbe73f3d61808773ce292285276804f5c29b60e7891f6bf93465c74cb921ce91dd049116bf860fd96a26c05cee48e689e231f2
-  data.tar.gz: 4b624853ee62ab0f6b7a606535d8606d087eb049d4cdc38c8e418e78f5c36f98f0be08e2b80705ad5fdd2111c2f5a0ee3d7aaa5294cbb88ffd1823a4c4751d38
+  metadata.gz: 0e53581d9a9ffc5aad90afe7fbe45a1460119b9de0e67a819da1351bd856585c29345f5d925a3fd5ec12853fecd2509173a6aa1a12fbf6d91225548348d603c9
+  data.tar.gz: a7d4934ff11e7d730611f35829a4033ac56bf31eb76adeb96ddc323b2074ebb5ce15e9959a62d78207704ef3537ca0148f83e1f1e364f2337e91fcf174564dfd

data/VERSION

@@ -1 +1 @@
-0.1.21
+0.1.22

data/lib/xot/bit_flag.rb

@@ -13,13 +13,13 @@ module Xot
 
     alias make_bit bit
 
-    def initialize (auto: false, none: 0, **flags, &block)
+    def initialize(auto: false, none: 0, **flags, &block)
       @bit2sym, @sym2bit, @auto, @next = {}, {none: none, no: none}, auto, 1
       flags.each {|sym, value| flag sym, value}
       BlockUtil.instance_eval_or_block_call self, &block if block
     end
 
-    def flag (symbol, value = nil, bit: nil)
+    def flag(symbol, value = nil, bit: nil)
       bit = value || make_bit(bit) || (@auto ? @next : nil)
 
       raise ArgumentError if !bit
@@ -35,7 +35,7 @@ module Xot
       bit
     end
 
-    def bits2symbols (bits)
+    def bits2symbols(bits)
       array = []
       bits.to_s(2).reverse.each_char.with_index do |char, index|
         next unless char == '1'
@@ -46,13 +46,13 @@ module Xot
       array
     end
 
-    def symbols2bits (*symbols)
+    def symbols2bits(*symbols)
       symbols.flatten.reduce(0) {|value, symbol| value | sym2bit(symbol)}
     end
 
     private
 
-      def sym2bit (symbol)
+      def sym2bit(symbol)
         bit = @sym2bit[symbol]
         bit = flag symbol if !bit && @auto
         raise "unknown symbol #{symbol.inspect} for flag." unless bit

data/lib/xot/bit_flag_accessor.rb

@@ -10,24 +10,24 @@ module Xot
 
   module BitFlagAccessor
 
-    def bit_flag_accessor (name, bit_flag = nil, **flags, &block)
+    def bit_flag_accessor(name, bit_flag = nil, **flags, &block)
       bf = define_bit_flag name, bit_flag, flags, block
       define_bit_flag_writer name, bf
       define_bit_flag_reader name, bf
     end
 
-    def bit_flag_writer (name, bit_flag = nil, **flags, &block)
+    def bit_flag_writer(name, bit_flag = nil, **flags, &block)
       define_bit_flag_writer name, define_bit_flag(name, bit_flag, flags, block)
     end
 
-    def bit_flag_reader (name, bit_flag = nil, **flags, &block)
+    def bit_flag_reader(name, bit_flag = nil, **flags, &block)
       define_bit_flag_reader name, define_bit_flag(name, bit_flag, flags, block)
     end
 
     private
 
-      def define_bit_flag (name, bit_flag, flags, block)
-        bit_flag ||= Xot::BitFlag.new **flags
+      def define_bit_flag(name, bit_flag, flags, block)
+        bit_flag ||= Xot::BitFlag.new(**flags)
         Xot::BlockUtil.instance_eval_or_block_call bit_flag, &block if block
 
         define_singleton_method "#{name}_flag".intern do
@@ -37,7 +37,7 @@ module Xot
         bit_flag
       end
 
-      def define_bit_flag_writer (name, bit_flag)
+      def define_bit_flag_writer(name, bit_flag)
         writer = "#{name}=".intern
         setter = "bf_set_#{name}__".intern
 
@@ -51,7 +51,7 @@ module Xot
         name
       end
 
-      def define_bit_flag_reader (name, bit_flag)
+      def define_bit_flag_reader(name, bit_flag)
         reader = name.intern
         getter = "bf_get_#{name}__".intern
 

data/lib/xot/bit_util.rb

@@ -8,7 +8,7 @@ module Xot
 
     module_function
 
-    def bit (*bits)
+    def bit(*bits)
       return nil if bits.compact.empty?
       bits.reduce(0) {|value, nth| value | (0x1 << nth)}
     end

data/lib/xot/block_util.rb

@@ -6,9 +6,9 @@ module Xot
 
   module BlockUtil
 
-    def instance_eval_or_block_call (recv, *args, &block)
+    def instance_eval_or_block_call(recv, *args, &block)
       if block.arity == 0
-        recv.instance_eval &block
+        recv.instance_eval(&block)
       else
         block.call recv, *args
       end

data/lib/xot/const_symbol_accessor.rb

@@ -6,12 +6,12 @@ module Xot
 
   module ConstSymbolAccessor
 
-    def const_symbol_accessor (name, **symbol2const)
+    def const_symbol_accessor(name, **symbol2const)
       const_symbol_writer name, **symbol2const
       const_symbol_reader name, **symbol2const
     end
 
-    def const_symbol_writer (name, **symbol2const)
+    def const_symbol_writer(name, **symbol2const)
       writer = "#{name}=".intern
       setter = "cs_set_#{name}__".intern
 
@@ -27,7 +27,7 @@ module Xot
       name
     end
 
-    def const_symbol_reader (name, **symbol2const)
+    def const_symbol_reader(name, **symbol2const)
       reader = name.intern
       getter = "cs_get_#{name}__".intern
 

data/lib/xot/extconf.rb

@@ -14,18 +14,18 @@ module Xot
 
     attr_reader :modules, :defs, :inc_dirs, :lib_dirs, :headers, :libs, :local_libs, :frameworks
 
-    def initialize (*modules, &block)
+    def initialize(*modules, &block)
       @modules = modules.map {|m| m.const_get :Module}
       @defs, @inc_dirs, @lib_dirs, @headers, @libs, @local_libs, @frameworks =
-        ([[]] * 7).map &:dup
+        ([[]] * 7).map(&:dup)
       Xot::BlockUtil.instance_eval_or_block_call self, &block if block
     end
 
-    def debug ()
+    def debug()
       env :DEBUG, false
     end
 
-    def setup ()
+    def setup()
       yield if block_given?
 
       modules.each do |m|
@@ -43,7 +43,7 @@ module Xot
       $LOCAL_LIBS << local_libs.map {|s| " -l#{s}"}.join
     end
 
-    def create_makefile (*args)
+    def create_makefile(*args)
       modules.each do |m|
         dir_config m.name.downcase, m.inc_dir, m.lib_dir
       end

data/lib/xot/hookable.rb

@@ -6,28 +6,28 @@ module Xot
 
   module Hookable
 
-    def hook (name, &block)
+    def hook(name, &block)
       c = class << self; self; end
       c.__send__ :define_method, name, &block
       self
     end
 
-    def on (name, &block)
+    def on(name, &block)
       hook name do |*a, &b|
-        block.call *a, &b
+        block.call(*a, &b)
       end
     end
 
-    def before (name, &block)
+    def before(name, &block)
       hook name do |*a, &b|
-        super *a, &b unless block.call(*a, &b) == :skip
+        super(*a, &b) unless block.call(*a, &b) == :skip
       end
     end
 
-    def after (name, &block)
+    def after(name, &block)
       hook name do |*a, &b|
-        ret = super *a, &b
-        block.call *a, &b
+        ret = super(*a, &b)
+        block.call(*a, &b)
         ret
       end
     end

data/lib/xot/invoker.rb

@@ -9,10 +9,10 @@ module Xot
 
   module Invoker
 
-    def initialize ()
+    def initialize()
     end
 
-    def handlers (create = false)
+    def handlers(create = false)
       if create
         @handlers ||= []
       else
@@ -20,18 +20,18 @@ module Xot
       end
     end
 
-    def add_handler (handler)
+    def add_handler(handler)
       return unless handler
       a = self.handlers true
       a.push handler unless a.include? handler
     end
 
-    def remove_handler (handler)
+    def remove_handler(handler)
       return unless handler
       self.handlers.delete handler
     end
 
-    def invoke (name, attributes = {}, options = {})
+    def invoke(name, attributes = {}, options = {})
       only     = options[:only]
       only     = [only] if only && !only.kind_of?(Array)
       handlers = only ? only : @handlers

data/lib/xot/module.rb

@@ -8,23 +8,23 @@ module Xot
 
     module_function
 
-    def name ()
+    def name()
       super.split('::')[-2]
     end
 
-    def version ()
+    def version()
       open(root_dir 'VERSION') {|f| f.readline.chomp}
     end
 
-    def root_dir (path = '')
+    def root_dir(path = '')
       File.expand_path "../../#{path}", __dir__
     end
 
-    def inc_dir ()
+    def inc_dir()
       root_dir 'include'
     end
 
-    def lib_dir ()
+    def lib_dir()
       root_dir 'lib'
     end
 

data/lib/xot/rake.rb

@@ -15,7 +15,7 @@ module Xot
   module Rake
 
 
-    def srcs_map ()
+    def srcs_map()
       paths = glob("#{src_dir}/**/*.{#{src_exts.join ','}}") +
         erbs_map.values.grep(/\.(#{src_exts.join '|'})$/)
       paths.reject! {|path| excluded? path}
@@ -25,36 +25,36 @@ module Xot
       make_path_map paths, src_ext_map
     end
 
-    def erbs_map ()
-      paths = glob *[inc_dir, src_dir].map {|s| "#{s}/**/*.erb"}
+    def erbs_map()
+      paths = glob(*[inc_dir, src_dir].map {|s| "#{s}/**/*.erb"})
       paths.reject! {|path| excluded? path}
       make_path_map paths, {".erb" => ""}
     end
 
-    def vendor_srcs_map (*dirs)
+    def vendor_srcs_map(*dirs)
       dirs  = src_dirs if dirs.empty?
       paths = dirs.map {|dir| glob "#{dir}/**/*.{#{src_exts.join ','}}"}.flatten
       paths.reject! {|path| excluded? path}
       make_path_map paths.flatten, src_ext_map
     end
 
-    def src_ext_map (to = '.o')
+    def src_ext_map(to = '.o')
       Hash[*src_exts.map {|ext| [".#{ext}", to]}.flatten]
     end
 
-    def defs ()
+    def defs()
       env_array :DEFS, []
     end
 
-    def test_alones ()
+    def test_alones()
       env :TESTS_ALONE, []
     end
 
-    def test_excludes ()
+    def test_excludes()
       env :TESTS_EXCLUDE, []
     end
 
-    def build_native_library ()
+    def build_native_library()
       outname = "lib#{target_name}.a"
       out     = File.join lib_dir, outname
       erbs    = erbs_map
@@ -114,7 +114,7 @@ module Xot
       end
     end
 
-    def build_ruby_extension (dlname: 'native', dlext: 'so')
+    def build_ruby_extension(dlname: 'native', dlext: 'so')
       dlname = env :DLNAME, dlname
       dlext  = env :DLEXT,  RbConfig::CONFIG['DLEXT'] || dlext
 
@@ -169,7 +169,7 @@ module Xot
       end
     end
 
-    def test_ruby_extension ()
+    def test_ruby_extension()
       alias_task :test => [:ext, 'test:full', 'test:alones']
 
       namespace :test do
@@ -188,7 +188,7 @@ module Xot
       end
     end
 
-    def build_ruby_gem ()
+    def build_ruby_gem()
       gemspec = "#{target_name}.gemspec"
       gemname = env :GEMNAME,    target_name
       gemver  = env :GEMVERSION, target.version
@@ -229,7 +229,7 @@ module Xot
       end
     end
 
-    def build_application ()
+    def build_application()
       bindir    = env :BINDIR, 'bin'
       bin       = "#{bindir}/#{target_name}"
       appdir    = "#{target.name}.app"
@@ -257,7 +257,7 @@ module Xot
       end
     end
 
-    def use_external_library (
+    def use_external_library(
       repos, branch: nil, tag: nil,
       incdir: nil, srcdir: nil, excludes: [],
       submodules: [], post_submodules: nil)
@@ -312,7 +312,7 @@ module Xot
       end
     end
 
-    def use_boost_library (modules = [], branch: nil, tag: nil)
+    def use_boost_library(modules = [], branch: nil, tag: nil)
       default_modules = %w[tools/build libs/config]
       use_external_library 'https://github.com/boostorg/boost',
         branch:          branch,
@@ -322,7 +322,7 @@ module Xot
         post_submodules: './bootstrap.sh && ./b2 headers'
     end
 
-    def define_placeholder_tasks ()
+    def define_placeholder_tasks()
       desc "delete temporary files"
       alias_task :clean
 

data/lib/xot/rake/alias_task.rb

@@ -12,7 +12,7 @@ module Xot
 
     class AliasTask < ::Rake::Task
 
-      def timestamp ()
+      def timestamp()
         prerequisite_tasks.map {|pre| pre.timestamp}.max || ::Rake::EARLY
       end
 
@@ -27,8 +27,8 @@ end# Xot
 
 module Rake
   module DSL
-    def alias_task (*args, &block)
-      Xot::Rake::AliasTask.define_task *args, &block
+    def alias_task(*args, &block)
+      Xot::Rake::AliasTask.define_task(*args, &block)
     end
   end
 end

data/lib/xot/rake/escalation.rb

@@ -9,8 +9,8 @@ module Rake
 
     alias invoke_task_org invoke_task
 
-    def invoke_task (*args, &block)
-      invoke_task_org *args, &block
+    def invoke_task(*args, &block)
+      invoke_task_org(*args, &block)
     rescue RuntimeError => e
       if e.message =~ /don't\s+know\s+.*\s+task\s+/i
         escalate_tasks
@@ -19,7 +19,7 @@ module Rake
       end
     end
 
-    def escalate_tasks ()
+    def escalate_tasks()
       Dir.chdir '..' do
         cmd = "rake #{ARGV.join ' '}"
         $stderr.puts "(in #{Dir.pwd}) #{cmd}"

data/lib/xot/rake/util.rb

@@ -12,71 +12,71 @@ module Xot
 
     VERSION_NAME = 'VERSION'
 
-    def modules ()
+    def modules()
       env(:MODULES, []).map {|m| m::Module}
     end
 
-    def target ()
+    def target()
       modules.last
     end
 
-    def target_name ()
+    def target_name()
       env :MODNAME, target.name.downcase
     end
 
-    def inc_dir ()
+    def inc_dir()
       env :INCDIR, 'include'
     end
 
-    def src_dir ()
+    def src_dir()
       env :SRCDIR, 'src'
     end
 
-    def lib_dir ()
+    def lib_dir()
       env :LIBDIR, 'lib'
     end
 
-    def doc_dir ()
+    def doc_dir()
       env :DOCDIR, 'doc'
     end
 
-    def ext_dir ()
+    def ext_dir()
       env :EXTDIR, "ext/#{target_name}"
     end
 
-    def ext_lib_dir ()
+    def ext_lib_dir()
       env :EXTLIBDIR, "lib/#{target_name}"
     end
 
-    def test_dir ()
+    def test_dir()
       env :TESTDIR, 'test'
     end
 
-    def vendor_dir ()
+    def vendor_dir()
       env :VENDORDIR, 'vendor'
     end
 
-    def inc_dirs ()
+    def inc_dirs()
       env_array(:INCDIRS, []) + modules.reverse.map {|m| m.inc_dir}.flatten
     end
 
-    def src_dirs ()
+    def src_dirs()
       env_array :SRCDIRS, []
     end
 
-    def src_exts ()
+    def src_exts()
       env_array(:SRCEXTS, []) + %w[c cc cpp m mm]
     end
 
-    def excludes ()
+    def excludes()
       env_array :EXCLUDES, []
     end
 
-    def excluded? (path)
+    def excluded?(path)
       excludes.any? {|s| path =~ %r{#{s}}}
     end
 
-    def glob (*patterns)
+    def glob(*patterns)
       paths = []
       patterns.each do |pattern|
         paths.concat Dir.glob(pattern)
@@ -84,30 +84,30 @@ module Xot
       paths
     end
 
-    def filter_file (path, &block)
+    def filter_file(path, &block)
       File.write path, block.call(File.read path)
     end
 
-    def cd_sh (dir, cmd)
+    def cd_sh(dir, cmd)
       Dir.chdir dir do
         $stderr.puts "(in #{Dir.pwd})"
         sh cmd
       end
     end
 
-    def modified_files (dir: '.', hash: '@')
+    def modified_files(dir: '.', hash: '@')
       `git diff --name-only #{hash} -- #{dir}`.lines.map &:chomp
     end
 
-    def version_path (dir = nil)
+    def version_path(dir = nil)
       dir ? "#{dir}/#{VERSION_NAME}" : VERSION_NAME
     end
 
-    def get_version (dir = nil)
+    def get_version(dir = nil)
       File.readlines(version_path dir).first.chomp
     end
 
-    def bump_version (index, version = get_version)
+    def bump_version(index, version = get_version)
       nums         = version.split('.').map &:to_i
       nums        << 0 until nums.size > index
       nums[index] += 1
@@ -116,13 +116,13 @@ module Xot
       nums.join '.'
     end
 
-    def bump_version_file (index, dir: nil)
+    def bump_version_file(index, dir: nil)
       newver = bump_version index, get_version(dir)
       File.write version_path(dir), newver
       newver
     end
 
-    def update_and_tag_version (index, dir: nil, &block)
+    def update_and_tag_version(index, dir: nil, &block)
       raise 'modified files exist' unless modified_files.empty?
 
       message = ENV['message']
@@ -138,7 +138,7 @@ module Xot
       sh %( git tag -a -m "#{message}" v#{newver} )
     end
 
-    def compile_erb (path, out)
+    def compile_erb(path, out)
       open(path) do |input|
         open(out, 'w') do |output|
           output.write compile_erb_str(input.read)
@@ -147,20 +147,20 @@ module Xot
     #rescue
     end
 
-    def compile_erb_str (str)
+    def compile_erb_str(str)
       ERB.new(str, nil, '%').result binding
     end
 
-    def params (max, sep = '', &block)
+    def params(max, sep = '', &block)
       raise 'block not given.' unless block
       return '' if max == 0
       (1..max).map(&block).join(sep)
     end
 
-    def make_path_map (paths, ext_map)
+    def make_path_map(paths, ext_map)
       paths = paths.map do |path|
         newpath = ext_map.inject path do |value, (from, to)|
-          value.sub /#{from.gsub('.', '\.')}$/, to
+          value.sub(/#{from.gsub('.', '\.')}$/, to)
         end
         raise "map to same path" if path == newpath
         [path, newpath]
@@ -168,12 +168,12 @@ module Xot
       Hash[*paths.flatten]
     end
 
-    def get_env (name, defval = nil)
+    def get_env(name, defval = nil)
       val = ENV[name.to_s] || Object.const_get(name) rescue defval
       val.dup rescue val
     end
 
-    def env (name, defval = nil)
+    def env(name, defval = nil)
       case val = get_env(name, defval)
       when /^\d+$/        then val.to_i
       when 'true',  true  then true
@@ -183,24 +183,24 @@ module Xot
       end
     end
 
-    def env_array (name, defval = nil)
+    def env_array(name, defval = nil)
       val = get_env name, defval
       val = val.strip.split(/\s+/) if val.kind_of? String
       val
     end
 
-    def append_env (name, *args)
+    def append_env(name, *args)
       ENV[name] = (ENV[name] || '') + " #{args.join ' '}"
     end
 
-    def make_cppflags (flags = '', defs = [], incdirs = [])
+    def make_cppflags(flags = '', defs = [], incdirs = [])
       s  = flags.dup
       s += make_cppflags_defs(defs)      .map {|s| " -D#{s}"}.join
       s += make_cppflags_incdirs(incdirs).map {|s| " -I#{s}"}.join
       s
     end
 
-    def make_cppflags_defs (defs = [])
+    def make_cppflags_defs(defs = [])
       a  = defs.dup
       a << $~[0].upcase if RUBY_PLATFORM =~ /mswin|ming|cygwin|darwin/i
       a << (debug? ? '_DEBUG' : 'NDEBUG')
@@ -210,16 +210,16 @@ module Xot
       a
     end
 
-    def make_cppflags_incdirs (dirs = [])
+    def make_cppflags_incdirs(dirs = [])
       dirs.dup + ruby_inc_dirs
     end
 
-    def ruby_inc_dirs ()
+    def ruby_inc_dirs()
       root = RbConfig::CONFIG['rubyhdrdir']
       [root, RbConfig::CONFIG['rubyarchhdrdir'] || "#{root}/#{RUBY_PLATFORM}"]
     end
 
-    def make_cflags (flags = '')
+    def make_cflags(flags = '')
       warning_opts = %w[
         no-unknown-pragmas
         no-deprecated-register
@@ -230,76 +230,76 @@ module Xot
       s << ' -std=c++11'                                          if gcc?
       s << ' -std=c++11 -stdlib=libc++ -mmacosx-version-min=10.7' if clang?
       s << ' ' + RbConfig::CONFIG['debugflags']                   if debug?
-      s.gsub! /-O\d?\w*/, '-O0'                                   if debug?
+      s.gsub!(/-O\d?\w*/, '-O0')                                  if debug?
       s
     end
 
-    def make_ldflags (flags = '', libdirs = [], frameworks = [])
+    def make_ldflags(flags = '', libdirs = [], frameworks = [])
       s  = flags.dup
       s << libdirs.map    {|s| " -L#{s}"}.join
       s << frameworks.map {|s| " -framework #{s}"}.join
       s
     end
 
-    def debug (state)
+    def debug(state)
       ENV['DEBUG'] = state.to_s
     end
 
-    def debug? ()
+    def debug?()
       env :DEBUG, false
     end
 
-    def win32? ()
+    def win32?()
       RUBY_PLATFORM =~ /mswin|ming|cygwin/
     end
 
-    def mswin? ()
+    def mswin?()
       RUBY_PLATFORM =~ /mswin/
     end
 
-    def ming? ()
+    def ming?()
       RUBY_PLATFORM =~ /ming/
     end
 
-    def cygwin? ()
+    def cygwin?()
       RUBY_PLATFORM =~ /cygwin/
     end
 
-    def osx? ()
+    def osx?()
       RUBY_PLATFORM =~ /darwin/
     end
 
-    def ios? ()
+    def ios?()
       false
     end
 
-    def gcc? ()
+    def gcc?()
       RbConfig::CONFIG['CXX'] =~ /(^|\s)g\+\+/i
     end
 
-    def clang? ()
+    def clang?()
       RbConfig::CONFIG['CXX'] =~ /(^|\s)clang/i
     end
 
-    def cxx ()
+    def cxx()
       env :CXX, RbConfig::CONFIG['CXX'] || 'g++'
     end
 
-    def ar ()
+    def ar()
       env :AR, RbConfig::CONFIG['AR']  || 'ar'
     end
 
-    def cppflags ()
+    def cppflags()
       flags = env :CPPFLAGS, RbConfig::CONFIG['CPPFLAGS']
       make_cppflags flags, defs, inc_dirs
     end
 
-    def cxxflags ()
+    def cxxflags()
       flags = env :CXXFLAGS, RbConfig::CONFIG['CXXFLAGS']
       make_cflags flags
     end
 
-    def arflags ()
+    def arflags()
       env :ARFLAGS, RbConfig::CONFIG['ARFLAGS'] || 'crs'
     end
 

data/lib/xot/setter.rb

@@ -6,7 +6,7 @@ module Xot
 
   module Setter
 
-    def set (*args)
+    def set(*args)
       first = args.shift
       if first.kind_of? Hash
         first.each {|name, value| set_value__ name, value}
@@ -17,7 +17,7 @@ module Xot
 
     private
 
-      def set_value__ (name, *values)
+      def set_value__(name, *values)
         raise ArgumentError, "set '#{values}' to '#{name}'" if
           !name || name.empty? || values.empty?
         __send__ "#{name}=", *values

data/lib/xot/test.rb

@@ -6,11 +6,11 @@ module Xot
 
   module Test
 
-    def assert_not (expression, *args)
+    def assert_not(expression, *args)
       assert !expression, *args
     end
 
-    def assert_not_includes (collection, obj, *args)
+    def assert_not_includes(collection, obj, *args)
       assert !collection.include?(obj), *args
     end
 

data/lib/xot/universal_accessor.rb

@@ -6,22 +6,22 @@ module Xot
 
   module UniversalAccessor
 
-    def universal_accessor (*names, **names_with_options)
+    def universal_accessor(*names, **names_with_options)
       names.each              {|name|       define_universal_accessor name}
       names_with_options.each {|name, opts| define_universal_accessor name, opts}
     end
 
     private
 
-      def define_universal_accessor (name, options = {})
+      def define_universal_accessor(name, options = {})
         set = "ua_set_#{name}__"
         get = "ua_get_#{name}__"
         class_eval <<-END
           alias_method :#{set}, options[:writer] || :#{name}=
           alias_method :#{get}, options[:reader] || :#{name}
           private :#{set}, :#{get}
-          def #{name} (*args)
-            #{set} *args unless args.empty?
+          def #{name}(*args)
+            #{set}(*args) unless args.empty?
             #{get}
           end
         END

data/test/test_bit_flag.rb

@@ -8,8 +8,8 @@ class TestBitFlag < Test::Unit::TestCase
 
   include Xot::BitUtil
 
-  def flag (*args, &block)
-    bf = Xot::BitFlag.new *args, &block
+  def flag(*args, &block)
+    bf = Xot::BitFlag.new(*args, &block)
     bf.flag :bit1, bit(1)
     bf.flag :bit2, bit(2)
     bf.flag :bit3, bit(3)
@@ -18,7 +18,7 @@ class TestBitFlag < Test::Unit::TestCase
     bf
   end
 
-  def test_bits2symbols ()
+  def test_bits2symbols()
     assert_equal [], flag.bits2symbols(0)
     assert_equal [:bit1], flag.bits2symbols(bit 1)
     assert_equal [:bit2], flag.bits2symbols(bit 2)
@@ -34,7 +34,7 @@ class TestBitFlag < Test::Unit::TestCase
     assert_raise(RuntimeError) {flag.bits2symbols(bit 0, 1)}
   end
 
-  def test_symbols2bits ()
+  def test_symbols2bits()
     assert_equal bit(1), flag.symbols2bits(:bit1)
     assert_equal bit(2), flag.symbols2bits(:bit2)
     assert_equal bit(5), flag.symbols2bits(:bit5)

data/test/test_bit_flag_accessor.rb

@@ -12,7 +12,7 @@ class TestBitFlagAccessor < Test::Unit::TestCase
     attr_accessor :bits
     alias set bits=
     alias get bits
-    def initialize (&block)
+    def initialize(&block)
       @bits = 0
       block.call self if block
     end
@@ -25,38 +25,38 @@ class TestBitFlagAccessor < Test::Unit::TestCase
     end
   end
 
-  def int (&block)
-    IntAccessor.new &block
+  def int(&block)
+    IntAccessor.new(&block)
   end
 
-  def symbol (&block)
-    SymbolAccessor.new &block
+  def symbol(&block)
+    SymbolAccessor.new(&block)
   end
 
-  def flag ()
+  def flag()
     SymbolAccessor.bits_flag
   end
 
-  def test_int_accessor ()
+  def test_int_accessor()
     assert_equal 0b0,  int.get
     assert_equal 0b1,  int{|o| o.bits = bit 0}.get
     assert_equal 0b10, int{|o| o.bits = bit 1}.get
   end
 
-  def test_symbol_writer ()
+  def test_symbol_writer()
     assert_equal 0b0,  symbol.get
     assert_equal 0b1,  symbol{|o| o.bits = :bit0}.get
     assert_equal 0b10, symbol{|o| o.bits = :bit1}.get
   end
 
-  def test_symbol_reader ()
+  def test_symbol_reader()
     assert_equal [],             symbol.bits
     assert_equal [:bit0],        symbol{|o| o.set bit 0}.bits
     assert_equal [:bit1],        symbol{|o| o.set bit 1}.bits
     assert_equal [:bit0, :bit1], symbol{|o| o.set bit 0, 1}.bits
   end
 
-  def test_singleton_flag_reader ()
+  def test_singleton_flag_reader()
     assert_equal 0b11,           flag.symbols2bits(:bit0, :bit1)
     assert_equal [:bit0, :bit1], flag.bits2symbols(0b11)
   end

data/test/test_bit_util.rb

@@ -8,7 +8,7 @@ class TestBitUtil < Test::Unit::TestCase
 
   include Xot::BitUtil
 
-  def test_bit ()
+  def test_bit()
     assert_equal 0b1,    bit(0)
     assert_equal 0b10,   bit(1)
     assert_equal 0b1000, bit(3)

data/test/test_block_util.rb

@@ -14,11 +14,11 @@ class TestBlockUtil < Test::Unit::TestCase
 
   end# Temp
 
-  def temp (*args)
+  def temp(*args)
     Temp.new
   end
 
-  def test_instance_eval_or_block_call ()
+  def test_instance_eval_or_block_call()
     t = temp
     t.value = 1
 

data/test/test_const_symbol_accessor.rb

@@ -14,40 +14,40 @@ class TestConstSymbolAccessor < Test::Unit::TestCase
     attr_accessor :const
     alias set const=
     alias get const
-    def initialize (&block)
+    def initialize(&block)
       @const = Const0
       block.call self if block
     end
   end
 
   class SymbolAccessor < ConstAccessor
-    const_symbol_accessor :const, {
+    const_symbol_accessor :const, **{
       const0: Const0,
       const1: Const1
     }
   end
 
-  def const (&block)
-    ConstAccessor.new &block
+  def const(&block)
+    ConstAccessor.new(&block)
   end
 
-  def symbol (&block)
-    SymbolAccessor.new &block
+  def symbol(&block)
+    SymbolAccessor.new(&block)
   end
 
-  def test_const_accessor ()
+  def test_const_accessor()
     assert_equal Const0, const.get
     assert_equal Const1, const{|o| o.const = Const1}.get
     assert_nothing_raised {const.const = Unknown}
   end
 
-  def test_symbol_writer ()
+  def test_symbol_writer()
     assert_equal Const0, symbol.get
     assert_equal Const1, symbol{|o| o.const = :const1}.get
     assert_raise(ArgumentError) {symbol.const = :unknown}
   end
 
-  def test_symbol_reader ()
+  def test_symbol_reader()
     assert_equal :const0, symbol.const
     assert_equal :const1, symbol{|o| o.set Const1}.const
     assert_raise(RuntimeError) {symbol{|o| o.set Unknown}.const}

data/test/test_hookable.rb

@@ -12,58 +12,58 @@ class TestHookable < Test::Unit::TestCase
 
     attr_reader :log
 
-    def initialize ()
+    def initialize()
       @log = []
     end
 
-    def test (val1, val2)
+    def test(val1, val2)
       @log << val1 << val2
     end
 
-    def zero ()
+    def zero()
       @log << 0
     end
 
   end# Temp
 
-  def temp (*args)
+  def temp(*args)
     Temp.new
   end
 
-  def test_hook ()
+  def test_hook()
     o = temp
     o.hook(:test) do |*args|
-      super -1, 0
+      super(-1, 0)
       o.log << args
-      super *args
+      super(*args)
       super 8, 9
     end
     o.test 1, 2
     assert_equal [-1, 0, [1, 2], 1, 2, 8, 9], o.log
   end
 
-  def test_before ()
+  def test_before()
     o = temp
     o.before(:zero) {o.log << 1}
     o.zero
     assert_equal [1, 0], o.log
   end
 
-  def test_after ()
+  def test_after()
     o = temp
     o.after(:zero) {o.log << 1}
     o.zero
     assert_equal [0, 1], o.log
   end
 
-  def test_on ()
+  def test_on()
     o = temp
     o.on(:zero) {o.log << 1}
     o.zero
     assert_equal [1], o.log
   end
 
-  def test_hook_self ()
+  def test_hook_self()
     o, id = temp, nil
     o.hook(:zero) {id = __id__}
     o.zero

data/test/test_invoker.rb

@@ -10,17 +10,17 @@ class TestInvoker < Test::Unit::TestCase
     include Xot::Invoker
   end
 
-  def invoker (*args, &block)
-    Invoker.new *args, &block
+  def invoker(*args, &block)
+    Invoker.new(*args, &block)
   end
 
-  def handler (method, &block)
+  def handler(method, &block)
     o = Object.new
     o.define_singleton_method method, &block
     o
   end
 
-  def test_add_handler ()
+  def test_add_handler()
     inv, var = invoker, nil
 
     assert_equal nil, var

data/test/test_rake.rb

@@ -20,7 +20,7 @@ class TestRake < Test::Unit::TestCase
 
   include Xot::Rake
 
-  def test_set ()
+  def test_set()
     assert_equal 'const', env(:Const, :dummy)
     assert_equal 0, env(:Zero, :dummy)
     assert_equal 1, env(:NonZero, :dummy)

data/test/test_setter.rb

@@ -14,29 +14,29 @@ class TestSetter < Test::Unit::TestCase
 
   end# Temp
 
-  def temp (*args)
+  def temp(*args)
     Temp.new
   end
 
-  def test_set ()
+  def test_set()
     o = temp
     assert_equal nil, o.x
     o.set :x, 1
     assert_equal 1,   o.x
   end
 
-  def test_set_by_hash ()
+  def test_set_by_hash()
     o = temp
     o.set :x => 1, :y => 2
     assert_equal [1, 2], [o.x, o.y]
   end
 
-  def test_invalid_name ()
+  def test_invalid_name()
     assert_raise(NoMethodError) {temp.set :badname, 1}
     assert_raise(ArgumentError) {temp.set :badname}
   end
 
-  def test_invalid_value ()
+  def test_invalid_value()
     assert_raise(ArgumentError) {temp.set :x}
   end
 

data/test/test_tester.rb

@@ -6,7 +6,7 @@ require_relative 'helper'
 
 class TestTester < Test::Unit::TestCase
 
-  def test_native ()
+  def test_native()
     assert Xot::Tester.test_native
   end
 

data/test/test_universal_accessor.rb

@@ -12,7 +12,7 @@ class TestUniversalAccessor < Test::Unit::TestCase
 
     attr_reader :args
 
-    def args= (*args)
+    def args=(*args)
       @args = args
     end
 
@@ -20,11 +20,11 @@ class TestUniversalAccessor < Test::Unit::TestCase
 
   end# Accessor
 
-  def accessor (*args)
-    Accessor.new *args
+  def accessor(*args)
+    Accessor.new(*args)
   end
 
-  def test_accessor ()
+  def test_accessor()
     a = accessor
     assert_equal nil, a.val
 
@@ -36,7 +36,7 @@ class TestUniversalAccessor < Test::Unit::TestCase
     assert_equal 3, a.val
   end
 
-  def test_accessor_splat_args ()
+  def test_accessor_splat_args()
     a = accessor
 
     a.args =   1, 2, 3;  assert_equal [[1, 2, 3]], a.args

data/xot.gemspec

@@ -28,6 +28,8 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '~> 2'
 
+  s.add_development_dependency 'test-unit'
+
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}
   s.test_files       = s.files.grep %r{^(test|spec|features)/}

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: xot
 version: !ruby/object:Gem::Version
-  version: 0.1.21
+  version: 0.1.22
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-16 00:00:00.000000000 Z
-dependencies: []
+date: 2021-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: This library include some useful utility classes and functions for development
   with C++.
 email: xordog@gmail.com