benry-recorder 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4546395dc9bc48dd67bd730e86d6b2875fffb556
+  data.tar.gz: c1d7c6b23e60e2b0b735aff167b6af5ef5ce8398
+SHA512:
+  metadata.gz: 86785e3485c6dbfa1e89737dd3259f8ab1f828209e66b43254900085bca4326ede38246f84d2d0007958114362818cecd4b02d61545de7bdbf8908ef06f9575e
+  data.tar.gz: 7df326f888d5f522a16ef5004273b032a99356de9fa578b3016ccff8eada31bf7c0a0e4c21cdb5077c616ddedada26435f71e84d0c68ac4f8a0ec480df05863b

data/README.md

@@ -0,0 +1,125 @@
+<!-- -*- coding: utf-8 -*- -->
+# Benry-recorder README
+
+Benry-recoder is a tiny utility that can:
+
+* Record method calls of target object.
+* Define fake methods on target object.
+* Create fake object which has fake methods.
+
+
+## Table of Contents
+
+<!-- TOC -->
+
+  * <a href="#how-to-record-method-calls">How to record method calls</a>
+  * <a href="#how-to-define-fake-methods">How to define fake methods</a>
+  * <a href="#how-to-create-fake-object">How to create fake object</a>
+  * <a href="#license-and-copyright">License and Copyright</a>
+
+<!-- /TOC -->
+
+
+## How to record method calls
+
+<!--
+file: example1.rb
+-->
+
+```ruby
+require 'benry/recorder'
+
+class Calc
+  def average(*nums)   # average() calls total()
+    return total(*nums) / nums.length
+  end
+  def total(*nums)
+    t = 0; nums.each {|n| t += n }
+    return t   # or: return nums.sum
+  end
+end
+
+## target object
+calc = Calc.new
+
+## record method calls
+rec = Benry::Recorder.new
+rec.record(calc, :total, :average)
+
+## call methods
+calc.average(10, 20, 30, 40)    # calls calc.total() internally
+
+## details of method calls
+p rec.length               #=> 2
+puts rec.inspect
+      #=> 0: #<Calc:0x001234abcd>.average(10, 20, 30, 40) #=> 25
+      #   1: #<Calc:0x001234abcd>.total(10, 20, 30, 40) #=> 100
+#
+p rec[0].obj               #=> #<Calc:0x001234abcd>
+p rec[0].obj.equal?(calc)  #=> true
+p rec[0].name              #=> :average
+p rec[0].args              #=> [10, 20, 30, 40]
+p rec[0].ret               #=> 25
+#
+p rec[1].obj               #=> #<Calc:0x001234abcd>
+p rec[1].obj.equal?(calc)  #=> true
+p rec[1].name              #=> :total
+p rec[1].args              #=> [10, 20, 30, 40]
+p rec[1].ret               #=> 100
+#
+p rec[0].to_a              #=> [obj, :average, [10, 20, 30, 40], 25]
+p rec[1].to_a              #=> [obj, :total, [10, 20, 30, 40], 100]
+```
+
+
+## How to define fake methods
+
+<!--
+file: example2.rb
+-->
+
+```ruby
+require 'benry/recorder'
+
+class Calc
+  ....(snip)....
+end
+
+## target object
+calc = Calc.new
+
+## before
+p calc.total(10, 20, 30, 40)     #=> 100
+p calc.average(10, 20, 30, 40)   #=>  25
+
+## define fake methods
+rec = Benry::Recorder.new
+rec.fake_method(calc, :total=>123, :average=>34)
+
+## after
+p calc.total(10, 20, 30, 40)     #=> 123
+p calc.average(10, 20, 30, 40)   #=>  34
+```
+
+
+## How to create fake object
+
+<!--
+file: example3.rb
+-->
+
+```ruby
+require 'benry/recorder'
+
+rec = Benry::Recorder.new
+obj = rec.fake_object(:foo=>10, :bar=>20)
+p obj.foo()                #=> 10
+p obj.bar()                #=> 20
+p obj.bar(3, 4, 'a'=>5)    # accepts any arguments
+```
+
+
+## License and Copyright
+
+* $License: MIT License $
+* $Copyright: copyright(c) 2011-2021 kuwata-lab.com all rights reserved $

data/Rakefile.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+
+PROJECT   = "benry-recorder"
+RELEASE   = ENV['RELEASE'] || "0.0.0"
+COPYRIGHT = "copyright(c) 2011-2021 kuwata-lab.com all rights reserved"
+LICENSE   = "MIT License"
+
+README_EXTRACT  = /^file: (.*\.rb)/
+
+Dir.glob("./task/*.rb").each {|x| require_relative x }
+
+def readme_extract_callback(filename, str)
+  if filename == 'example1.rb'
+    str =~ /class Calc\n(.*?)^end\n/m
+    $_classdef = $1
+  elsif filename == 'example2.rb'
+    str = str.sub(/^ *\.\.\.+\(snip\)\.\.\.+ *\n/, $_classdef)
+  end
+  return str
+end

data/benry-recorder.gemspec

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+Gem::Specification.new do |spec|
+  spec.name            = 'benry-recorder'
+  spec.version         = '$Release: 1.0.0 $'.split()[1]
+  spec.author          = 'kwatch'
+  spec.email           = 'kwatch@gmail.com'
+  spec.platform        = Gem::Platform::RUBY
+  spec.homepage        = 'https://github.com/kwatch/benry-ruby/tree/ruby/benry-recorder'
+  spec.summary         = "Record method calls, or define fake methods."
+  spec.description     = <<-'END'
+Benry-recorder is a tiny utility that can:
+
+* Record method calls of target object.
+* Define fake methods on target object.
+* Create fake object which has fake methods.
+END
+  spec.license         = 'MIT'
+  spec.files           = Dir[
+                           'README.md', 'MIT-LICENSE', #'CHANGES.md'
+                           'Rakefile.rb', 'benry-recorder.gemspec',
+                           #'bin/*',
+                           'lib/**/*.rb',
+                           'test/**/*.rb',
+                           'task/**/*.rb',
+                         ]
+  #spec.executables     = ['benry-recorder']
+  #spec.bindir          = 'bin'
+  spec.require_path    = 'lib'
+  #spec.test_files      = Dir['test/run_all.rb']
+  spec.test_files      = Dir['test/**/*_test.rb']
+  #spec.extra_rdoc_files = ['README.md', 'CHANGES.md']
+
+  spec.add_development_dependency 'minitest'    , '~> 0'
+  spec.add_development_dependency 'minitest-ok' , '~> 0'
+end

data/lib/benry/recorder.rb

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+
+###
+### $Release: 1.0.0 $
+### $Copyright: copyright(c) 2011-2021 kuwata-lab.com all rights reserved $
+### $License: MIT License $
+###
+
+
+module Benry
+
+
+  ##
+  ## record method calls, or define fake methods.
+  ##
+  ## ex. record method calls
+  ##    ## target class
+  ##    class Calc
+  ##      def average(*nums)   # average() calls total()
+  ##        return total(*nums) / nums.length
+  ##      end
+  ##      def total(*nums)
+  ##        t = 0; nums.each {|n| t += n }
+  ##        return t   # or: return nums.sum
+  ##      end
+  ##    end
+  ##    ## record method calls
+  ##    rec = Benry::Recorder.new
+  ##    calc = Calc.new
+  ##    rec.record(calc, :total, :average)
+  ##    ## call methods
+  ##    calc.average(10, 20, 30, 40)
+  ##    ## details of method calls
+  ##    p rec.length               #=> 2
+  ##    puts rec.inspect
+  ##          #=> 0: #<Calc:0x001234abcd>.average(10, 20, 30, 40) #=> 25
+  ##          #   1: #<Calc:0x001234abcd>.total(10, 20, 30, 40) #=> 100
+  ##    #
+  ##    p rec[0].obj               #=> #<Calc:0x001234abcd>
+  ##    p rec[0].obj.equal?(calc)  #=> true
+  ##    p rec[0].name              #=> :average
+  ##    p rec[0].args              #=> [10, 20, 30, 40]
+  ##    p rec[0].ret               #=> 25
+  ##    #
+  ##    p rec[1].obj               #=> #<Calc:0x001234abcd>
+  ##    p rec[1].obj.equal?(calc)  #=> true
+  ##    p rec[1].name              #=> :total
+  ##    p rec[1].args              #=> [10, 20, 30, 40]
+  ##    p rec[1].ret               #=> 100
+  ##    #
+  ##    p rec[0].to_a              #=> [obj, :average, [10, 20, 30, 40], 25]
+  ##    p rec[1].to_a              #=> [obj, :total, [10, 20, 30, 40], 100]
+  ##
+  ## ex. fake method
+  ##    rec = Benry::Recorder.new
+  ##    calc = Calc.new
+  ##    ## before
+  ##    p calc.total(10, 20, 30, 40)     #=> 100
+  ##    p calc.average(10, 20, 30, 40)   #=>  25
+  ##    ## after
+  ##    rec.fake_method(calc, :total=>123, :average=>34)
+  ##    p calc.total(10, 20, 30, 40)     #=> 123
+  ##    p calc.average(10, 20, 30, 40)   #=>  34
+  ##
+  ## ex. fake object
+  ##    rec = Benry::Recorder.new
+  ##    obj = rec.fake_object(:foo=>10, :bar=>20)
+  ##    p obj.foo()                #=> 10
+  ##    p obj.bar()                #=> 20
+  ##    p obj.bar(3, 4, 'a'=>5)    # accepts any arguments
+  ##
+  class Recorder
+
+
+    class Called
+
+      def initialize(obj, name, args, ret)
+        @obj  = obj
+        @name = name
+        @args = args
+        @ret  = ret
+      end
+
+      #; [!m98p9] returns receiver object.
+      #; [!es61g] returns method name.
+      #; [!2yeeo] returns arguments.
+      #; [!yd3hl] returns arguments.
+      attr_accessor :obj, :name, :args, :ret
+
+      def to_a()
+        #; [!hrol9] returns array of obj, nae, args, and ret.
+        return [@obj, @name, @args, @ret]
+      end
+
+      def inspect()
+        #; [!g2iwe] represents internal data.
+        s = args.collect {|arg| arg.inspect }.join(", ")
+        return "#{obj.inspect}.#{name}(#{s}) #=> #{ret.inspect}"
+      end
+
+    end
+
+
+    def initialize()
+      @called = []
+    end
+
+    def length()
+      @called.length
+    end
+
+    alias size length
+
+    def [](index)
+      return @called[index]
+    end
+
+    def inspect()
+      #; [!k85bz] represents internal data.
+      buf = []
+      @called.each_with_index {|called, i| buf << "#{i}: #{called.inspect}\n" }
+      return buf.join()
+    end
+
+    def record_method(obj, *method_names)
+      #; [!61z3j] records method calls.
+      called_list = @called
+      proc_obj = proc do |obj, name, orig_method|
+        (class << obj; self; end).class_eval do
+          alias_method orig_method, name
+          define_method(name) do |*args|
+            called = Recorder::Called.new(obj, name.to_s.intern, args, nil)
+            called_list << called
+            #; [!9kh1f] calls original method.
+            ret = obj.__send__(orig_method, *args)
+            called.ret = ret
+            ret
+          end
+        end
+      end
+      method_names.each do |name|
+        proc_obj.call(obj, name, "__#{name}_orig".intern)
+      end
+      self
+    end
+    alias record record_method
+
+    def fake_method(obj, **name_and_values)
+      #; [!g112x] defines fake methods.
+      called_list = @called
+      proc_obj = proc do |obj, name, val|
+        (class << obj; self; end).class_eval do
+          #; [!kgvm1] defined methods can can take any arguments.
+          define_method(name) do |*args|
+            called_list << Recorder::Called.new(obj, name, args, val)
+            val
+          end
+        end
+      end
+      name_and_values.each do |name, val|
+        proc_obj.call(obj, name, val)
+      end
+      #; [!2p1b0] returns self.
+      self
+    end
+    alias fake fake_method
+
+    def fake_object(**name_and_values)
+      #; [!hympr] creates fake object.
+      obj = Object.new
+      fake_method(obj, **name_and_values)
+      return obj
+    end
+
+  end
+
+
+end

data/task/common-task.rb

@@ -0,0 +1,185 @@
+# -*- 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."
+
+$ruby_versions ||= %w[2.4 2.5 2.6 2.7 3.0]
+
+
+require 'rake/clean'
+CLEAN << "build"
+CLEAN.concat Dir.glob("#{PROJECT}-*.gem").collect {|x| x.sub(/\.gem$/, '') }
+CLOBBER.concat Dir.glob("#{PROJECT}-*.gem")
+
+
+desc "show release guide"
+task :guide do
+  RELEASE != '0.0.0'  or abort "rake help: required 'RELEASE=X.X.X'"
+  rel, proj = RELEASE, PROJECT
+  rel =~ /(\d+\.\d+)/
+  branch = "#{proj}_rel-#{$1}"
+  puts <<END
+How to release:
+
+  $ git diff .
+  $ git status .
+  $ which ruby
+  $ rake test
+  $ rake test:all
+  $ rake readme:execute             # optional
+  $ rake readme:toc                 # optional
+  $ rake package RELEASE=#{rel}
+  $ rake package:extract            # confirm files in gem file
+  $ (cd #{proj}-#{rel}/data; find . -type f)
+  $ gem install #{proj}-#{rel}.gem  # confirm gem package
+  $ gem uninstall #{proj}
+  $ gem push #{proj}-#{rel}.gem     # publish gem to rubygems.org
+  $ git tag #{proj}-#{rel}
+  $ git push
+  $ git push --tags
+END
+end unless Rake::Task.task_defined?(:guide)
+
+
+desc "do test"
+task :test do
+  ruby "test/run_all.rb"
+end unless Rake::Task.task_defined?(:test)
+
+
+if ENV['VS_HOME'] && $ruby_versions
+  desc "do test for different ruby versions"
+  task :'test:all' do
+    vs_home = ENV['VS_HOME'].split(/:/).first
+    ENV['TC_QUIET'] = "Y" if File.exist?("test/tc.rb")
+    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
+      next unless dir
+      puts "==== ruby #{ver} (#{dir}) ===="
+      sh "#{dir}/bin/ruby test/run_all.rb" do |ok, res|
+        $stderr.puts "** test failed" unless ok
+      end
+    end
+  end unless Rake::Task.task_defined?(:'test:all')
+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 "'#{PROJECT}' != '#{spec.name}' (project name in gemspec file)"
+    spec.files
+  end
+  return $_target_files
+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 "edit metadata in files"
+task :edit do
+  target_files().each do |fname|
+    changed = edit_file(fname) do |s|
+      #s = s.gsub(/\$Release[:].*?\$/,   "$"+"Release: #{RELEASE} $")
+      s = s.gsub(/\$Copyright[:].*?\$/, "$"+"Copyright: #{COPYRIGHT} $")
+      s = s.gsub(/\$License[:].*?\$/,   "$"+"License: #{LICENSE} $")
+      s
+    end
+    puts "[C] #{fname}"     if changed
+    puts "[U] #{fname}" unless changed
+  end
+end unless Rake::Task.task_defined?(:edit)
+
+
+desc "create package (*.gem)"
+task :package do
+  RELEASE != '0.0.0'  or abort "rake help: required 'RELEASE=X.X.X'"
+  ## 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) do |s|
+      s = s.gsub(/\$Release[:].*?\$/,   "$"+"Release: #{RELEASE} $")
+      s = s.gsub(/\$Copyright[:].*?\$/, "$"+"Copyright: #{COPYRIGHT} $")
+      s = s.gsub(/\$License[:].*?\$/,   "$"+"License: #{LICENSE} $")
+      s
+    end
+  end
+  ## build
+  chdir dir do
+    sh "gem build #{PROJECT}.gemspec"
+  end
+  mv "#{dir}/#{PROJECT}-#{RELEASE}.gem", "."
+  rm_rf dir
+end unless Rake::Task.task_defined?(:package)
+
+
+desc "extract latest gem file"
+task :'package:extract' do
+  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 unless Rake::Task.task_defined?(:'package:extract')
+
+
+desc "upload gem file to rubygems.org"
+task :publish do
+  RELEASE != '0.0.0'  or abort "rake help: required 'RELEASE=X.X.X'"
+  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 push --tags"
+  end
+end unless Rake::Task.task_defined?(:publish)
+
+
+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/readme-task.rb

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+
+README_FILE      = "README.md"       unless defined? README_FILE
+README_EXTRACT   = /^file: +(\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
+    dir = "tmp/readme"
+    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
+    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
+    url = ENV['README_URL']  or abort "$README_URL required."
+    htmlfile = "README.html"
+    sh "curl -s -o #{htmlfile} #{url}"
+    rexp = /<h(\d)><a id="(.*?)" class="anchor".*><\/a>(.*)<\/h\1>/
+    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/
+      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()
+    #
+    changed = File.open("README.md", "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] README.md"          if changed
+    puts "[not changed] README.md"  unless changed
+  end
+
+end

data/test/recorder_test.rb

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*-
+
+###
+### $Release: 1.0.0 $
+### $Copyright: copyright(c) 2011-2021 kuwata-lab.com all rights reserved $
+### $License: MIT License $
+###
+
+File.class_eval do
+  libpath = join(dirname(dirname(expand_path(__FILE__))), 'lib')
+  $LOAD_PATH.unshift(libpath) unless $LOAD_PATH.include?(libpath)
+end
+
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/ok'
+
+require 'benry/recorder'
+
+
+class Calc4190
+  def average(*nums)   # average() calls total()
+    return total(*nums) / nums.length
+  end
+  def total(*nums)
+    t = 0
+    nums.each {|n| t += n }
+    return t   # or return nums.sum
+  end
+end
+
+
+describe Benry::Recorder do
+
+  describe '#record_method()' do
+    it "[!61z3j] records method calls." do
+      rec = Benry::Recorder.new
+      calc = Calc4190.new
+      rec.record_method(calc, :total, :average)
+      avg = calc.average(10, 20, 30, 40)   #=> 25
+      #
+      ok {rec.length}  == 2
+      #
+      ok {rec[0].obj}  == calc
+      ok {rec[0].name} == :average
+      ok {rec[0].args} == [10, 20, 30, 40]
+      ok {rec[0].ret}  == 25
+      #
+      ok {rec[1].obj}  == calc
+      ok {rec[1].name} == :total
+      ok {rec[1].args} == [10, 20, 30, 40]
+      ok {rec[1].ret}  == 100
+    end
+    it "[!9kh1f] calls original method." do
+      rec = Benry::Recorder.new
+      calc = Calc4190.new
+      rec.record_method(calc, :total, :average)
+      ok {calc.average(10, 20, 30, 40)} == 25
+      ok {calc.average(1.0, 2.0, 3.0, 4.0)} == 2.5
+    end
+  end
+
+  describe '#fake_method()' do
+    it "[!g112x] defines fake methods." do
+      rec = Benry::Recorder.new
+      calc = Calc4190.new
+      rec.fake_method(calc, :total=>150)
+      ret = calc.average(10, 20)  # calc.average() calls calc.total() internally
+      ok {ret} == 75              # 75 == 150/2
+      #
+      ok {rec.length}  == 1
+      ok {rec[0].obj}  == calc
+      ok {rec[0].name} == :total
+      ok {rec[0].args} == [10, 20]
+      ok {rec[0].ret}  == 150
+    end
+    it "[!kgvm1] defined methods can can take any arguments." do
+      rec = Benry::Recorder.new
+      calc = Calc4190.new
+      rec.fake_method(calc, :total=>999)
+      ret = calc.total(10, 20, :a=>1, 'b'=>2)
+      ok {ret} == 999
+      #
+      ok {rec.length}  == 1
+      #
+      ok {rec[0].obj}  == calc
+      ok {rec[0].name} == :total
+      ok {rec[0].args} == [10, 20, {:a=>1, 'b'=>2}]
+      ok {rec[0].ret}  == 999
+    end
+    it "[!2p1b0] returns self." do
+    end
+  end
+
+  describe '#fake_object()' do
+    it "[!hympr] creates fake object." do
+      rec = Benry::Recorder.new
+      obj = rec.fake_object(:foo=>123, :bar=>"abc")
+      ok {obj.foo(10, 20, 'a'=>1, 'b'=>2)} == 123
+      ok {obj.bar(30, 40, x: 8, y: 9)} == "abc"
+      #
+      ok {rec.length}  == 2
+      #
+      ok {rec[0].obj}  == obj
+      ok {rec[0].name} == :foo
+      ok {rec[0].args} == [10, 20, {'a'=>1, 'b'=>2}]
+      ok {rec[0].ret}  == 123
+      #
+      ok {rec[1].obj}  == obj
+      ok {rec[1].name} == :bar
+      ok {rec[1].args} == [30, 40, {:x=>8, :y=>9}]
+      ok {rec[1].ret}  == "abc"
+    end
+  end
+
+  describe '#inspect()' do
+    it "[!k85bz] represents internal data." do
+      rec = Benry::Recorder.new
+      calc = Calc4190.new
+      rec.fake_method(calc, :total=>200)
+      rec.record_method(calc, :average)
+      ret = calc.average(10, 20, 30, 40)
+      #
+      s = rec.inspect.gsub(/#<Calc4190:0x\w+>/, '#<Calc4190:0xXXXX>')
+      ok {s} == ("0: #<Calc4190:0xXXXX>.average(10, 20, 30, 40) #=> 50\n"\
+                 "1: #<Calc4190:0xXXXX>.total(10, 20, 30, 40) #=> 200\n")
+    end
+  end
+
+end
+
+
+describe Benry::Recorder::Called do
+
+  before do
+    @calc = Calc4190.new
+    @rec = Benry::Recorder.new
+    @rec.record_method(@calc, :total, :average)
+    avg = @calc.average(10, 20, 30, 40)   #=> 25
+    @called0 = @rec[0]
+    @called1 = @rec[1]
+  end
+
+  describe '#obj' do
+    it "[!m98p9] returns receiver object." do
+      ok {@called0.obj} == @calc
+      ok {@called1.obj} == @calc
+    end
+  end
+
+  describe '#name' do
+    it "[!es61g] returns method name." do
+      ok {@called0.name} == :average
+      ok {@called1.name} == :total
+    end
+  end
+
+  describe '#args' do
+    it "[!2yeeo] returns arguments." do
+      ok {@called0.args} == [10, 20, 30, 40]
+      ok {@called1.args} == [10, 20, 30, 40]
+    end
+  end
+
+  describe '#ret' do
+    it "[!yd3hl] returns arguments." do
+      ok {@called0.ret} == 25
+      ok {@called1.ret} == 100
+    end
+  end
+
+  describe '#to_a' do
+    it "[!hrol9] returns array of obj, nae, args, and ret." do
+      ok {@called0.to_a} == [@calc, :average, [10, 20, 30, 40], 25]
+      ok {@called1.to_a} == [@calc, :total,   [10, 20, 30, 40], 100]
+    end
+  end
+
+  describe '#inspect()' do
+    it "[!g2iwe] represents internal data." do
+      rexp = /\A#<Calc4190:0x\w+>\.average\(10, 20, 30, 40\) #=> 25\z/
+      ok {@called0.inspect()} =~ rexp
+    end
+  end
+
+end

data/test/run_all.rb

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+Dir.glob(File.join(File.dirname(__FILE__), '**/*_test.rb')).each do |x|
+  #require x
+  require File.absolute_path(x)
+  #load x
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: benry-recorder
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- kwatch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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'
+- !ruby/object:Gem::Dependency
+  name: minitest-ok
+  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: |
+  Benry-recorder is a tiny utility that can:
+
+  * Record method calls of target object.
+  * Define fake methods on target object.
+  * Create fake object which has fake methods.
+email: kwatch@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile.rb
+- benry-recorder.gemspec
+- lib/benry/recorder.rb
+- task/common-task.rb
+- task/readme-task.rb
+- test/recorder_test.rb
+- test/run_all.rb
+homepage: https://github.com/kwatch/benry-ruby/tree/ruby/benry-recorder
+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: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: Record method calls, or define fake methods.
+test_files:
+- test/recorder_test.rb