arcadia 0.1.0

data/base/a-contracts.rb

@@ -0,0 +1,253 @@
+#
+#   a-contracts.rb - Arcadia Ruby ide
+#   by Antonio Galeone <antonio-galeone@rubyforge.org>
+#
+
+# Catalog of all contracts used by exstension. This astraction guarantees 
+# the separation of ext
+# contract must extend AeContract
+
+require "base/a-ext"
+
+#---------------- contracts ----------------------
+class MainContract < ArcadiaContract
+  class TMainObj < TObj
+  		attr_accessor :obj, :domain, :extension
+  end
+
+  EXTENSION_BEFORE_BUILD = "EXTENSION_BEFORE_BUILD"
+  EXTENSION_BUILD = "EXTENSION_BUILD"
+  EXTENSION_AFTER_BUILD = "EXTENSION_AFTER_BUILD"
+  EXTENSION_FINALIZE = "EXTENSION_FINALIZE"
+  CONTRACT_RETRIVE = "CONTRACT_RETRIVE"
+  RAISE_EXTENSION = "RAISE_EXTENSION"
+  
+  def extension_before_build(_tobj)
+    raise_event(EXTENSION_BEFORE_BUILD, _tobj)
+  end
+  
+  def extension_build(_tobj)
+    raise_event(EXTENSION_BUILD, _tobj)
+  end
+  
+  def extension_after_build(_tobj)
+    raise_event(EXTENSION_AFTER_BUILD, _tobj)
+  end
+
+  def raise_extension(_tobj)
+    raise_action(RAISE_EXTENSION, _tobj)
+  end
+
+end
+
+
+class EditorContract < ArcadiaContract
+  class TEditorObj < TObj
+  		attr_accessor :file, :line, :col, :title, :text
+  end
+  OPEN_FILE = "OPEN_FILE"
+  CLOSE_FILE = "CLOSE_FILE"
+  OPEN_TEXT = "OPEN_TEXT"
+
+	AFTER_CREATE = "AFTER_CREATE"
+	BREAKPOINT_AFTER_CREATE = "BREAKPOINT_AFTER_CREATE"
+	BREAKPOINT_AFTER_DELETE = "BREAKPOINT_AFTER_DELETE"
+	BREAKPOINTS_AFTER_CREATE = "BREAKPOINTS_AFTER_CREATE"
+	BREAKPOINTS_AFTER_DELETE = "BREAKPOINTS_AFTER_DELETE"
+	FILE_AFTER_OPEN = "FILE_AFTER_OPEN"
+	FILE_AFTER_CLOSE = "FILE_AFTER_CLOSE"
+	BUFFER_AFTER_RAISE = "BUFFER_AFTER_RAISE"
+
+  def open_file(_tobj)
+  		raise_action(OPEN_FILE, _tobj)
+  end
+  
+  def close_file(_tobj)
+  		raise_action(CLOSE_FILE, _tobj)
+  end
+  
+  def open_text(_tobj)
+    raise_action(OPEN_TEXT, _tobj)
+	end
+
+
+  def file_opened(_tobj=nil)
+  		raise_event(FILE_AFTER_OPEN, _tobj)
+  end
+
+  def buffer_raised(_tobj=nil)
+  		raise_event(BUFFER_AFTER_RAISE, _tobj)
+  end
+
+  def file_closed(_tobj=nil)
+  		raise_event(FILE_AFTER_CLOSE, _tobj)
+  end
+ 
+  def breakpoint_created(_tobj=nil)
+  		raise_event(BREAKPOINT_AFTER_CREATE, _tobj)
+  end
+  
+  def breakpoint_deleted(_tobj=nil)
+  		raise_event(BREAKPOINT_AFTER_DELETE, _tobj)
+  end
+  def breakpoints_created(_array_of_tobj=nil)
+  		raise_event(BREAKPOINTS_AFTER_CREATE, _array_of_tobj)
+  end
+  def breakpoints_deleted(_array_of_tobj=nil)
+  		raise_event(BREAKPOINTS_AFTER_DELETE, _array_of_tobj)
+  end
+end
+
+class MsgContract < ArcadiaContract
+  TYPE_SIMPLE = "TYPE_SIMPLE"
+  TYPE_DEBUG = "TYPE_DEBUG"
+  SObj = Struct.new("MsgState"
+  )
+  class TMsgObj < TObj
+  		attr_accessor :type, :text
+  end
+  
+  EVENT_EXT_MSG_OUT = "EVENT_EXT_MSG_OUT"
+  def out(_tobj)
+    raise_event(EVENT_EXT_MSG_OUT, _tobj)
+  end
+  
+  def out_simple(_sender, _msg, _channel=nil)
+    _tobj = TMsgObj.new(_sender, 'channel'=>_channel)
+    _tobj.type = TYPE_SIMPLE
+    _tobj.text = _msg
+    self.out(_tobj)
+  end
+  
+  def out_debug(_sender, _msg, _channel=nil)
+    _tobj = TMsgObj.new(_sender, 'channel'=>_channel)
+    _tobj.type = TYPE_DEBUG
+    _tobj.text = _msg
+    self.out(_tobj)
+  end
+end
+
+class ShellContract < ArcadiaContract
+  SObj = Struct.new("ShellState"
+  )
+  class TShellObj < TObj
+  		attr_accessor :file
+  end
+
+  def run(_tobj)
+	end  
+  def debug(_tobj)
+	end  
+end
+
+
+class DebugContract < ArcadiaContract
+  SObj = Struct.new("DebugState"
+  )
+  class TDebugObj < TObj
+    attr_accessor :file, :line, :error_text, :error_class,:callers, :variables
+  end
+  
+  DEBUG_BEGIN="DEBUG_BEGIN"
+  DEBUG_END="DEBUG_END"
+  DEBUG_STEP="DEBUG_STEP"
+  
+  def debug_begin(_tobj=nil)
+  		raise_event(DEBUG_BEGIN, _tobj)
+	end
+  def debug_end(_tobj=nil)
+  		raise_event(DEBUG_END, _tobj)
+	end
+	def debug_step(_tobj=nil)
+  		raise_event(DEBUG_STEP, _tobj)
+	end
+end
+
+class InspectorContract < ArcadiaContract
+  SObj = Struct.new("InspectorActionState"
+  )
+  class TInspectorObj < TObj
+  		attr_accessor	 :wrapper, :requires, :property_family,:property_name,:property_value
+  end
+
+  SELECT_WRAPPER = "SELECT_WRAPPER"
+  #ACTIVATE_WRAPPER = "ACTIVATE_WRAPPER"
+  DELETE_WRAPPER = "DELETE_WRAPPER"
+  ADD_REQUIRE = "ADD_REQUIRE"
+  REGISTER_WRAPPER = "REGISTER_WRAPPER"
+#  UPDATE_PROPERTY = "UPDATE_PROPERTY"
+  DELETE_INSPECTOR = "DELETE_INSPECTOR"
+  RAISE_ACTIVE_OBJECT = "RAISE_ACTIVE_OBJECT"
+  RAISE_ACTIVE_TOPLEVEL = "RAISE_ACTIVE_TOPLEVEL"
+  
+  def delete_wrapper(_tobj=nil)
+  		raise_action(DELETE_WRAPPER, _tobj)
+  end
+  
+  def raise_active_object(_tobj=nil)
+  		raise_action(RAISE_ACTIVE_OBJECT, _tobj)
+  end
+
+  def raise_active_toplevel(_tobj=nil)
+  		raise_action(RAISE_ACTIVE_OBJECT, _tobj)
+  end
+  
+  def select(_tobj=nil)
+  		raise_action(SELECT_WRAPPER, _tobj)
+  end 
+
+	def add_require(_tobj=nil)
+  		raise_action(ADD_REQUIRE, _tobj)
+	end
+	
+  def register(_tobj=nil)
+  		raise_action(REGISTER_WRAPPER, _tobj)
+  end 
+  
+#  def update_property(_tobj=nil)
+#    raise_action(UPDATE_PROPERTY, _tobj)
+#  end
+  
+  def delete_inspector(_tobj=nil)
+    raise_action(DELETE_INSPECTOR, _tobj)
+  end
+  
+  publish_action :raise_active_object
+end
+
+class PublishContract < ArcadiaContract
+  ADD_COMAND_ACTOR = "ADD_COMAND_ACTOR"
+  def add_command_actor(_tobj)
+    raise_action(ADD_COMAND_ACTOR, _tobj)
+  end
+end
+
+
+
+class WrapperContract < ArcadiaContract
+  class TWrapperObj < TObj
+  		attr_accessor	 :wrapper, :property_name, :property_family, :property_old_value, :property_new_value
+  end
+  WRAPPER_AFTER_CREATE="WRAPPER_AFTER_CREATE"
+  PROPERTY_AFTER_UPDATE="PROPERTY_AFTER_UPDATE"
+  UPDATE_PROPERTY="UPDATE_PROPERTY"
+  def update_property(_tobj)
+    raise_action(UPDATE_PROPERTY, _tobj)
+  end
+  def property_updated(_tobj)
+    raise_event(PROPERTY_AFTER_UPDATE, _tobj)
+  end
+  def wrapper_created(_tobj)
+    raise_event(WRAPPER_AFTER_CREATE, _tobj)
+  end
+end
+
+class PaletteContract < ArcadiaContract
+  class TPaletteObj < TObj
+  		attr_accessor	 :parent, :x, :y
+  end
+  MAKE_SELECTED_WRAPPER = "MAKE_SELECTED_WRAPPER"
+  def make_selected(_tobj)
+    raise_action(MAKE_SELECTED_WRAPPER, _tobj)
+  end
+end

data/base/a-ext.rb

@@ -0,0 +1,360 @@
+#
+#   a-ext.rb - Arcadia Ruby ide
+#   by Antonio Galeone <antonio-galeone@rubyforge.org>
+#
+
+require "observer"
+require 'singleton'
+
+class ArcadiaExt
+  attr_reader :arcadia
+
+  def initialize(_arcadia, _name=nil)
+    @arcadia = _arcadia
+    @name = _name
+    unless self.respond_to? :build
+      raise NoMethodError, "ArcadiaExt needs to respond to `:build'" 
+    end
+    unless self.respond_to? :before_build
+      raise NoMethodError, "ArcadiaExt needs to respond to `:before_build'" 
+    end
+    unless self.respond_to? :after_build
+      raise NoMethodError, "ArcadiaExt needs to respond to `:after_build'" 
+    end
+    if self.respond_to? :arcadia_update
+    		ObserverCallback.new(@arcadia.main_contract, self, :arcadia_update)
+    end
+    ObjectSpace.define_finalizer(self, self.method(:finalize).to_proc)
+  end
+
+  def before_build
+    #must be implemented in child
+  end
+  
+  def build
+    #must be implemented in child
+  end
+
+  def after_build
+    #must be implemented in child
+  end
+
+	def frame
+	  if @frame == nil
+	    @frame = @arcadia.layout.register_panel(@arcadia['conf'][@name+'.frame'],@name, @arcadia['conf'][@name+'.label'])
+	  end
+    return @frame
+	end
+
+	def frame_free
+	  @arcadia.layout.unregister_panel(@arcadia['conf'][@name+'.frame'],@name)
+	  @frame = nil
+	end
+
+	def conf(_property)
+	  @arcadia['conf'][@name+'.'+_property]
+	end
+#  def arcadia_update(_sender, _event)
+    #must be implemented to activate
+#  end
+
+  def can_exit_query
+    return true
+  end
+
+  def finalize
+  		#may be extendeded in child
+  end
+
+  def verbose
+    '??????'
+  end
+
+end
+
+
+class ObserverCallback
+	def initialize(_publisher, _subscriber, _method_update_to_call=:update)
+		@publisher = _publisher
+		@subscriber = _subscriber
+		@method=_method_update_to_call
+		@publisher.add_observer(self)
+	end
+	def update(*args)
+		@subscriber.send(@method,*args)
+	end
+end
+
+class ObserverCallbackContract < ObserverCallback
+	def initialize(_publisher, _subscriber, _method_update_to_call=:update, _channel=nil)
+	  super(_publisher, _subscriber, _method_update_to_call)
+	  @channel = _channel
+	  @channel_conf = @subscriber.conf(@publisher.class.to_s+'.channel') if @subscriber.respond_to?(:conf)
+  end
+
+	def filter(_event)
+	  @channel_conf != nil && @channel_conf != _event.channel
+	end
+  
+	def update(_event, *args)
+	  super(_event, *args) if !filter(_event)
+  end
+end
+
+
+class ObserverCallbackContractThread < ObserverCallbackContract
+	def update(*args)
+		Thread.new do
+		  super(*args)
+		end
+	end
+
+end
+
+
+# The contract define the interface beetwhen extension
+# in particulare define method than raise event to observers client
+# and a way to retreive state from client
+
+class ArcadiaContract
+  include Observable
+  include Singleton
+  class ContractEvent 
+    	attr_reader :contract
+    	attr_reader :signature
+    	attr_reader :context
+    	attr_reader :channel
+    	attr_reader :time
+    	attr_writer :action
+    	
+    	SIGNATURE = "NOT_DEFINED"
+     def initialize(_contract, _signature=SIGNATURE, _context=nil)
+       @contract = _contract
+     		@signature = _signature
+     		@context = _context
+     		_context.channel != nil ?@channel=_context.channel: @channel='0'
+     		@time = Time.new
+     		@action = false
+     end
+     
+    	def handled(_by)
+    	  @contract.event_handled(TObj.new(_by))
+    	end
+    	
+    	def is_action? 
+    	  @action
+    	end
+  end
+  
+  class TObj
+   	attr_reader :sender
+   	attr_accessor :channel
+   	DEFAULT_CHANNEL='0'
+   	def initialize(_sender, _args=nil)
+		  @sender=_sender
+		  @channel = DEFAULT_CHANNEL
+		  if _args 
+		  	  _args.each do |key, value|
+		  	    self.send(key+'=', value)
+		  	  end
+		  end
+		  
+	  end
+	  
+#	  properties.each do |prop|
+#	    define_method(prop) {
+#        instance_variable_get("@#{prop}")
+#      }
+#      define_method("#{prop}=") do |value|
+#        instance_variable_set("@#{prop}", value)
+#      end
+#		end
+
+#			define_method(prop)
+#				attr_reader prop.to_sym # prop by itself also worked for me
+#				# code snip ? setter method
+#			end
+
+			
+#		def TObj.property(*properties)
+#      properties.each { |property|
+#        class_eval(%Q[
+#          def #{property}
+#            @#{property}
+#          end
+#  
+#          def #{property}=(value)
+#            @#{property} = value
+#          end
+#        ])
+#      }
+#		end	  
+	end
+	
+  class EventInfo
+  	 attr_reader :method
+  	 attr_reader :label
+  	 attr_reader :icon
+    def initialize(_method)
+      @method = @method
+      #TODO: load label and icon from config file
+    end
+  end
+
+	EVENT_HANDLED = "EVENT_HANDLED"
+	CONTRACT_CREATED = "CONTRACT_CREATED"
+	
+  SObj = Struct.new("GenericState",
+    :caller
+  )
+#  TObj = Struct.new("GenericObj",
+#    :sender
+#  )
+  
+#  def initialize(_sender=nil, _state_method=nil, _channel='0')
+#    @@instances = Array.new if !defined?(@@instances)
+#    #@@listeners_queue Array.new if !defined?(@@listeners_queue)
+#    @@instances << self
+#	  @sender = _sender
+#	  @state_method = _state_method
+#	  @channel = _channel
+#    ObjectSpace.define_finalizer(self, self.class.method(:finalize).to_proc)
+#    #ArcadiaContract.source(self).raise_event(CONTRACT_CREATED, TObj.new(_sender))
+#  end
+  
+#	def ArcadiaContract.instances
+#	  @@instances
+#	end
+
+#	def ArcadiaContract.source(_sender=nil)
+#	  if !defined?(@@source)
+#		  (_sender==nil) ? @@source = ArcadiaContract.new : @@source = _sender
+#		end
+#		return @@source
+#	end
+
+#	def ArcadiaContract.finalize(id)
+#  		raise_event(MainContract::EXTENSION_FINALIZE, id)
+#	end
+
+  # raise an event with event handled as context obj
+  def event_handled(_tobj)
+  		raise_event(EVENT_HANDLED, _tobj)
+  end
+  
+  def _event_forge(_event_signature, _tobj) 
+    ContractEvent.new(self, _event_signature, _tobj)
+  end
+  private :_event_forge
+  
+  
+  def raise_event(_event_signature, _tobj, *args)
+     _raise_event(_event_forge(_event_signature, _tobj),*args)
+  end
+
+  def _raise_event(_event, *args)
+     changed
+     notify_observers(_event, *args)
+     if self.class != ArcadiaContract
+       self.class.superclass.instance._raise_event(_event, *args)
+     end
+  end
+  #protected :_raise_event
+  
+  def raise_action(_event_signature, _tobj, *args)
+     _raise_action(_event_forge(_event_signature, _tobj),*args)
+  end
+
+  def _raise_action(_event, *args)
+ 	  _event.action = true 
+ 		_raise_event(_event, *args)
+  end
+  private :_raise_action
+
+  
+
+#  def retrieve_state(*args)
+#    unless @sender.respond_to? @state_method
+#      raise NoMethodError, self.class.to_s+" needs to respond to "+@state_method.to_s 
+#    end
+#    return @sender.send(@state_method, *args)
+#  end
+
+  def ArcadiaContract.publish_action(_method)
+    _info = EventInfo.new(_method)
+    @@actions = Array.new if !defined?(@@actions)
+    @@actions << _info
+  end
+
+end
+
+class ArcadiaContractListener
+	def initialize(_subscriber, _class, _method, _channel=nil)
+#	  @arcadia = _arcadia 
+	  @subscriber = _subscriber
+	  @class = _class
+	  @method = _method
+	  @channel = _channel
+	  create_callback(_class.instance)
+#		_klass = _class
+#		while _klass.kind_of?(ArcadiaContract)
+#		  create_callback(_klass.instance)
+#		  _klass = _klass.superclass
+#		end 
+
+#	  ObserverCallback.new(_class.instance, self, :do_main_event)
+#	  ObserverCallback.new(MainContract.instance, self, :do_main_event)
+#	  @class.instances.each do |_contract| 
+#	    create_callback(_contract) if _contract.kind_of?(@class)
+#	  end
+	end
+	
+#	def do_main_event(_event)
+#		if _event.signature == MainContract::CONTRACT_RETRIVE && _event.context.contract.kind_of?(@class)
+#			create_callback(_event.context.contract)
+##   elsif _event.signature == ArcadiaContract::CONTRACT_CREATED && _event.contract.kind_of?(@class)
+##			create_callback(_event.contract)
+#		end
+#	end
+
+	def create_callback(_contract)
+	  ObserverCallbackContract.new(_contract, @subscriber, @method, @channel)
+	  #ObserverCallback.new(_contract, _subscriber, _method)
+	end
+	
+#	def update(*args)
+#		@subscriber.send(@method,*args)
+#	end
+
+#	def info
+#	  @contract.retrieve_state if @contract 
+#	end
+
+#	def delegate_action(_action, _obj=nil)
+#	  if @contract && @contract.respond_to? :do_action
+#	    @contract.do_action
+#	  end
+#	end
+end
+
+class ArcadiaContractListenerThread < ArcadiaContractListener
+	
+	def create_callback(_contract)
+	  #Thread.new do super(_contract, _subscriber, _method) end
+	  ObserverCallbackContractThread.new(_contract)
+	end
+	
+end
+
+
+
+
+#class AeContractListener
+#	def initialize(_arcadia)
+#	  
+#	end
+#	def listen_on(_aeclip_name, _method_update_to_call=:update)
+#	end
+#	def update(_tobj)
+#	end
+#end