-

The above thread showed finally the need to split the evaluation down
into smaller chunks.

Here is a simple evaluation template (first part) which can be applied
to the Ruby language:

http://lazaridis.com/case/lang/index.html

If you like, please post the most elegant solutions (either to sections
or to the whole document).

I will collect the results and write them down in a document, which will
compare ruby with other languages.

This document can serve as an flash-start (for people which simply like
to take a look on ruby).

http://lazaridis.com/case/lang/ruby.html

.

# here's your basic talker class

class Talker
  def sayHello
    puts "Hello world"
  end
end

# __FILE__ == $0 means that the program is being run directly
# rather than 'require'd from another file

if __FILE__ == $0
  talker = Talker.new
  talker.sayHello
end

# one-pass interpreter, and you can reopen classes
# so let's just continue

# here are the two instance variables added to the class, complete with
# autogenerated getters and setters

class Talker
  attr_accessor :name, :age

  def initialize(name, age)
    @name, @age = name, age
  end

  # following the spec, though say_name is more rubyish
  def sayYourName
    puts @name
  end

  def sayYourAge
    puts @age
  end
end

# now note that our object 'talker' has access to the new methods in its
# class

if __FILE__ == $0
  # note that we aren't breaking encapsulation and accessing the vars directly;
  # the setter methods are called name= and age=, and the getters are called
  # name and age
  talker.name = "Just another talker"
  talker.age = 1
  talker.sayYourName
  talker.sayYourAge
end

# reflection
class Talker

  # simple

  def sayYourClassName
    puts self.class.name # the 'self' is optional here
  end

  # objects know nothing about the variables that are bound to them
  # (a variable name is not the name of the instance anyway). The
  # closest you can come to the "name" of an object is it's object id, so...
  def sayYourInstanceName
    puts object_id # again, you could say self.object_id if you prefer
  end

  # advanced

  # caller returns a stack (array) of strings of the form
  #   file:linenumber in `method'
  # so we extract the most recent one and parse the method name out
  # code from PLEAC
  def thisMethodName
    caller[0] =~ /in `([^']+)'/ ? $1 : '(anonymous)';
  end

  # string interpolation in action - the bit between the #{} can be
  # any valid expression; to_s will be called on the result and
  # interpolated into the string
  def sayHelloAdvanced
    puts "#{thisMethodName}: Hello World"
  end

  # expert
  def sayYourClassDefinition
    puts "Class:"
    sayYourClassName

    # %{} is another way to write a string literal
    # (looks neat for multiline strings)
    # we use the standard 'inspect' method to print out arrays of
    # method names in a ["meth1", "meth2", ...] format
    puts %{
Methods:
  public:
    #{public_methods.inspect}
  protected
    #{protected_methods.inspect}
  private:
    #{private_methods.inspect}
  non-inherited:
    #{(methods - self.class.superclass.instance_methods).inspect}

  Instance Variables:
    #{instance_variables.inspect}
    }

    # note that the instance variables belong to the *instance*, not
    # to the class, so they're not technically part of the class
    # definition. the following code is illustrative:
    #
    # class A
    #   attr_accessor :foo, :bar # defines getters and setters
    # end
    #
    # a = A.new
    # p a.instance_variables # => []
    # a.foo = 10
    # p a.instance_variables # => ["@foo"]
    # b = A.new
    # p b.instance_variables # => []
  end

  def sayYourClassCode
    puts "Sadly, you cannot introspect the source code from within a program"
    # though see http://rubyforge.org/projects/parsetree/
    # for a way to get at the parsed AST
  end
end

# testing it out

if __FILE__ == $0
  talker.sayHelloAdvanced
  talker.sayYourClassName
  talker.sayYourClassDefinition
  talker.sayYourClassCode
end

Hope this helps.

from the command-line, i like to start it, e.g. with "ruby talker.rb"

I miss a "main" directive / function / object.

something like:

def main
    talker = Talker.new
    talker.sayHello
end

attr_accessor :name
attr_accessor :age

 >   def initialize(name, age)
 >     @name, @age = name, age
 >   end

Is this the constructor?

I assume I can write

    def initialize(name, age)
      @name = name
      @age  = age
    end

seperate message will follow.

.

# first time setting the class
class Talker
  attr_accessor :name

  def initialize(name)
    @name = name
  end

end

talker = Talker.new('Bob')
puts talker.name

# reopen the class to add sayYourName
class Talker
  def sayYourName
    puts @name
  end
end

talker.sayYourName

The output is:

Bob
Bob

def sayYourName; puts @name; end

class Foo
  def say_hello
    puts "hello world"
  end

  puts "hi, this is the reader"
end

a = Foo.new
a.say_hello

the first puts statement gets executed when say_hello is called; the second
one is not inside a def statement, and so gets executed when the interpreter
gets to it.

Hence the lack of a main() method - in a sense, the whole fine is a main(),
since the entry point is the top of the file (comes in real handy when
writing quick imperative scripts - you aren't forced to define a class just
because Ruby is a pure OO language).

Hence the if __FILE__ == $0 blocks - if the file is not being run directly,
the condition fails, and the whole block is skipped.

As for reopening classes, you can modify a class at runtime (add/delete
methods, mix in a module), and any objects belonging to the class inherit
those modifications (rather trivially, since they look up methods in the
class). But, since this is a one pass interpreter, those changes come into
effect at the time the reader reads them, and so the object "changes" in the
middle of its lifecycle.

This means that ruby is _not_ strictly Object Oriented.

And this means that I can drop the "if __FILE__ [...]" construct.

I like both points.

-

I assume I can launch my application with "ruby talker.rb".

Thank you for you explanations.

I've understood now everything.

Altough I'm excited about some contructs, I must postpone their discussion.

I'll come back to them soon.

.

So this construct just checks if this the source file is the file that
is executed directly with e.g. 'ruby talker.rb', and only if this is the
case, the codeblock will be executed.

$0 => main-file (or entry-file, or top-level file, or top-level program)

I would like to setup ruby at this point, to add the installation steps
to the document.

Can one suggest me the simplest possible installation (one-click)?

One for Windows and one for Linux (if possible similar in content)?

.

http://rubyforge.org/frs/?group_id=167

and for Linux:

http://rubyforge.org/frs/?group_id=426

Yours,

The application main code will be alternatively entered in a seperate
file, main.rb:

-

[...]

"#" is used as a comment marker _and_ partly within code.

Can I use another comment marker?

Can I write "puts "#{thisMethodName}: Hello World"" in an different
manner, without the use of "#"?

.

  require 'talker'

  talker = Talker.new
  talker.sayHello

for my main.rb. Note that the require statement does not need the .rb
suffix on the file containing the class.

  puts thisMethodName.to_s + ": Hello World"

The + operator performs concatenation when its arguments are strings.

=begin
bla bla
bla
=end

=begin
        This is a comment.
=end

Just FYI.

preliminary draft:

http://lazaridis.com/case/lang/ruby.html

is there possibly a more direct solution available, with cleaner code
and a stable/higher execution speed?

but

     puts "Class #{sayYourClassName}" >> Talker Class
     puts "Class " + sayYourClassName.to_s >> Talker Class

why?

thank you for your efforts.

James Edward Gray II wrote:

caller.active_method

%{} => string
#{} => string interpolation of code

-

I will try to work this out myself.

Where can I find the following information?:

   * An UML diagramm (or another visual representation) of the ruby
class-model.

   * A deep (but compact) description of the reflection/introspection api's.

http://flgr.0x42.net/class-graph.png

Note that it is quite large and not too pretty, though.

http://www.rubycentral.com/book/ (first issue)
http://phrogz.net/ProgrammingRuby/ (first issue with Wiki for changes)
http://www.pragmaticprogrammer.com/titles/ruby/index.html (second issue)
http://www.amazon.com/exec/obidos/tg/detail/-/0974514055/ (second issue)

Does anyone has the detailed model of the core class-model?

I need at this point only reference of the reflection/introspection api.

I cannot locate it.

.

-

btw:

found this ppt-presentation about the object-model (but would prefere an
UML diagramm):

http://rubyforge.org/docman/view.php/251/96/ChrisPine_UROM.ppt

.

I've reviewed a little the documentation, but find nothing about metadata.

Is there a standard way to apply metadata/annotations to my class
Talker, its Methods, its Attributes?

E.g.:

class Talker

   attr_accessor :name # Type = String; Label = Name; Size = 30;
   attr_accessor :age  # Type = int;    Label = Age;  Min=1; Max=150;

   def sayYourName
   end
end

-

"attr_accessor" does not work on class variables (e.g. @@count).

Must I create @@var/getter/setter manually?

.

irb(main):001:0> class MyClass
irb(main):002:1> class << self
irb(main):003:2> attr_accessor :test
irb(main):004:2> end
irb(main):005:1> end
=> nil
irb(main):006:0> MyClass.test = 501
=> 501
irb(main):007:0> MyClass.test
=> 501

There is a gotcha though:

irb(main):008:0> class MyClass
irb(main):009:1> def test_method
irb(main):010:2> @@test
irb(main):011:2> end
irb(main):012:1> end
=> nil
irb(main):013:0> MyClass.new.test_method
NameError: uninitialized class variable @@test in MyClass
         from (irb):10:in `test_method'
         from (irb):14
         from :0

You can see that this technique does not use @@test.

All of this is just playing around though.  If you seriously need to
define class accessors a lot and can't be bothered to type:

def self.test(  ) @@test end
def self.test=( value ) @@test = value end

Most editors I've ever seen will allow you to macro that and assign it
to a single keystroke.

My opinion, feel free to completely ignore, is that you've strayed
pretty far from "evaluating Ruby" when you worry about details like
this.  We can sit here and show you examples like the above
indefinitely, exploring all corners of the language.  There's no
substitute for just learning the language and seeing what it can do for
you though, and this is a poor way to go about that.

ok

-

Where can I find the implementation of "attr_accessor"?

I'm intrested in seeing how much effort it is to write an own
"flex_attr_accessor".

[I will possibly include this in the evaluation template, section
"language extension"]

Ruby looks very nice till now, although I've hit already some limitations:

http://lazaridis.com/case/lang/ruby.html

.