fxri 0.3.2 → 0.3.3

data/lib/Recursive_Open_Struct.rb

@@ -16,218 +16,218 @@
 #
 #    ac.close
 #
-# After closing, 
+# After closing,
 #
 #    ac.widnow.name = "UberSuperDuper"
 #
 # You get the usual NoMethodError, because 'widnow' does not exist.
 #
 class Recursive_Open_Struct
-	# Create a new Recursive_Open_Struct.
-	def initialize
-		@methods = Hash.new
-		@open = true
-	end
-	
-	# automatically add parameters
-	def method_missing(method, *params) # :nodoc:
-		# setting or getting?
-		is_setting = !params.empty?
-		
-		key = method.id2name
-		# remove trailing =
-		key.chop! if is_setting 
-		
-		# if structure is closed, disable hierarchy creation
-		super unless @methods.has_key?(key) || @open
-		
-		if is_setting
-			# assigning a new value
-			if @methods[key].class == Recursive_Open_Struct
-				raise TypeError, "overwriting previously created hierarchy entry '#{key}' not allowed", caller(1)
-			end
-			@methods[key] = *params
-		else
-			# no param: create new Recursive_Open_Struct object, if nothing is set.
-			unless @methods.has_key?(key)
-				@methods[key] = Recursive_Open_Struct.new
-			end
-		end
-		@methods[key]
-	end
-	
-	# An alternative way to access the value of an attribute
-	#  s = Recursive_Open_Struct.new
-	#  s.name = "Hugo"
-	#  s["name"] # "Hugo"
-	def [](key) 
-		@methods[key]
-	end
-	
-	# An alternative way to set the value of an attribute
-	#  s = Recursive_Open_Struct.new
-	#  s["name"] = "Hugo"
-	#  s.name # "Hugo"
-	def []=(key, value)
-		self.send((key+"=").to_sym, value)
-	end
-	
-	# call-seq:
-	#  attrs() -> an_array
-	#
-	# Return a sorted array of attribute names, similar to #methods.
-	#
-	#  s = Recursive_Open_Struct.new
-	#  s.name = "martinus"
-	#  s.age = 25
-	#  s.attrs # returns ["age", "name"]
-	def attrs
-		@methods.keys.sort
-	end
-	
-	# After calling #close, no further modification of the configuration hierarchy
-	# is allowed. This is not as strict as #freeze, because you are still allowed
-	# to modify data.
-	#
-	#  s = Recursive_Open_Struct.new
-	#  s.name = "Hugo"
-	#  s.close
-	#  s.name = "martinus" # does still work
-	#  s.age = 25 # raises NoMethodError
-	def close
-		do_set_open_status(false)
-	end
-	
-	# Reopens a Recursive_Open_Struct which was closed with #close earlier.
-	# After this call, it is possible to modify the structure again.
-	def re_open
-		do_set_open_status(true)
-	end
-	
-	# call-seq:
-	#  open?() -> boolean
-	#
-	# Return whether the structure is still open or not.
-	#
-	#  s = Recursive_Open_Struct.new
-	#  s.open? # returns true
-	#  s.close
-	#  s.open? # returns false
-	def open?
-		@open
-	end
-	
-	# call-seq:
-	#  each() { |elem| ... }
-	#
-	# Iterates through all elements of the Recursive_Open_Struct in alphabetic order.
-	def each
-		attrs.each do |attr|
-			yield @methods[attr]
-		end
-	end
-	
-	protected
-	
-	def do_set_open_status(status)
-		@methods.each_value do |val|
-			val.do_set_open_status(status) if val.class == Recursive_Open_Struct
-		end
-		@open = status
-	end
+  # Create a new Recursive_Open_Struct.
+  def initialize
+    @methods = Hash.new
+    @open = true
+  end
+
+  # automatically add parameters
+  def method_missing(method, *params) # :nodoc:
+    # setting or getting?
+    is_setting = !params.empty?
+
+    key = method.id2name
+    # remove trailing =
+    key.chop! if is_setting
+
+    # if structure is closed, disable hierarchy creation
+    super unless @methods.has_key?(key) || @open
+
+    if is_setting
+      # assigning a new value
+      if @methods[key].class == Recursive_Open_Struct
+        raise TypeError, "overwriting previously created hierarchy entry '#{key}' not allowed", caller(1)
+      end
+      @methods[key] = *params
+    else
+      # no param: create new Recursive_Open_Struct object, if nothing is set.
+      unless @methods.has_key?(key)
+        @methods[key] = Recursive_Open_Struct.new
+      end
+    end
+    @methods[key]
+  end
+
+  # An alternative way to access the value of an attribute
+  #  s = Recursive_Open_Struct.new
+  #  s.name = "Hugo"
+  #  s["name"] # "Hugo"
+  def [](key)
+    @methods[key]
+  end
+
+  # An alternative way to set the value of an attribute
+  #  s = Recursive_Open_Struct.new
+  #  s["name"] = "Hugo"
+  #  s.name # "Hugo"
+  def []=(key, value)
+    self.send((key+"=").to_sym, value)
+  end
+
+  # call-seq:
+  #  attrs() -> an_array
+  #
+  # Return a sorted array of attribute names, similar to #methods.
+  #
+  #  s = Recursive_Open_Struct.new
+  #  s.name = "martinus"
+  #  s.age = 25
+  #  s.attrs # returns ["age", "name"]
+  def attrs
+    @methods.keys.sort
+  end
+
+  # After calling #close, no further modification of the configuration hierarchy
+  # is allowed. This is not as strict as #freeze, because you are still allowed
+  # to modify data.
+  #
+  #  s = Recursive_Open_Struct.new
+  #  s.name = "Hugo"
+  #  s.close
+  #  s.name = "martinus" # does still work
+  #  s.age = 25 # raises NoMethodError
+  def close
+    do_set_open_status(false)
+  end
+
+  # Reopens a Recursive_Open_Struct which was closed with #close earlier.
+  # After this call, it is possible to modify the structure again.
+  def re_open
+    do_set_open_status(true)
+  end
+
+  # call-seq:
+  #  open?() -> boolean
+  #
+  # Return whether the structure is still open or not.
+  #
+  #  s = Recursive_Open_Struct.new
+  #  s.open? # returns true
+  #  s.close
+  #  s.open? # returns false
+  def open?
+    @open
+  end
+
+  # call-seq:
+  #  each() { |elem| ... }
+  #
+  # Iterates through all elements of the Recursive_Open_Struct in alphabetic order.
+  def each
+    attrs.each do |attr|
+      yield @methods[attr]
+    end
+  end
+
+  protected
+
+  def do_set_open_status(status)
+    @methods.each_value do |val|
+      val.do_set_open_status(status) if val.class == Recursive_Open_Struct
+    end
+    @open = status
+  end
 end
 
 if __FILE__ == $0
-	require 'test/unit'
-	
-	class TestRecursiveOpenStruct < Test::Unit::TestCase
-		def setup
-			@s = Recursive_Open_Struct.new
-		end
-	
-		def setAndAssertValue(val)
-			@s.test = val
-			assert_equal(val, @s.test)
-			@s.close
-			assert_equal(val, @s.test)
-			@s.test = "asdf"
-			assert_equal("asdf", @s.test)
-		end
-		
-		def testSetNil
-			setAndAssertValue(nil)
-		end
-
-		def testSimple
-			@s.test = "xx"
-			@s.close
-			assert_equal("xx", @s.test)
-		end
-		
-		def testSetFalse
-			setAndAssertValue(false)
-		end
-		
-		def testSetStr
-			setAndAssertValue("topfen")
-		end
-		
-		def testSetClass
-			setAndAssertValue(String)
-		end
-		
-		def testSetTrue
-			setAndAssertValue(true)
-		end
-		
-		def testSet0
-			setAndAssertValue(0)
-		end
-		
-		def testRaiseTypeError
-			@s.a.b = 1
-			assert_raise(TypeError) do
-				@s.a = 3
-			end
-		end
-		
-		def testAttrs
-			assert_equal([], @s.attrs)
-			@s.b = "x"
-			@s.a = "a"
-			assert_equal(["a", "b"], @s.attrs)
-		end
-		
-		def testRecursive
-			@s.a.b = 1
-			@s.a.c = 2
-			assert_equal(["a"], @s.attrs)
-		end
-		
-		def testStrange
-			@s.a
-			assert_equal(["a"], @s.attrs)
-			assert_equal(Recursive_Open_Struct, @s.a.class)
-			@s.a.x = "asfd"
-			assert_equal("asfd", @s.a.x)
-		end
-		
-		def testKlammer
-			@s.a = "asdf"
-			assert_equal("asdf", @s["a"])
-			@s.b_x = "hog"
-			assert_equal("hog", @s["b_x"])
-			@s.c.b.a = 1234
-			assert_equal(1234, @s["c"]["b"]["a"])
-		end
-		
-		def testDeep
-			@s.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z = false
-			@s.close
-			assert_raise(NoMethodError) do
-				@s.blub = "hellow"
-			end
-			assert_equal(false, @s.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z)
-		end
-	end
+  require 'test/unit'
+
+  class TestRecursiveOpenStruct < Test::Unit::TestCase
+    def setup
+      @s = Recursive_Open_Struct.new
+    end
+
+    def setAndAssertValue(val)
+      @s.test = val
+      assert_equal(val, @s.test)
+      @s.close
+      assert_equal(val, @s.test)
+      @s.test = "asdf"
+      assert_equal("asdf", @s.test)
+    end
+
+    def testSetNil
+      setAndAssertValue(nil)
+    end
+
+    def testSimple
+      @s.test = "xx"
+      @s.close
+      assert_equal("xx", @s.test)
+    end
+
+    def testSetFalse
+      setAndAssertValue(false)
+    end
+
+    def testSetStr
+      setAndAssertValue("topfen")
+    end
+
+    def testSetClass
+      setAndAssertValue(String)
+    end
+
+    def testSetTrue
+      setAndAssertValue(true)
+    end
+
+    def testSet0
+      setAndAssertValue(0)
+    end
+
+    def testRaiseTypeError
+      @s.a.b = 1
+      assert_raise(TypeError) do
+        @s.a = 3
+      end
+    end
+
+    def testAttrs
+      assert_equal([], @s.attrs)
+      @s.b = "x"
+      @s.a = "a"
+      assert_equal(["a", "b"], @s.attrs)
+    end
+
+    def testRecursive
+      @s.a.b = 1
+      @s.a.c = 2
+      assert_equal(["a"], @s.attrs)
+    end
+
+    def testStrange
+      @s.a
+      assert_equal(["a"], @s.attrs)
+      assert_equal(Recursive_Open_Struct, @s.a.class)
+      @s.a.x = "asfd"
+      assert_equal("asfd", @s.a.x)
+    end
+
+    def testKlammer
+      @s.a = "asdf"
+      assert_equal("asdf", @s["a"])
+      @s.b_x = "hog"
+      assert_equal("hog", @s["b_x"])
+      @s.c.b.a = 1234
+      assert_equal(1234, @s["c"]["b"]["a"])
+    end
+
+    def testDeep
+      @s.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z = false
+      @s.close
+      assert_raise(NoMethodError) do
+        @s.blub = "hellow"
+      end
+      assert_equal(false, @s.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z)
+    end
+  end
 end

data/lib/RiManager.rb

@@ -3,153 +3,153 @@ require 'rdoc/ri/ri_driver'
 require 'pp'
 
 class NameDescriptor
-	CLASS = 0
-	INSTANCE_METHOD = 1
-	CLASS_METHOD = 2
-	def type
-		@method_name ||= false
-		@is_class_method ||= false
-		if @method_name
-			if @is_class_method
-				CLASS_METHOD
-			else
-				INSTANCE_METHOD
-			end
-		else
-			CLASS
-		end
-	end
-	
-	def to_s
-		str = ""
-		str << @class_names.join("::")
-		if @method_name && str != ""
-			str << (@is_class_method ? "::" : "#")
-		end
-		str << @method_name if @method_name
-		str
-	end
+  CLASS = 0
+  INSTANCE_METHOD = 1
+  CLASS_METHOD = 2
+  def type
+    @method_name ||= false
+    @is_class_method ||= false
+    if @method_name
+      if @is_class_method
+        CLASS_METHOD
+      else
+        INSTANCE_METHOD
+      end
+    else
+      CLASS
+    end
+  end
+
+  def to_s
+    str = ""
+    str << @class_names.join("::")
+    if @method_name && str != ""
+      str << (@is_class_method ? "::" : "#")
+    end
+    str << @method_name if @method_name
+    str
+  end
 end
 
 # This basically is a stripped down version of RiDriver.
 # I cannot use RiDriver directly, because I need to set the driver.
 class RiManager
-	def initialize(display, path = RI::Paths::PATH)
-		@reader = RI::RiReader.new(RI::RiCache.new(RI::Paths::PATH))
-		@display = display
-		@display.reader = @reader
-		# prepare all names
-		@all_names = prepare_all_names
-	end
-	
-	def prepare_all_names
-		names = Array.new
-		@reader.all_names.each do |name|
-			begin
-				names.push NameDescriptor.new(name)
-			rescue RiError => e
-				# silently ignore errors
-			end
-		end
-		names
-	end
-	
-	def check_names
-		@reader.all_names.each do |name|
-			begin
-				if (NameDescriptor.new(name).to_s != name)
-					p [name, NameDescriptor.new(name).to_s, NameDescriptor.new(name)]
-				end
-			rescue RiError => e
-				puts e
-			end
-		end
-	end
-	
-	# Returns all fully names as name descriptors
-	def all_names
-		@all_names
-	end
-	
-	# Searches for the description of a name and shows it using +display+.
-	def show(name_descriptor, width)
-		@display.width = width
-		# narrow down namespace
-		namespace = @reader.top_level_namespace
-		name_descriptor.class_names.each do |classname|
-			namespace = @reader.lookup_namespace_in(classname, namespace)
-			if namespace.empty?
-				raise RiError.new("Nothing known about #{name_descriptor}")
-			end
-		end
-		
-		# At this point, if we have multiple possible namespaces, but one
-		# is an exact match for our requested class, prune down to just it
-		# PS: this comment is shamlessly stolen from ri_driver.rb
-		entries = namespace.find_all {|m| m.full_name == name_descriptor.full_class_name}
-		namespace = entries if entries.size == 1
-		
-		if name_descriptor.method_name
-			methods = @reader.find_methods(name_descriptor.method_name, name_descriptor.is_class_method, namespace)
-			report_method_stuff(name_descriptor.method_name, methods)
-		else
-			report_class_stuff(namespace)
-		end
-	end
-	
-	def report_class_stuff(namespace)
-		raise RiError.new("namespace") unless namespace.size==1
-		@display.display_class_info @reader.get_class(namespace[0])
-	end
-	
-	def report_method_stuff(requested_method_name, methods)
-		if methods.size == 1
-			method = @reader.get_method(methods[0])
-			@display.display_method_info(method)
-		else
-			entries = methods.find_all {|m| m.name == requested_method_name}
-			if entries.size == 1
-				method = @reader.get_method(entries[0])
-				@display.display_method_info(method)
-			else
-				puts methods.map {|m| m.full_name}.join(", ")
-			end
-		end
-=begin	
-	
-		method = if (methods.size == 1)
-			@reader.get_method(methods[0])
-		else
-			entries = methods.find_all {|m| m.name == requested_method_name}
-			entries.size
-			# there really should be just *one* method that matches.
-			raise RiError.new("got a strange method") unless entries.size == 1
-			@reader.get_method(entries[0])
-		end
-		@display.display_method_info(method)
+  def initialize(display, path = RI::Paths::PATH)
+    @reader = RI::RiReader.new(RI::RiCache.new(RI::Paths::PATH))
+    @display = display
+    @display.reader = @reader
+    # prepare all names
+    @all_names = prepare_all_names
+  end
+
+  def prepare_all_names
+    names = Array.new
+    @reader.all_names.each do |name|
+      begin
+        names.push NameDescriptor.new(name)
+      rescue RiError => e
+        # silently ignore errors
+      end
+    end
+    names
+  end
+
+  def check_names
+    @reader.all_names.each do |name|
+      begin
+        if (NameDescriptor.new(name).to_s != name)
+          p [name, NameDescriptor.new(name).to_s, NameDescriptor.new(name)]
+        end
+      rescue RiError => e
+        puts e
+      end
+    end
+  end
+
+  # Returns all fully names as name descriptors
+  def all_names
+    @all_names
+  end
+
+  # Searches for the description of a name and shows it using +display+.
+  def show(name_descriptor, width)
+    @display.width = width
+    # narrow down namespace
+    namespace = @reader.top_level_namespace
+    name_descriptor.class_names.each do |classname|
+      namespace = @reader.lookup_namespace_in(classname, namespace)
+      if namespace.empty?
+        raise RiError.new("Nothing known about #{name_descriptor}")
+      end
+    end
+
+    # At this point, if we have multiple possible namespaces, but one
+    # is an exact match for our requested class, prune down to just it
+    # PS: this comment is shamlessly stolen from ri_driver.rb
+    entries = namespace.find_all {|m| m.full_name == name_descriptor.full_class_name}
+    namespace = entries if entries.size == 1
+
+    if name_descriptor.method_name
+      methods = @reader.find_methods(name_descriptor.method_name, name_descriptor.is_class_method, namespace)
+      report_method_stuff(name_descriptor.method_name, methods)
+    else
+      report_class_stuff(namespace)
+    end
+  end
+
+  def report_class_stuff(namespace)
+    raise RiError.new("namespace") unless namespace.size==1
+    @display.display_class_info @reader.get_class(namespace[0])
+  end
+
+  def report_method_stuff(requested_method_name, methods)
+    if methods.size == 1
+      method = @reader.get_method(methods[0])
+      @display.display_method_info(method)
+    else
+      entries = methods.find_all {|m| m.name == requested_method_name}
+      if entries.size == 1
+        method = @reader.get_method(entries[0])
+        @display.display_method_info(method)
+      else
+        puts methods.map {|m| m.full_name}.join(", ")
+      end
+    end
+=begin
+
+    method = if (methods.size == 1)
+      @reader.get_method(methods[0])
+    else
+      entries = methods.find_all {|m| m.name == requested_method_name}
+      entries.size
+      # there really should be just *one* method that matches.
+      raise RiError.new("got a strange method") unless entries.size == 1
+      @reader.get_method(entries[0])
+    end
+    @display.display_method_info(method)
 =end
-	end
+  end
 end
 
 if __FILE__ == $0
-	display = Displayer.new
-	ri = RiManager.new(display)
-	ri.all_names.each do |name|
-		p [name.type, name.to_s] if name.type==0
-	end
+  display = Displayer.new
+  ri = RiManager.new(display)
+  ri.all_names.each do |name|
+    p [name.type, name.to_s] if name.type==0
+  end
 end
 
 
 =begin
 # iterate through everything
 reader.full_class_names.sort.each do |class_name|
-	classDesc = reader.find_class_by_name(class_name)
-	
-	if class_name=="Integer"
-		pp classDesc.instance_methods
-		puts classDesc.to_yaml
-		#puts classDesc.methods
-		gets
-	end
+  classDesc = reader.find_class_by_name(class_name)
+
+  if class_name=="Integer"
+    pp classDesc.instance_methods
+    puts classDesc.to_yaml
+    #puts classDesc.methods
+    gets
+  end
 end
 =end