あなたの Ruby コードを添削します 【第 5 回】 Miyako + MidoreDayBook + Lispもどき

$ wc miyako.rb miyako_ext.rb
  5137  13190 133706 miyako.rb
  1177  2982   29260 miyako_ext.rb

$ grep protected miyako.rb
    protected :setup
    protected :add, :compile
    protected :process_default
    protected :createList
    protected :init_height
    protected :_drawText, :_drawTextMild
    protected :setup
    protected :layout_left_inside, :layout_right_inside, :layout_center_inside
    protected :layout_top_inside, :layout_middle_inside, :layout_bottom_inside
    protected :layout_left_outside, :layout_right_outside, :layout_center_outside
    protected :layout_top_outside, :layout_middle_outside, :layout_bottom_outside
    protected :get_base_width, :get_base_height
    protected :get_base_x, :get_base_y
    protected :createWindow, :setMargin
    protected :setPauseLocate
    protected :createWindow, :setMargin
      protected :copyRect, :draw, :cdraw
$ grep private miyako.rb
$

# スーパークラスで定義された private メソッドを呼び出す例
class A
  def print_ok
    puts "OK"
  end
  private :print_ok
end

class B < A
  def m
    print_ok   # スーパークラスで定義された private メソッドを呼ぶ
  end
end

B.new.m    # エラーにならない！

# include したモジュールで定義されている private メソッドを呼び出す例
module M
  def print_ok
    puts "OK"
  end
  private :print_ok
end

class C
  include M

  def m
    print_ok   # include したモジュールで定義されている private メソッドを呼ぶ
  end
end

C.new.m   # やっぱりエラーにならない

 class Person
   def initialize(name, age)
     @name = name     # この変数は公開する
     @age = age       # この変数は公開したくない
   end

   # ……しかし、Person#name も Person#age も別のオブジェクトからアクセスしたい
   def ==(other)
     @name == other.name and    # ← Person#name を外から呼んでる
     @age == other.age          # ← Person#age を外から呼んでる
   end

   attr_reader :name  # Person#name は public で問題なし
   attr_reader :age   # でも Person#age は無制限に公開したくない
   protected :age     # ……ので、protected にする
 end

        while f.eof? == false

        until f.eof?

    def Direction.cr
      return @@cr
    end

    def to_s
      @p.to_s+","+@s.to_s
    end

    def to_s
      "#{@p},#{@s}"
    end

      raise YukiError,new("Command Label is Empty!") if label == nil

      raise YukiError, "command label is empty" unless label

    def [](name)
      raise YukiError.new("name is Not String or Symbol!") unless name.kind_of?(String) || name.kind_of?(Symbol)
      name = name.intern if name.class == String
      raise YukiError.new("Illegal scenario name! : "+ name.to_s) unless @scnr.include?(name)
      @scnr[name].reset(false)
      return @scnr[name]
    end

    def [](name)
      scenario = @scnr[name] or raise YukiError, "unknown scenario: #{name.inspect}"
      scenario.reset(false)
      scenario
    end

            if com =~ /^color[=\s\t]+(.+)$/
              cl = add(cl, tmc + tm, spr)
              tmc = ""
              cl.push(Direction.new(Direction::FONTCOLOR, Miyako::Color.to_rgb($1), :setting))
            elsif com =~ /^size[=\s\t]+(\d+)$/
              cl = add(cl, tmc + tm, spr)
              tmc = ""
              cl.push(Direction.new(Direction::FONTSIZE, $1.to_i, :setting))
            elsif com == "pause"
              cl = add(cl, tmc + tm, spr)
              tmc = ""
              cl.push(Direction.new(Direction::PAUSE))
            elsif com == "clear"
              cl = add(cl, tmc + tm, spr)
              tmc = ""
              cl.push(Direction.new(Direction::CLEAR))
            elsif com == "cr"
              cl = add(cl, tmc + tm, spr)
              tmc = ""
              cl.push(Direction.new(Direction::CR))
            elsif com =~ /^message_wait[=\s\t]+(\d*\.?\d+)$/
                       (以下略)

            case com
            when /^color[=\s\t]+(.+)$/
              cl = add(cl, tmc + tm, spr)
              tmc = ""
              cl.push(Direction.new(Direction::FONTCOLOR, Miyako::Color.to_rgb($1), :setting))
            when /^size[=\s\t]+(\d+)$/
              cl = add(cl, tmc + tm, spr)
              tmc = ""
              cl.push(Direction.new(Direction::FONTSIZE, $1.to_i, :setting))
            when "pause"
              cl = add(cl, tmc + tm, spr)
              tmc = ""
              cl.push(Direction.new(Direction::PAUSE))
            when "clear"
              cl = add(cl, tmc + tm, spr)
              tmc = ""
              cl.push(Direction.new(Direction::CLEAR))
            when "cr"
              cl = add(cl, tmc + tm, spr)
              tmc = ""
              cl.push(Direction.new(Direction::CR))
            when /^message_wait[=\s\t]+(\d*\.?\d+)$/
                       (以下略)

COMMAND_DESCRIPTORS = [
  [/^color[=\s\t]+(.+)$/,
   lambda {|m| Direction.new(Direction::FONTCOLOR, Miyako::Color.to_rgb(m[1]), :setting) }],
  [/^size[=\s\t]+(\d+)$/,
   lambda {|m| Direction.new(Direction::FONTSIZE, m[1].to_i, :setting) }],
  ["pause",
   lambda {|m| Direction.new(Direction::PAUSE) }],
  ["clear",
   lambda {|m| Direction.new(Direction::CLEAR) }],
  ["cr",
   lambda {|m| Direction.new(Direction::CR) }],
         ：
         ：
]

class Compiler
  def Compiler.compile(c, spr)
         ：
         ：
        pattern, action = COMMAND_DESCRIPTORS.detect {|re, | re =~ com }
        if pattern
          m = pattern.match(com)
          cl = add(cl, tmp + tm, spr)
          tmp = ""
          cl.push action.call(m)
        else
          # どの正規表現にもマッチしなかった場合のコード
        end
      end

/^color[=\s\t]+(.+)$/

 case com
 when /\A\s*(\w+)\s*=/m
   name = $1
   value = $'.strip
   # 略
 when /\A\s*\w+\s*\z/
   name = com.strip
 else
   raise CompileError, "syntax error: #{com.inspect}"
 end

 VALUE_PARSER = {
   'color' => lambda {|str| Direction.new(Direction::FONTCOLOR, Miyako::Color.to_rgb(str) },
   'size'  => lambda {|str| Direction.new(Direction::FONTSIZE, Integer(str), :setting) },
      :
      :
 }

 def Compiler.compile(c, spr)
      :
      :
     case com
     when /\A\s*(\w+)\s*=\s*(.*)\z/m
       name = $1
       value = $2.strip
       parser = VALUE_PARSER[name] or
           raise CompileError, "unknown command: #{name.inspect}"
       cl.push parser.call(value)
       # 以下略

    def Color::to_rgb(v)
      return nil unless v
      if v.kind_of?(Array)
        raise MiyakoError.new("Illegal color array!") unless v.length == 3
        return v
      end
      return cc2rgb(v) if v.kind_of?(Integer)
      return str2rgb(v.to_s) if v.kind_of?(Symbol)
      return str2rgb(v) if v.kind_of?(String)
      raise MiyakoError.new("Illegal parameter")
    end

    def Color::to_rgb(v)
      return nil unless v
      case v
      when Array
        raise MiyakoError, "size of color array must be 3" unless v.size == 3
        v
      when Integer then cc2rgb(v)
      when Symbol  then str2rgb(v.to_s)
      when String  then str2rgb(v)
      else
        raise MiyakoError, "wrong type of argument: #{v.inspect} (#{v.class})"
      end
    end

    def Color::str2rgb(str)
      return eval("["+str+"]") if str =~ /^\[?(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*)\]?$/
      return hex2rgb(str) if str =~ /^\#[\da-fA-F]{6}/
      const_str = str.upcase
      return eval("Miyako::Color::"+str.upcase) if Module.constants.include?(const_str)
      raise MiyakoError.new("Illegal parameter")
    end

    def Color::str2rgb(str)
      case str
      when /\A\[\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\]\z/
        [$1.to_i, $2.to_i, $3.to_i]
      when /\A\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\z/
        [$1.to_i, $2.to_i, $3.to_i]

      const_str = str.upcase
      return eval("Miyako::Color::"+str.upcase) if Module.constants.include?(const_str)

$ ruby-1.8.5 -e '
  module Miyako
    class Color
      RED = 1
      p Module.constants.sort
    end
  end
'
["ARGF", "ARGV", "ArgumentError", "Array", "Bignum", "Binding",
"Class", "Color", "Comparable", "Continuation", "Data", "Dir", "ENV",
"EOFError", "Enumerable", "Errno", "Exception", "FALSE", "FalseClass",
"File", "FileTest", "Fixnum", "Float", "FloatDomainError", "GC",
"Hash", "IO", "IOError", "IndexError", "Integer", "Interrupt",
"Kernel", "LoadError", "LocalJumpError", "Marshal", "MatchData",
"MatchingData", "Math", "Method", "Miyako", "Module", "NIL",
"NameError", "NilClass", "NoMemoryError", "NoMethodError",
"NotImplementedError", "Numeric", "Object", "ObjectSpace", "PLATFORM",
"Precision", "Proc", "Process", "RED", "RELEASE_DATE",
"RUBY_PLATFORM", "RUBY_RELEASE_DATE", "RUBY_VERSION", "Range",
"RangeError", "Regexp", "RegexpError", "RuntimeError", "STDERR",
"STDIN", "STDOUT", "ScriptError", "SecurityError", "Signal",
"SignalException", "StandardError", "String", "Struct", "Symbol",
"SyntaxError", "SystemCallError", "SystemExit", "SystemStackError",
"TOPLEVEL_BINDING", "TRUE", "Thread", "ThreadError", "ThreadGroup",
"Time", "TrueClass", "TypeError", "UnboundMethod", "VERSION",
"ZeroDivisionError"]

module Miyako
  class Color
    RED = 1
  end
end

p Miyako::Color.const_defined?(:ARGF)   # => true

module Miyako
  class Color
    RED = 1
  end
end
p Miyako::Color.constants   # => ["RED"]

module Miyako
  class AbstractColor
    CONST = "全然関係ない定数"
  end

  class Color < AbstractColor
    RED = 1
  end
end

p Miyako::Color.constants   # => ["RED", "CONST"]

    def Color.str2rgb(str)
      case str
      when /\A\[?\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\]?\z/
        [$1.to_i, $2.to_i, $3.to_i]
      when /\A\#[\da-fA-F]{6}\z/
        hex2rgb(str)
      else
        if constants().include?(str.upcase)
          const_get(str.upcase)
        else
          raise MiyakoError, "wrong color expression: #{str.inspect}"
        end
      end
    end

 COLORS = {
   'BLACK' => [  0,   0,   0],
   'WHITE' => [255, 255, 255],
   'RED'   => [255,   0,   0],
     :
     :
 }

  osn = Config::CONFIG["target_os"].downcase
  @@osName = osn =~ /win/ ? "win" : (osn =~ /linux/ ? "linux" : "other")

/mswin(?!ce)|mingw|cygwin|bccwin/

$ ls daybook/**/*.rb
daybook/base/daybook_lib.rb
daybook/base/daybook_mod.rb
daybook/base/daybook_print.rb
daybook/daybook.rb
daybook/daybook_admin_review.rb
daybook/daybook_comment.rb
daybook/daybook_cont.rb
daybook/daybook_google.rb
daybook/daybook_logmail.rb
daybook/daybook_new.rb
daybook/daybook_search.rb
daybook/daybook_viewindex.rb
daybook/index/d_index.rb
daybook/newpost/d_check.rb
daybook/newpost/d_commentmail.rb
daybook/newpost/d_new.rb
daybook/newpost/d_params.rb
daybook/owner/d_google.rb
daybook/owner/d_remake.rb
daybook/search/d_search.rb

$ find daybook
daybook
daybook/bin
daybook/bin/cont.rb
daybook/bin/logmail.rb
daybook/bin/admin_review.rb
daybook/bin/new.rb
daybook/bin/google.rb
daybook/bin/search.rb
daybook/bin/viewindex.rb
daybook/bin/comment.rb
daybook/lib
daybook/lib/daybook
daybook/lib/daybook/htmlremake.rb
daybook/lib/daybook/makexml.rb
daybook/lib/daybook/getparams.rb
daybook/lib/daybook/mainbase.rb
daybook/lib/daybook/checkpath.rb
daybook/lib/daybook/checkuri.rb
daybook/lib/daybook/newpost.rb
daybook/lib/daybook/googlesitemap.rb
daybook/lib/daybook/readwrite.rb
daybook/lib/daybook/print.rb
daybook/lib/daybook/commentmail.rb
daybook/lib/daybook/mysearch.rb
daybook/lib/daybook/newindex.rb
daybook/lib/daybook.rb
daybook/config

 /var/www/tree/                    DocumentRoot
 /var/www/tree/wiki/               CGI を動かすディレクトリ
 /var/www/tree/wiki/index.cgi      CGI プログラム (実行可能ファイル)
 /var/www/tree/wiki/config         設定ファイル
 /usr/local/lib/bitchannel/        ソースコード
 /usr/local/lib/bitchannel/lib/    ライブラリ (*.rb)
 /var/bitchannel/                  データ

$ for i (*/*.rb) {
>   echo "----- $i"
>   rdefs --class $i
>   echo
> }
----- base/daybook_lib.rb
class MainBase

----- base/daybook_mod.rb
module CheckPath
module ReadWrite
module MakeXML
  include REXML

----- base/daybook_print.rb
module PrintMessage
class DaybookPrint
include PrintMessage

----- index/d_index.rb
class NewIndex
  include MakeXML
  include ReadWrite

----- newpost/d_check.rb
class CheckURI

----- newpost/d_commentmail.rb
class DaybookCommentMail
  include ReadWrite

----- newpost/d_new.rb
class NewPost
  include MakeXML
  include ReadWrite

----- newpost/d_params.rb
class GetParams

----- owner/d_google.rb
class GoogleSiteMap
  include MakeXML
  include ReadWrite

----- owner/d_remake.rb
class HTMLRemake
  include CheckPath
  include MakeXML
  include ReadWrite

----- search/d_search.rb
class MySearch
  include MakeXML
  include ReadWrite

module Daybook
  class MainBase
  end
end

p Daybook::MainBase.new   # モジュールの外からアクセスするときは「::」を使う

$ rdefs --class lib/daybook/*.rb
module Daybook
  module CheckPath
module Daybook
  class CheckURI
module Daybook
  class CommentMail
    include ReadWrite
module Daybook
  class GetParams
module Daybook
  class GoogleSiteMap
    include MakeXML
    include ReadWrite
module Daybook
  class HTMLRemake
    include CheckPath
    include MakeXML
    include ReadWrite
module Daybook
  class MainBase
module Daybook
  module MakeXML
    include REXML
module Daybook
  class MySearch
    include MakeXML
    include ReadWrite
module Daybook
  class NewIndex
    include MakeXML
    include ReadWrite
module Daybook
  class NewPost
    include MakeXML
    include ReadWrite
module DayBook
  module PrintMessage
  class Print
    include PrintMessage
module Daybook
  module ReadWrite

#!/usr/local/bin/ruby
#  encoding: utf-8
#  daybook.rb

#!/usr/local/bin/ruby
#  encoding: utf-8
#  daybook_lib.rb

#!/usr/local/bin/ruby
#  encoding: utf-8
#  d_index.rb

    h_sort.each{|aray|

      item_comment = REXML::Element.new( "item_comment" )
      v = aray[1]
      v.each{|i| i_name = item_comment.add_element(i.name); i_name.add_text(i.text) }
      comments.add_element(item_comment)
      }
    #----------
    return comments
  end
  def p_admin_xml_make(archives_list_targetxml)
    h = Hash.new{|h, key| h[key] = []}
    archivesdoc = m_make_new_xml("archives")
    docroot = archivesdoc.root
    meta = docroot.add_element("metadate")
    meta.add_text(Time.now.to_s)
    docroot.add_text("\n")
    items = docroot.add_element("items")
    #----------
    archives_list_targetxml.each{|f|
     onefiledoc = Document.new(File.new( f ))
     entry = REXML::Element.new( "entry" )
     @list_element.each{|e| entry.add_element(onefiledoc.elements[e]) unless onefiledoc.elements[e].nil? }

     onefiledoc.root.get_elements('item_comment').each{|com|
       comments = REXML::Element.new( "comments" )
       comments.add_element(com.elements["date"])
       comments.add_element(com.elements["postno"])
       comments.add_element(com.elements["name"])
       entry.add_element(comments)
       }

     y = onefiledoc.root.elements['meta/metadate/d_y'].text

  def p_index_xml_make(list_targetxml)
    indexdoc = m_make_new_xml("daybookindex")

    docroot = indexdoc.root; docroot.add_text("\n")
    meta = docroot.add_element("metadate")
    meta.add_text(Time.now.to_s); docroot.add_text("\n")

      v.each{|i| i_name = item_comment.add_element(i.name); i_name.add_text(i.text) }

      v.each {|i|
        i_name = item_comment.add_element(i.name)
        i_name.add_text(i.text)
      }

$ rdefs daybook/lib/daybook/checkuri.rb
module Daybook
  class CheckURI
    def initialize(myhash)
    def daybook_comment_check
    def daybook_newpage_check
    def daybook_search_check
    private
    def p_check_script_name(ref_buttonname, env_buttonname, error_list)
    def p_check_host(ref, uri, error_list)
    def p_check_path(ref, uri, error_list)
    def p_check_index_ref(ref, uri, error_list)

  def daybook_comment_check
    require "uri";error_list = Hash.new

 def comment_sendmail(para_data)
   body = ["\n\n",Time.now.to_s,"--\n"]
    para_data.each{|key ,value| body << ["[","#{key}", ",", "#{value}","]"].to_s }
    body << "\n"
    str_mail = p_make_body(body.to_s)

    require 'net/smtp'

 def p_make_body(body)
   require "nkf"

    para_data.each{|key ,value| body << ["[","#{key}", ",", "#{value}","]"].to_s }

    para_data.each{|key, value| body << "[#{key},#{value}]" }

    params.each do |key, value|
      body << "[#{key},#{value}]"
    end

  SAFE = 3

      a_time = File.atime(html) if FileTest.exist?(html)

  def m_write_file(path_file, str)
    begin
      File.open(path_file, File::WRONLY | File::CREAT){|w|
      w.flock(File::LOCK_EX)
      w.print str
      }
    rescue SystemCallError
      $stderr.print "IO failes: " + $!
      raise
    end
  end

 def m_read_xml(path_xml)
   doc = Document.new()
   doc << XMLDecl.new(version="1.0", encoding="UTF-8" )
   doc.add_text("\n")

   sourcedoc = Document.new(File.new( path_xml ))
   docroot = sourcedoc.root
   doc.add_element(docroot)

   return  doc

 end

   sourcedoc = File.open(path_xml) {|f|
     f.flock(File::LOCK_SH)
     Document.new(f)
   }

$ grep initialize daybook/*.rb
daybook/checkuri.rb:    def initialize(myhash)
daybook/commentmail.rb:    def initialize(myhash)
daybook/getparams.rb:    def initialize
daybook/googlesitemap.rb:    def initialize(myhash)
daybook/htmlremake.rb:    def initialize(myhash)
daybook/mainbase.rb:    def initialize(mod)
daybook/mysearch.rb:    def initialize(myhash)
daybook/newindex.rb:    def initialize(myhash)
daybook/newpost.rb:    def initialize(myhash)

$ rdefs lisp.rb
def getToken
def parse0
def parse
def pr(x)
def define(x) #関数定義
def findVar(x, env)
def evlis(l, env)
def eval(x, env)

    while l.gsub!(/[^\010][\010]/,"") do end

while l.gsub!(/[^\010][\010]/, '')
  ;
end

    if l =~ /^;.*$/ #コメント
      print "-"
      next
    end

    l.chomp.scan(/\s+|;.*$|([^()' ]+|.)/){|s,| @buf.push s if s}

$ ruby lisp.rb
-> ;                行頭からコメントを書くと次の行のプロンプトは「->」
->  ;               行頭に空白を入れると次の行のプロンプトは「>」
>

def pr(x)
  case x
  when Integer, String then x.to_s   #数字 アトム
  when Array #リスト
    res = "("
    if x != []
      res << pr(x[0])
      x = x[1]
      while x.class == Array && x != [] do
        res << " #{pr(x[0])}"
        x = x[1]
      end
      res << " . #{pr(x)}" if x != []
    end
    res << ")"
  end
end

    when "if"
      if eval(x[1][0], env) != []
        eval(x[1][1][0], env)
      else
        eval(x[1][1][1][0], env)
      end
    when "while"
      while eval(x[1][0], env) != [] do
        eval(x[1][1][0], env)
      end

def define(x) #関数定義
  @fenv = [[x[1][0], [x[1][1][0], x[1][1][1][0]]]].concat(@fenv)
  x[1][0]
end

        if f = @fenv.assoc(x[0])