fxri 0.1.0

data/lib/Packet_List.rb

@@ -0,0 +1,192 @@
+# Copyright (c) 2004, 2005 Martin Ankerl
+require 'set'
+
+# Packet_List is a more convenient wrapper for FXIconList. This class has to be used 
+# in combination with Packet_Item.
+class Packet_List < FXIconList
+	include Responder
+	
+	# Create a new Packet_List. All parameters are passed to the parental constructor FXIconList.
+	def initialize(data, *args)
+		@data = data
+		@sort_mutex = Mutex.new
+		@sort_thread = nil
+		if FOXVERSION=="1.0"
+			def getItem(num)
+				retrieveItem(num)
+			end
+		end
+		
+		@header_item_index = 0
+		@reversed = false
+		@conversions = Array.new
+		@items = Set.new
+		super(*args)
+		
+		header.connect(SEL_COMMAND) do |sender, sel, item_number|
+			on_cmd_header(item_number)
+		end
+		
+		
+		# HACK: only works when one header is there.
+		self.connect(SEL_CONFIGURE) do |sender, sel, data|
+			update_header_width
+		end
+	end
+	
+	def create
+		super
+		recalc
+	end
+	
+	# HACK: only works when one header is there.
+	def update_header_width
+		header.setItemSize(0, width-verticalScrollBar.width)
+		recalc
+	end
+	
+	
+	# Called whenever a header is clicked
+	def on_cmd_header(header_item_index)
+		@data.gui_mutex.synchronize do
+			header.setArrowDir(@header_item_index, MAYBE)
+			if @header_item_index == header_item_index
+				@reversed = !@reversed
+			else
+				@reversed = false
+			end
+			@header_item_index = header_item_index
+			header.setArrowDir(@header_item_index, @reversed)
+			sortItems
+		end
+		# sort array
+		@data.items.sort! do |a, b| 
+			cmp = a.sortable(header_item_index) <=> b.sortable(header_item_index)
+			if @reversed
+				-cmp
+			else 
+				cmp
+			end
+		end
+		return 0
+	end
+	
+	def sortItems
+		@items.each do |item|
+			item.update_sort_key
+		end
+		super
+	end
+	
+	# Check if the search order is reversed (happens when clicking on the same header twice)
+	def reversed?
+		@reversed
+	end
+	
+	# Get index of the header that should be used for sorting
+	def sort_index
+		@header_item_index
+	end
+	
+	# Add a new header. The block that you need to specify is used to convert a string of this
+	# column into something that can be used for sorting. The yielded parameter item_colum_text
+	# is the text of one item of this column.
+	def add_header(text, width, &conversion) # :yields: item_column_text
+		appendHeader(text, nil, width)
+		header.setArrowDir(0, false) if @conversions.empty?
+		@conversions.push conversion
+	end
+		
+	# Create a new Packet_Item. After the icon, you can specify the text for each of the columns.
+	# Here is an example:
+	#  list.create_item(my_icon, "Martin", "Ankerl", "2005")
+	def create_item(icon, *args)
+		Packet_Item.new(self, icon, *args)
+	end
+	
+	# Add a new Packet_Item to this list.Called from within Packet_Item during Packet_Item#parent=
+	def add_item(item)
+		@items.add item
+		appendItem(item.fox_item)
+		item
+	end
+	
+	# Remove the given Packet_Item from the list. This is slow, because
+	# the item has to be searched with a linear search. To remove all items
+	# use #clear.
+	def remove_item(item)
+		i = 0
+		@items.delete item
+		fox_item = item.fox_item
+		i += 1 while i < numItems && fox_item != getItem(i)
+		removeItem(i) if i < numItems
+		item
+	end
+	
+	def appendItem(*args)
+		$fx_icon_item_remove_mutex.synchronize do
+			#puts "appendItem"
+			super
+		end
+	end
+	
+	# Before actually deleting, the item has to be marked as deleted to prevent 
+	# drawing afterwards.
+	def removeItem(*args)
+		$fx_icon_item_remove_mutex.synchronize do
+			#puts "removeitem"
+			# at first, mark item as deleted to prevent drawing afterwards
+			getItem(args[0]).deleted
+			# do the evil delete
+			super
+		end
+	end
+	
+	# Remove all items, but do this within the mutex to be sure everything goes ok.
+	def clearItems(*args)
+		$fx_icon_item_remove_mutex.synchronize do
+			#puts "clearitems"
+			super
+		end
+	end
+	
+	# This may be called when the item is currently beeing deleted.
+	# this method works only before or after the delete, therefore
+	# the mutex is necessary.
+	def getContentWidth(*args)
+		$fx_icon_item_remove_mutex.synchronize do
+			#puts "contentwidth"
+			super
+		end
+	end
+	
+	# This may be called when the item is currently beeing deleted.
+	# this method works only before or after the delete, therefore
+	# the mutex is necessary.
+	def getContentHeight(*args)
+		$fx_icon_item_remove_mutex.synchronize do
+			#puts "contentheight"
+			super
+		end
+	end
+	
+	# Removes all items from the list.
+	def clear
+		@items.each { |item| item.clear }
+		@items.clear
+		# todo: mutex!?
+		clearItems
+	end
+	
+	# use in combination with Packet_Item#show
+	def dirty_clear
+		clearItems
+		@items.clear
+	end
+	
+	# Get the sort for a given header index. The sort function has been supplied
+	# when calling #new. This is used from Packet_Item.
+	def sort_function(header_item_index)
+		@conversions[header_item_index]
+	end
+end	

data/lib/Recursive_Open_Struct.rb

@@ -0,0 +1,233 @@
+# Author:: Martin Ankerl (mailto:martin.ankerl@gmail.com)
+
+# Recursive_Open_Struct provides a convenient interface to a hierarchy of configuration
+# parameters. You do not need to define the accessors, they are created automatically
+# on demand.
+#
+# Have a look at this example:
+#
+#    ac = Recursive_Open_Struct.new
+#    ac.window.name = "SuperDuper"
+#    ac.app.version = "2.1.3"
+#    ac.this.is.automatically.created = "blabla"
+#
+# After you have created all of your configuration parameters, to prevent
+# typos when using the parameters, the structure can be closed:
+#
+#    ac.close
+#
+# 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
+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
+end

data/lib/RiManager.rb

@@ -0,0 +1,155 @@
+require "yaml"
+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
+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)
+=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
+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
+end
+=end