fxri 0.1.0

data/lib/FoxTextFormatter.rb

@@ -0,0 +1,265 @@
+# This class is mostly copy & paste from ri_formatter.rb.
+# except that it always returns a string and does not print anything.
+class FoxTextFormatter
+	# define all possible styles
+	STYLE_NORMAL = :STYLE_NORMAL
+	STYLE_BOLD = :STYLE_BOLD
+	STYLE_CLASS = :STYLE_CLASS
+	STYLE_H1 = :STYLE_H1
+	STYLE_H2 = :STYLE_H2
+	STYLE_H3 = :STYLE_H3
+	STYLE_TELETYPE = :STYLE_TELETYPE
+	STYLE_CODE = :STYLE_CODE
+	STYLE_EMPHASIS = :STYLE_EMPHASIS
+	
+	attr_reader :indent
+	attr_accessor :width
+	
+	# whenever text should be printed/added/shown, proc is called with the text as the argument.
+	def initialize(width, indent, &proc)
+		@width = width
+		@indent = indent
+		@proc = proc
+	end
+	
+	######################################################################
+	
+	def draw_line(label=nil)
+		len = @width
+		len -= (label.size+1) if label
+		len = [0, len].max
+		@proc.call("-"*len)
+		if label
+			@proc.call(" ")
+			@proc.call(label, STYLE_CLASS)
+		end
+		@proc.call("\n")
+	end
+	
+	def display_params(method)
+		params = method.params
+		
+		if params[0] == ?(
+			if method.is_singleton
+				params = method.full_name + params
+			else
+				params = method.name + params
+			end
+		end
+		params.split(/\n/).each do |param|
+			@proc.call(param+"\n", STYLE_BOLD)
+		end
+	end	
+	
+	def wrap(txt,  prefix=@indent, linelen=@width)
+		return if !txt || txt.empty?
+		@proc.call(prefix, STYLE_EMPHASIS)
+		conv_markup(txt, prefix, linelen)
+=begin		
+		textLen = linelen - prefix.length
+		patt = Regexp.new("^(.{0,#{textLen}})[ \n]")
+		next_prefix = prefix.tr("^ ", " ")
+		
+		res = []
+		
+		while work.length > textLen
+			if work =~ patt
+				res << $1
+				work.slice!(0, $&.length)
+			else
+				res << work.slice!(0, textLen)
+			end
+		end
+		res << work if work.length.nonzero?
+		@proc.call(prefix +  res.join("\n" + next_prefix) + "\n")
+=end
+	end
+	
+	######################################################################
+	
+	def blankline
+		@proc.call("\n")
+	end
+	
+	######################################################################
+	
+	# called when we want to ensure a nbew 'wrap' starts on a newline
+	# Only needed for HtmlFormatter, because the rest do their
+	# own line breaking
+	
+	def break_to_newline
+	end
+	
+	######################################################################
+	
+	def bold_print(txt)
+		@proc.call(txt, STYLE_BOLD)
+	end
+	
+	######################################################################
+	
+	def raw_print_line(txt)
+		@proc.call(txt)
+	end
+	
+	######################################################################
+	
+	# convert HTML entities back to ASCII
+	def conv_html(txt)
+		txt.
+		gsub(/&gt;/, '>').
+		gsub(/&lt;/, '<').
+		gsub(/&quot;/, '"').
+		gsub(/&amp;/, '&')	
+	end
+	
+	# convert markup into display form
+	def conv_markup(txt, prefix, linelen)
+		
+		# this code assumes that tags are not used inside tags
+		pos = 0
+		old_pos = 0
+		style = STYLE_NORMAL
+		current_indent = prefix.size
+		while pos = txt.index(%r{(<tt>|<code>|<b>|<em>|</tt>|</code>|</b>|</em>)}, old_pos)			
+			new_part = txt[old_pos...pos]
+			@proc.call(new_part, style)
+			
+			# get tag name
+			old_pos = txt.index(">", pos) + 1
+			style = case txt[(pos+1)...(old_pos-1)]
+				when "tt"
+					STYLE_TELETYPE
+				when "code"
+					STYLE_CODE
+				when "b"
+					STYLE_BOLD
+				when "em"
+					STYLE_EMPHASIS
+				else
+					# closing or unknown tags
+					STYLE_NORMAL
+				end
+		end
+		@proc.call(txt[old_pos...txt.size], style)
+		@proc.call("\n")
+	end
+	
+	######################################################################
+	
+	def display_list(list)
+		case list.type		
+		when SM::ListBase::BULLET 
+			prefixer = proc { |ignored| @indent + "*   " }
+		
+		when SM::ListBase::NUMBER,
+			SM::ListBase::UPPERALPHA,
+			SM::ListBase::LOWERALPHA
+		
+			start = case list.type
+				when SM::ListBase::NUMBER      then 1
+				when SM::ListBase::UPPERALPHA then 'A'
+				when SM::ListBase::LOWERALPHA then 'a'
+				end
+			prefixer = proc do |ignored|
+				res = @indent + "#{start}.".ljust(4)
+				start = start.succ
+				res
+			end
+		
+		when SM::ListBase::LABELED
+			prefixer = proc do |li|
+				li.label
+			end
+			
+		when SM::ListBase::NOTE
+			longest = 0
+			list.contents.each do |item|
+				if item.kind_of?(SM::Flow::LI) && item.label.length > longest
+					longest = item.label.length
+				end
+			end
+			
+			prefixer = proc do |li|
+				@indent + li.label.ljust(longest+1)
+			end
+			
+		else
+			fail "unknown list type"
+		end
+			
+		list.contents.each do |item|
+			if item.kind_of? SM::Flow::LI
+				prefix = prefixer.call(item)
+				display_flow_item(item, prefix)
+			else
+				display_flow_item(item)
+			end
+		end
+	end
+	
+	######################################################################
+	
+	def display_flow_item(item, prefix=@indent)
+		case item
+		when SM::Flow::P, SM::Flow::LI
+			wrap(conv_html(item.body), prefix)
+			blankline
+		
+		when SM::Flow::LIST
+			display_list(item)
+		
+		when SM::Flow::VERB
+			display_verbatim_flow_item(item, @indent)
+		
+		when SM::Flow::H
+			display_heading(conv_html(item.text.join), item.level, @indent)
+		
+		when SM::Flow::RULE
+			draw_line
+			
+		when String
+			wrap(conv_html(item), prefix)
+		
+		else
+			fail "Unknown flow element: #{item.class}"
+		end
+	end
+	
+	######################################################################
+	
+	def display_verbatim_flow_item(item, prefix=@indent)
+		item.body.split(/\n/).each do |line|
+			@proc.call(@indent)
+			@proc.call(conv_html(line))
+			@proc.call("\n")
+		end
+		blankline
+	end
+	
+	######################################################################
+	
+	def display_heading(text, level, indent)
+		case level
+		when 1
+			@proc.call(text, STYLE_H1)
+			@proc.call("\n")
+		
+		when 2
+			@proc.call(text, STYLE_H2)
+			@proc.call("\n")
+			
+		else
+			@proc.call(indent)
+			@proc.call(text, STYLE_H3)
+			@proc.call("\n")
+		end
+	end
+	
+	
+	def display_flow(flow)
+		flow.each do |f|
+			display_flow_item(f)
+		end
+	end
+end

data/lib/Globals.rb

@@ -0,0 +1,42 @@
+require 'lib/Recursive_Open_Struct'
+
+$cfg = Recursive_Open_Struct.new
+
+$cfg.app.name = "fxri - Instant Ruby Enlightenment"
+
+# uses the first font that is available
+$cfg.app.font.name = ["Bitstream Vera Sans", "Verdana", "Trebuchet MS", "Tahoma", "Arial"]
+$cfg.ri_font = ["Bitstream Vera Sans Mono", "Courier New", "Courier"]
+$cfg.app.font.size = 8
+
+$cfg.app.width = 760	
+$cfg.app.height = 480
+$cfg.search_delay = 0.1
+$cfg.minimum_letters_per_line = 20
+$cfg.packet_list_width = 160
+$cfg.irb_height = 300
+$cfg.status_line_update_interval = 0.1
+
+$cfg.list.opts = ICONLIST_SINGLESELECT|ICONLIST_DETAILED|LAYOUT_FILL_X|LAYOUT_FILL_Y|ICONLIST_AUTOSIZE
+
+# icons, are automatically loaded from Icon_Loader.
+$cfg.icons.klass = "class.png"
+$cfg.icons.class_method = "module.png"
+$cfg.icons.instance_method = "method.png"
+
+# all texts
+$cfg.text.search = "%d / %d entries"
+$cfg.text.search_field = "What do you want to know?"
+$cfg.text.method_name = "name"
+
+
+$cfg.text.help = %|This is <b>fxri</b>, a graphical interface to the <em>Ruby</em> documentation. Fxri comes with a search engine with quite a few features. Here are several examples:
+'<em>Array</em>': Lists all classes with the name <em>Array</em>. Note that upcase words are treated case sensitive, lowercase words insensitive.
+'<em>array sort</em>': Everything that contains both <em>array</em> and <em>sort</em> (case insensitive).
+'<em>array -Fox</em>': Everything that contain the name <em>array</em> (case insensitive), but not <em>Fox</em> (case sensitive).
+After searching just press <em>down</em> to browse the search results. Press <em>Tab</em> to move back into the search field.
+If you have any questions, suggestions, problems, please contact me with <b>martin.ankerl@gmail.com</b>.|
+
+
+# prevent further modifications
+$cfg.close

data/lib/Icon_Loader.rb

@@ -0,0 +1,35 @@
+# Copyright (c) 2004, 2005 Martin Ankerl
+
+# Converts a Recursive_Open_Struct that contains filenames of PNG-icons into real icons.
+class Icon_Loader
+	# Create a new Icon_Loader. You need to specify the Fox-application.
+	def initialize(app)
+		@app = app
+	end
+	
+	# Takes each attribute of the given Recursive_Open_Struct,
+	# converts it into a real icon, and sets it.
+	def cfg_to_icons(cfg)
+		cfg.attrs.each do |attr|
+			value = cfg.send(attr.to_sym)
+			if (value.class == Recursive_Open_Struct)
+				cfg_to_icons(value)
+			else
+				# value is a filename
+				icon = make_icon(value)
+				cfg.send((attr + "=").to_sym, icon)
+			end
+		end
+	end
+	
+	# Constructs an icon from the given filename (from the icons directory).
+	def make_icon(filename)
+		filename = File.join("lib", "icons", filename)
+		icon = nil
+		File.open(filename, "rb") do |f|
+			icon = FXPNGIcon.new(@app, f.read, 0)
+		end
+		icon.create
+		icon
+	end
+end

data/lib/Packet_Item.rb

@@ -0,0 +1,179 @@
+# Copyright (c) 2004, 2005 Christoph Heindl and Martin Ankerl
+class MutexDummy
+	def synchronize
+		yield
+	end
+end
+
+# Lock used to synchronize item removes.
+# for now, a global lock is good enough. 
+$fx_icon_item_remove_mutex = Mutex.new
+
+
+# An item for Packet_List. This is a convenient wrapper for the FXIconItem.
+class Packet_Item
+
+	attr_accessor :searchable
+
+	# Fox_Item is a very thin wrapper that calles Packet_Item functionality.
+	class Fox_Item < FXIconItem
+		# optimization: directly sort by sort_key and reversed
+		attr_accessor :sort_key
+		attr_accessor :reversed
+		
+		# Create a new item with packet_item as the parent. *args is passed to the FXIconItem.
+		def initialize(packet_item, *args)
+			@packet_item = packet_item
+			@sort_key = nil
+			@reversed = 1
+			@is_deleted = false
+			super(*args)
+		end
+
+		# Sometimes draw is called AFTER the item has been removed. 
+		# In this case: return immediately. Otherwise a Runtime Error would occur!
+		def draw(*args)
+			$fx_icon_item_remove_mutex.synchronize do
+				#puts "draw"
+				return if @is_deleted
+				super
+			end
+		end
+
+		# Mark item as deleted, to prevent execution of draw afterwards
+		# this is called from Packet_List which uses the same mutex
+		# as draw.
+		def deleted
+			@is_deleted = true
+		end
+		
+		# Called from sortItems, uses packet_item's comparison.
+		def <=>(other)
+			(@sort_key <=> other.sort_key) * @reversed
+		end
+		
+		# Get the packet item
+		def packet_item
+			@packet_item
+		end
+		
+		# Pass-through method
+		def data
+			@packet_item.data
+		end
+	end
+	
+	# Creates a Packet_Item with newParent as the parent list, which is allowed to be nil.
+	# You can also use Packet_List#add_item instead.
+	def initialize(newParent, icon, *content)
+		@content = content
+		@sortable = Array.new(@content.size)
+		@icon = icon
+		@data = nil
+		@parent = nil
+		@sort_key = nil
+		@searchable = nil
+		# call parent=, don't forget the self!!
+		self.parent = newParent
+		show if newParent
+		# update sortable
+		@content.each_index do |pos|
+			update_sortable(pos, @content[pos]) if parent
+		end
+	end
+
+	# Get the content of the given column number.
+	def [](column_nr)
+		@content[column_nr]
+	end
+	
+	# Set new text for the given column number.
+	def []=(column_nr, newVal) 
+		@content[column_nr] = newVal
+		return unless @parent
+		@item.text = @content.join("\t")
+		update_sortable(column_nr, newVal)
+		@parent.recalc
+	end
+	
+	# Get the sortable representation of this column's content.
+	def sortable(pos)
+		@sortable[pos]
+	end
+		
+	# update FXIconItem's sort key and reversed status
+	def update_sort_key
+		@item.sort_key = @sortable[@parent.sort_index]
+		@item.reversed = @parent.reversed? ? -1 : 1
+	end
+	
+	# Get the parent list for this item.
+	def parent
+		@parent
+	end
+	
+	# Set a new parent. This removes this item from the current list and adds itself to 
+	# the new one.
+	def parent=(newParent)
+		return if newParent == @parent
+		remove_item if @parent
+		@parent = newParent
+		@content.each_index do |pos|
+			update_sortable(pos, @content[pos]) if @parent
+		end
+	end
+	
+	# Shows item on parent without updating the search index. This can be used
+	# if an item is removed and added to the same list.
+	def show
+		create_item
+		@parent.add_item(self)
+	end
+	
+	# Get the wrapper item.
+	def fox_item
+		@item
+	end
+	
+	# Allows to set user data.
+	def data=(data)
+		@data = data
+	end
+	
+	# Get user data.
+	def data
+		@data
+	end
+	
+	# Removes the item from its parent.
+	def clear
+		@parent = nil
+	end
+	
+	# The icon of this item.
+	def icon
+		@icon
+	end
+	
+	private
+
+	# Calles the sort function to update the sortable representation of column pos.
+	def update_sortable(pos, newVal)
+		sort_function = @parent.sort_function(pos)
+		if sort_function
+			@sortable[pos] = sort_function.call(newVal)
+		else
+			@sortable[pos] = newVal
+		end
+	end
+	
+	# Remove item from parent
+	def remove_item
+		@parent.remove_item(self)
+	end
+	
+	# Creates wrapper item, and sets it's data
+	def create_item
+		@item = Fox_Item.new(self, @content.join("\t"), @icon, @icon)
+	end
+end