From 5548c7bff292de16abb9f6e8d9cc4999e0b22c71 Mon Sep 17 00:00:00 2001
From: "(no author)" <(no author)@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>
Date: Sat, 3 Jul 2004 15:38:36 +0000
Subject: This commit was manufactured by cvs2svn to create branch 'ruby_1_8'.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8@6568 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
---
 lib/xsd/codegen.rb            |  12 +++
 lib/xsd/codegen/classdef.rb   | 203 ++++++++++++++++++++++++++++++++++++++++++
 lib/xsd/codegen/commentdef.rb |  34 +++++++
 lib/xsd/codegen/gensupport.rb | 112 +++++++++++++++++++++++
 lib/xsd/codegen/methoddef.rb  |  63 +++++++++++++
 lib/xsd/codegen/moduledef.rb  | 191 +++++++++++++++++++++++++++++++++++++++
 6 files changed, 615 insertions(+)
 create mode 100644 lib/xsd/codegen.rb
 create mode 100644 lib/xsd/codegen/classdef.rb
 create mode 100644 lib/xsd/codegen/commentdef.rb
 create mode 100644 lib/xsd/codegen/gensupport.rb
 create mode 100644 lib/xsd/codegen/methoddef.rb
 create mode 100644 lib/xsd/codegen/moduledef.rb

(limited to 'lib/xsd')

diff --git a/lib/xsd/codegen.rb b/lib/xsd/codegen.rb
new file mode 100644
index 0000000000..d820ebf1f2
--- /dev/null
+++ b/lib/xsd/codegen.rb
@@ -0,0 +1,12 @@
+# XSD4R - Generating code library
+# Copyright (C) 2004  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'xsd/codegen/gensupport'
+require 'xsd/codegen/moduledef'
+require 'xsd/codegen/classdef'
+require 'xsd/codegen/methoddef'
diff --git a/lib/xsd/codegen/classdef.rb b/lib/xsd/codegen/classdef.rb
new file mode 100644
index 0000000000..8f72e95efd
--- /dev/null
+++ b/lib/xsd/codegen/classdef.rb
@@ -0,0 +1,203 @@
+# XSD4R - Generating class definition code
+# Copyright (C) 2004  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'xsd/codegen/gensupport'
+require 'xsd/codegen/moduledef'
+require 'xsd/codegen/methoddef'
+
+
+module XSD
+module CodeGen
+
+
+class ClassDef < ModuleDef
+  include GenSupport
+
+  def initialize(name, baseclass = nil)
+    super(name)
+    @baseclass = baseclass
+    @classvar = []
+    @attrdef = []
+  end
+
+  def def_classvar(var, value)
+    var = var.sub(/\A@@/, "")
+    unless safevarname?(var)
+      raise ArgumentError.new("#{var} seems to be unsafe")
+    end
+    @classvar << [var, value]
+  end
+
+  def def_attr(attrname, writable = true, varname = nil)
+    unless safevarname?(varname || attrname)
+      raise ArgumentError.new("#{varname || attrname} seems to be unsafe")
+    end
+    @attrdef << [attrname, writable, varname]
+  end
+
+  def dump
+    buf = ""
+    unless @requirepath.empty?
+      buf << dump_requirepath 
+    end
+    buf << dump_emptyline unless buf.empty?
+    package = @name.split(/::/)[0..-2]
+    buf << dump_package_def(package) unless package.empty?
+    buf << dump_comment if @comment
+    buf << dump_class_def
+    spacer = false
+    unless @classvar.empty?
+      spacer = true
+      buf << dump_classvar
+    end
+    unless @const.empty?
+      buf << dump_emptyline if spacer
+      spacer = true
+      buf << dump_const
+    end
+    unless @code.empty?
+      buf << dump_emptyline if spacer
+      spacer = true
+      buf << dump_code
+    end
+    unless @attrdef.empty?
+      buf << dump_emptyline if spacer
+      spacer = true
+      buf << dump_attributes
+    end
+    unless @methoddef.empty?
+      buf << dump_emptyline if spacer
+      spacer = true
+      buf << dump_methods
+    end
+    buf << dump_class_def_end
+    buf << dump_package_def_end(package) unless package.empty?
+    buf
+  end
+
+private
+
+  def dump_class_def
+    name = @name.to_s.split(/::/)
+    if @baseclass
+      format("class #{name.last} < #{@baseclass}")
+    else
+      format("class #{name.last}")
+    end
+  end
+
+  def dump_class_def_end
+    str = format("end")
+  end
+
+  def dump_classvar
+    dump_static(
+      @classvar.collect { |var, value|
+        %Q(@@#{var.sub(/^@@/, "")} = #{dump_value(value)})
+      }.join("\n")
+    )
+  end
+
+  def dump_attributes
+    str = ""
+    @attrdef.each do |attrname, writable, varname|
+      varname ||= attrname
+      if attrname == varname
+        str << format(dump_accessor(attrname, writable), 2)
+      end
+    end
+    @attrdef.each do |attrname, writable, varname|
+      varname ||= attrname
+      if attrname != varname
+        str << "\n" unless str.empty?
+        str << format(dump_attribute(attrname, writable, varname), 2)
+      end
+    end
+    str
+  end
+
+  def dump_accessor(attrname, writable)
+    if writable
+      "attr_accessor :#{attrname}"
+    else
+      "attr_reader :#{attrname}"
+    end
+  end
+
+  def dump_attribute(attrname, writable, varname)
+    str = nil
+    mr = MethodDef.new(attrname)
+    mr.definition = "@#{varname}"
+    str = mr.dump
+    if writable
+      mw = MethodDef.new(attrname + "=", 'value')
+      mw.definition = "@#{varname} = value"
+      str << "\n" + mw.dump
+    end
+    str
+  end
+end
+
+
+end
+end
+
+
+if __FILE__ == $0
+  require 'xsd/codegen/classdef'
+  include XSD::CodeGen
+  c = ClassDef.new("Foo::Bar::HobbitName", String)
+  c.def_require("foo/bar")
+  c.comment = <<-EOD
+      foo
+    bar
+      baz
+  EOD
+  c.def_const("FOO", 1)
+  c.def_classvar("@@foo", "var".dump)
+  c.def_classvar("baz", "1".dump)
+  c.def_attr("Foo", true, "foo")
+  c.def_attr("bar")
+  c.def_attr("baz", true)
+  c.def_attr("Foo2", true, "foo2")
+  c.def_attr("foo3", false, "foo3")
+  c.def_method("foo") do
+    <<-EOD
+        foo.bar = 1
+\tbaz.each do |ele|
+\t  ele
+        end
+    EOD
+  end
+  c.def_method("baz", "qux") do
+    <<-EOD
+      [1, 2, 3].each do |i|
+        p i
+      end
+    EOD
+  end
+
+  m = MethodDef.new("qux", "quxx", "quxxx") do
+    <<-EOD
+    p quxx + quxxx
+    EOD
+  end
+  m.comment = "hello world\n123"
+  c.add_method(m)
+  c.def_code <<-EOD
+    Foo.new
+    Bar.z
+  EOD
+  c.def_code <<-EOD
+    Foo.new
+    Bar.z
+  EOD
+  c.def_privatemethod("foo", "baz", "*arg", "&block")
+
+  puts c.dump
+end
diff --git a/lib/xsd/codegen/commentdef.rb b/lib/xsd/codegen/commentdef.rb
new file mode 100644
index 0000000000..f98fade57d
--- /dev/null
+++ b/lib/xsd/codegen/commentdef.rb
@@ -0,0 +1,34 @@
+# XSD4R - Generating comment definition code
+# Copyright (C) 2004  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'xsd/codegen/gensupport'
+
+
+module XSD
+module CodeGen
+
+
+module CommentDef
+  include GenSupport
+
+  attr_accessor :comment
+
+private
+
+  def dump_comment
+    if /^#/ =~ @comment
+      format(@comment)
+    else
+      format(@comment).gsub(/^/, "# ")
+    end
+  end
+end
+
+
+end
+end
diff --git a/lib/xsd/codegen/gensupport.rb b/lib/xsd/codegen/gensupport.rb
new file mode 100644
index 0000000000..df90550fa0
--- /dev/null
+++ b/lib/xsd/codegen/gensupport.rb
@@ -0,0 +1,112 @@
+# XSD4R - Code generation support
+# Copyright (C) 2004  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+module XSD
+module CodeGen
+
+
+module GenSupport
+  def capitalize(target)
+    target.sub(/^([a-z])/) { $1.tr!('[a-z]', '[A-Z]') }
+  end
+  module_function :capitalize
+
+  def uncapitalize(target)
+    target.sub(/^([A-Z])/) { $1.tr!('[A-Z]', '[a-z]') }
+  end
+  module_function :uncapitalize
+
+  def safeconstname(name)
+    safename = name.scan(/[a-zA-Z0-9_]+/).collect { |ele|
+      GenSupport.capitalize(ele)
+    }.join
+    unless /^[A-Z]/ =~ safename
+      safename = "C_#{safename}"
+    end
+    safename
+  end
+  module_function :safeconstname
+
+  def safeconstname?(name)
+    /\A[A-Z][a-zA-Z0-9_]*\z/ =~ name
+  end
+  module_function :safeconstname?
+
+  def safemethodname(name)
+    safevarname(name)
+  end
+  module_function :safemethodname
+
+  def safemethodname?(name)
+    /\A[a-zA-Z_][a-zA-Z0-9_]*[=!?]?\z/ =~ name
+  end
+  module_function :safemethodname?
+
+  def safevarname(name)
+    safename = name.scan(/[a-zA-Z0-9_]+/).join('_')
+    safename = uncapitalize(safename)
+    unless /^[a-z]/ =~ safename
+      safename = "m_#{safename}"
+    end
+    safename
+  end
+  module_function :safevarname
+
+  def safevarname?(name)
+    /\A[a-z_][a-zA-Z0-9_]*\z/ =~ name
+  end
+  module_function :safevarname?
+
+  def format(str, indent = nil)
+    str = trim_eol(str)
+    str = trim_indent(str)
+    if indent
+      str.gsub(/^/, " " * indent)
+    else
+      str
+    end
+  end
+
+private
+
+  def trim_eol(str)
+    str.collect { |line|
+      line.sub(/\r?\n$/, "") + "\n"
+    }.join
+  end
+
+  def trim_indent(str)
+    indent = nil
+    str = str.collect { |line| untab(line) }.join
+    str.each do |line|
+      head = line.index(/\S/)
+      if !head.nil? and (indent.nil? or head < indent)
+        indent = head
+      end
+    end
+    return str unless indent
+    str.collect { |line|
+      line.sub(/^ {0,#{indent}}/, "")
+    }.join
+  end
+
+  def untab(line, ts = 8)
+    while pos = line.index(/\t/)
+      line = line.sub(/\t/, " " * (ts - (pos % ts)))
+    end
+    line
+  end
+
+  def dump_emptyline
+    "\n"
+  end
+end
+
+
+end
+end
diff --git a/lib/xsd/codegen/methoddef.rb b/lib/xsd/codegen/methoddef.rb
new file mode 100644
index 0000000000..797a4f024e
--- /dev/null
+++ b/lib/xsd/codegen/methoddef.rb
@@ -0,0 +1,63 @@
+# XSD4R - Generating method definition code
+# Copyright (C) 2004  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'xsd/codegen/gensupport'
+require 'xsd/codegen/commentdef'
+
+
+module XSD
+module CodeGen
+
+
+class MethodDef
+  include GenSupport
+  include CommentDef
+
+  attr_accessor :definition
+
+  def initialize(name, *params)
+    unless safemethodname?(name)
+      raise ArgumentError.new("#{name} seems to be unsafe")
+    end
+    @name = name
+    @params = params
+    @comment = nil
+    @definition = yield if block_given?
+  end
+
+  def dump
+    buf = ""
+    buf << dump_comment if @comment
+    buf << dump_method_def
+    buf << dump_definition if @definition
+    buf << dump_method_def_end
+    buf
+  end
+
+private
+
+  def dump_method_def
+    if @params.empty?
+      format("def #{@name}")
+    else
+      format("def #{@name}(#{@params.join(", ")})")
+    end
+  end
+
+  def dump_method_def_end
+    format("end")
+  end
+
+  def dump_definition
+    format(@definition, 2)
+  end
+end
+
+
+end
+end
diff --git a/lib/xsd/codegen/moduledef.rb b/lib/xsd/codegen/moduledef.rb
new file mode 100644
index 0000000000..dc2746b2ee
--- /dev/null
+++ b/lib/xsd/codegen/moduledef.rb
@@ -0,0 +1,191 @@
+# XSD4R - Generating module definition code
+# Copyright (C) 2004  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'xsd/codegen/gensupport'
+require 'xsd/codegen/methoddef'
+require 'xsd/codegen/commentdef'
+
+
+module XSD
+module CodeGen
+
+
+class ModuleDef
+  include GenSupport
+  include CommentDef
+
+  def initialize(name)
+    @name = name
+    @comment = nil
+    @const = []
+    @code = []
+    @requirepath = []
+    @methoddef = []
+  end
+
+  def def_require(path)
+    @requirepath << path
+  end
+
+  def def_const(const, value)
+    unless safeconstname?(const)
+      raise ArgumentError.new("#{const} seems to be unsafe")
+    end
+    @const << [const, value]
+  end
+
+  def def_code(code)
+    @code << code
+  end
+
+  def def_method(name, *params)
+    add_method(MethodDef.new(name, *params) { yield if block_given? }, :public)
+  end
+  alias def_publicmethod def_method
+
+  def def_protectedmethod(name, *params)
+    add_method(MethodDef.new(name, *params) { yield if block_given? },
+      :protected)
+  end
+
+  def def_privatemethod(name, *params)
+    add_method(MethodDef.new(name, *params) { yield if block_given? }, :private)
+  end
+
+  def add_method(m, visibility = :public)
+    @methoddef << [visibility, m]
+  end
+
+  def dump
+    buf = ""
+    unless @requirepath.empty?
+      buf << dump_requirepath 
+    end
+    buf << dump_emptyline unless buf.empty?
+    package = @name.split(/::/)[0..-2]
+    buf << dump_package_def(package) unless package.empty?
+    buf << dump_comment if @comment
+    buf << dump_module_def
+    spacer = false
+    unless @const.empty?
+      buf << dump_emptyline if spacer
+      spacer = true
+      buf << dump_const
+    end
+    unless @code.empty?
+      buf << dump_emptyline if spacer
+      spacer = true
+      buf << dump_code
+    end
+    unless @methoddef.empty?
+      buf << dump_emptyline if spacer
+      spacer = true
+      buf << dump_methods
+    end
+    buf << dump_module_def_end
+    buf << dump_package_def_end(package) unless package.empty?
+    buf
+  end
+
+private
+
+  def dump_requirepath
+    format(
+      @requirepath.collect { |path|
+        %Q(require '#{path}')
+      }.join("\n")
+    )
+  end
+
+  def dump_const
+    dump_static(
+      @const.sort.collect { |var, value|
+        %Q(#{var} = #{dump_value(value)})
+      }.join("\n")
+    )
+  end
+
+  def dump_code
+    dump_static(@code.join("\n"))
+  end
+
+  def dump_static(str)
+    format(str, 2)
+  end
+
+  def dump_methods
+    methods = {}
+    @methoddef.each do |visibility, method|
+      (methods[visibility] ||= []) << method
+    end
+    str = ""
+    [:public, :protected, :private].each do |visibility|
+      if methods[visibility]
+        str << "\n" unless str.empty?
+        str << visibility.to_s << "\n\n" unless visibility == :public
+        str << methods[visibility].collect { |m| format(m.dump, 2) }.join("\n")
+      end
+    end
+    str
+  end
+
+  def dump_value(value)
+    if value.respond_to?(:to_src)
+      value.to_src
+    else
+      value
+    end
+  end
+
+  def dump_package_def(package)
+    format(package.collect { |ele| "module #{ele}" }.join("; ")) + "\n\n"
+  end
+
+  def dump_package_def_end(package)
+    "\n\n" + format(package.collect { |ele| "end" }.join("; "))
+  end
+
+  def dump_module_def
+    name = @name.to_s.split(/::/)
+    format("module #{name.last}")
+  end
+
+  def dump_module_def_end
+    format("end")
+  end
+end
+
+
+end
+end
+
+
+if __FILE__ == $0
+  require 'xsd/codegen/moduledef'
+  include XSD::CodeGen
+  m = ModuleDef.new("Foo::Bar::HobbitName")
+  m.def_require("foo/bar")
+  m.def_require("baz")
+  m.comment = <<-EOD
+    foo
+    bar
+    baz
+  EOD
+  m.def_method("foo") do
+    <<-EOD
+      foo.bar = 1
+      baz.each do |ele|
+        ele + 1
+      end
+    EOD
+  end
+  m.def_method("baz", "qux")
+  #m.def_protectedmethod("aaa")
+  m.def_privatemethod("bbb")
+  puts m.dump
+end
-- 
cgit v1.2.3