arcadia 0.1.3 → 0.2.0

data/base/a-commons.rb

@@ -0,0 +1,480 @@
+#
+#   a-commons.rb - Arcadia Ruby ide
+#   by Antonio Galeone <antonio-galeone@rubyforge.org>
+#
+
+require "observer"
+require 'singleton'
+
+# +------------------------------------------+
+#      Extension
+# +------------------------------------------+
+
+class ArcadiaExt
+  attr_reader :arcadia
+
+  def initialize(_arcadia, _name=nil)
+    @arcadia = _arcadia
+    Arcadia.add_listener(self, BuildEvent)
+    Arcadia.add_listener(self, ExitQueryEvent)
+    Arcadia.add_listener(self, FinalizeEvent)
+    @name = _name
+    @frames = Array.new
+    @frames_points = conf_array("#{_name}.frames")
+    @frames_labels = conf_array("#{_name}.labels")
+    @float_frames = Array.new
+#    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 conf_array(_name)
+    res = []
+    value = @arcadia['conf'][_name]
+    res.concat(value.split(',')) if value
+    res
+  end
+  
+  def frame(_n=0)
+	  if @frames[_n] == nil && @frames_points[_n]
+	    (@frames_labels[_n].nil?)? _label = @name : _label = @frames_labels[_n]
+	    @frames[_n] = @arcadia.layout.register_panel(@frames_points[_n],@name, _label)
+	  end
+    return @frames[_n]
+  end
+
+  def frame_free(_n=0)
+	  if _n.nil?
+      @frames.each_index{|i|
+        @arcadia.layout.unregister_panel(@frames_points[i],@name)
+        @frames[i]=nil
+      }
+	  else
+  	   @arcadia.layout.unregister_panel(@frames_points[_n],@name)
+  	   @frames[_n] = nil
+	  end
+	  
+  end
+
+  def frame_raise(_n=0)
+	  if _n.nil?
+      @frames.each_index{|i|
+        @arcadia.layout.raise_panel(@frames_points[i],@name)
+      }
+	  else
+  	   @arcadia.layout.raise_panel(@frames_points[_n],@name)
+	  end
+  end
+
+
+  def frame_title(_title=nil, _n=0)
+	  self.frames(_n) if @frames[_n] == nil
+    @arcadia.layout.domain(@frames_points[_n])['root'].top_text(_title)
+  end
+
+  def float_frame(_n=0, _args=nil)
+	  if @float_frames[_n].nil? 
+	    @float_frames[_n] =  @arcadia.layout.new_float_frame(_args)
+	  end
+     @float_frames[_n]
+  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
+  
+  def exec(_method, _args=nil)
+    if self.respond_to(_method)
+      self.send(_method, _args)
+    end
+  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
+
+# +------------------------------------------+
+#      Event
+# +------------------------------------------+
+
+class Event
+  class Result
+    attr_reader :sender
+    attr_reader :time
+    def initialize(_sender, _args=nil)
+      @sender = _sender
+      if _args 
+        _args.each do |key, value|
+          self.send(key+'=', value)
+        end
+      end
+      @time = Time.new
+    end
+  end
+  attr_reader :sender
+  attr_accessor :parent
+  attr_reader :channel
+  attr_reader :time
+  attr_reader :results
+  def initialize(_sender, _args=nil)
+    @breaked = false
+    @sender = _sender
+    @channel = '0'
+    if _args 
+      _args.each do |key, value|
+        #self.send(key, value)
+        self.send(key+'=', value)
+      end
+    end
+    @time = Time.new
+    @results = Array.new
+  end
+  
+  def add_result(_sender, _args=nil)
+    if self.class::Result
+      res = self.class::Result.new(_sender, _args)
+    else
+      res = Result.new(_sender, _args)
+    end
+    @results << res
+    res
+  end
+  
+  def is_breaked?
+    @breaked
+  end
+  
+  def break
+    @breaked = true
+  end
+end
+
+module EventBus #(or SourceEvent)
+  def process_event(_event)
+    return _event if !defined?(@@listeners)
+    event_classes = _event_class_stack(_event.class)
+    #before fase
+    event_classes.each do |_c|
+      _process_fase(_c, _event, 'before')
+      break if _event.is_breaked?
+    end unless _event.is_breaked?
+    # fase
+    event_classes.each do |_c|
+      _process_fase(_c, _event)
+      break if _event.is_breaked?
+    end unless _event.is_breaked?
+    #after fase
+    event_classes.each do |_c|
+      _process_fase(_c, _event, 'after')
+      break if _event.is_breaked?
+    end unless _event.is_breaked?
+    _event
+  end
+  
+  def broadcast_event(_event)
+    return _event if !defined?(@@listeners)
+    event_classes = _event_class_stack(_event.class)
+    event_classes.each do |_c|
+      _broadcast_fase(_c, _event)
+    end
+  end
+  
+  def _event_class_stack(_class)
+    #p "------> chiamato _event_class_stack for class #{_class}"
+    res = Array.new
+    cur_class = _class
+    while cur_class != Object
+	#p "#{cur_class} son on #{cur_class.superclass}"
+       res << cur_class
+       cur_class = cur_class.superclass
+    end
+    return res
+  end
+  private :_event_class_stack
+  
+  def _process_fase(_class, _event, _fase_name = nil)
+    # _fase_name cicle
+    return if @@listeners[_class].nil?
+    _fase_name.nil?? suf = '':suf = _fase_name
+    #method_name = 'on_'+suf+_class.to_s.downcase.gsub('event','')
+    method_name = _method_name(_class, suf)
+    #p _method_name(_event, suf)+' == '+method_name
+    #p method_name
+    if _class != _event.class
+      #sub_method_name = 'on_'+suf+_event.class.to_s.downcase.gsub('event','')
+      sub_method_name = _method_name(_event.class, suf)
+      @@listeners[_class].each do|_listener|
+         if _listener.respond_to?(sub_method_name)
+       _listener.send(sub_method_name, _event)
+         elsif _listener.respond_to?(method_name)
+           _listener.send(method_name, _event)
+         end
+      end
+    else
+      @@listeners[_class].each do|_listener|
+        _listener.send(method_name, _event) if _listener.respond_to?(method_name)
+      end
+    end
+  end
+  private :_process_fase
+  def _method_name(_class, _suf='')
+    _str = _class.to_s
+    _pre = _str[0..1]
+    _in = _str[2..-1]
+    _suf = _suf+'_' if _suf.length >0
+    return 'on_'+(_suf+_pre+_in.gsub(/[A-Z]/){|s| '_'+s.to_s}).downcase.gsub('_event','')
+  end
+  private :_method_name
+  def _broadcast_fase(_class, _event)
+    return if @@listeners[_class].nil?
+    method_name = _method_name(_class)
+    if _class != _event.class
+      sub_method_name = _method_name(_event.class)
+      @@listeners[_class].each do|_listener|
+      #p "--- method_name=>#{method_name}"
+      #p "--- sub_method_name=>#{sub_method_name}"
+      #p "--- for listener #{_listener}"
+	 if _listener.respond_to?(sub_method_name)
+	   Thread.new{_listener.send(sub_method_name, _event)}
+         elsif _listener.respond_to?(method_name)
+           Thread.new{_listener.send(method_name, _event)}
+         end
+      end
+    else
+      @@listeners[_class].each do|_listener|
+        _listener.send(method_name, _event) if _listener.respond_to?(method_name)
+      end
+    end
+  end
+  private :_broadcast_fase
+
+  
+  def add_listener(_listener, _class_event)
+    @@listeners = {} unless defined? @@listeners
+    @@listeners[_class_event] = []   unless @@listeners.has_key?(_class_event)
+    @@listeners[_class_event] << _listener
+  end
+
+end
+
+
+module Autils
+	def full_in_path_command(_command=nil)
+	  return nil if _command.nil?
+		_ret = nil
+		RUBY_PLATFORM.include?('win32') ? _sep = ';':_sep=':'
+		ENV['PATH'].split(_sep).each{|_path|
+			_file = File.join(_path, _command)
+			if FileTest.exist?(_file)
+	  			_ret = _file
+			end
+		}
+		_ret
+	end
+
+  def is_windows?
+    !(RUBY_PLATFORM =~ /(win|w)32$/).nil?
+    #RUBY_PLATFORM.include?('win')
+  end
+	
+end
+
+module Configurable
+  def properties_file2hash(_property_file)
+    r_hash = Hash.new
+    if _property_file &&  FileTest::exist?(_property_file)
+      f = File::open(_property_file,'r')
+      begin
+        _lines = f.readlines
+        _lines.each{|_line|
+          _strip_line = _line.strip
+          if (_strip_line.length > 0)&&(_strip_line[0,1]!='#')
+            var_plat = _line.split('::')
+            if var_plat.length > 1
+              if (RUBY_PLATFORM.include?(var_plat[0]))
+                _line = var_plat[1]
+                var_plat[2..-1].collect{|x| _line=_line+'::'+x} if var_plat.length > 2
+              else
+                _line = ''
+              end
+            end
+            var = _line.split('=')
+            if var.length > 1
+              _value = var[1].strip
+              var[2..-1].collect{|x| _value=_value+'='+x} if var.length > 2
+              r_hash[var[0].strip]=_value
+            end
+          end
+        }
+      ensure
+        f.close unless f.nil?
+      end
+      return r_hash      
+    end
+  end
+end
+
+module Persistable
+  def write_persist(_persist_file)
+    if FileTest::exist?(_persist_file)
+      f = File.new(_persist_file, "w")
+      begin
+        if f
+          p = self['pers']
+          if p
+            p.each{|key,value|
+              f.syswrite(key+'='+value+"\n")
+            }
+          end
+        end
+      ensure
+        f.close unless f.nil?
+      end
+    end
+  end
+end
+
+class Application
+  extend EventBus
+  include Configurable
+  include Persistable
+  ApplicationParams = Struct.new( "ApplicationParams",
+    :name,
+    :version,
+    :config_file,
+    :persistent_file
+  )
+
+  def initialize(_ap=ApplicationParams.new)
+    @@instance = self
+    eval('$'+_ap.name+'=self')
+    publish('applicationParams', _ap)
+    publish(_ap.name,self)
+    @first_run = false
+    self['applicationParams'].persistent_file = File.join(local_dir, self['applicationParams'].name+'.pers')
+    if !File.exists?(self['applicationParams'].persistent_file)
+      File.new(self['applicationParams'].persistent_file, File::CREAT).close
+    end
+    publish('conf', properties_file2hash(self['applicationParams'].config_file)) if self['applicationParams'].config_file
+    publish('pers', properties_file2hash(self['applicationParams'].persistent_file)) if self['applicationParams'].persistent_file
+    yield(self) if block_given?
+  end
+  
+  def Application.instance
+    @@instance
+  end
+
+  def prepare
+  end
+
+  def publish(_name, _obj)
+    @objs = Hash.new if !defined?(@objs)
+    if @objs[_name] == nil
+      @objs[_name] = _obj
+    else
+      raise("The name #{_name} already exist")
+    end
+  end
+
+  # this method load config file from local directory for personalizations
+  def load_local_config(_create_if_not_exist=true)
+      local_file_config = File.join(local_dir,File.basename(self['applicationParams'].config_file))
+      if FileTest.exist?(local_file_config)
+        self['conf'].update(self.properties_file2hash(local_file_config))
+      elsif _create_if_not_exist
+        if FileTest.writable?(local_dir)
+          f = File.new(local_file_config, "w")
+          begin
+            if f
+              p = self['conf']
+              if p
+                p.keys.sort.each{|key|
+                  f.syswrite('#'+key+'='+self['conf'][key]+"\n")
+                }
+              end
+            end
+          ensure
+            f.close unless f.nil?
+          end
+        else
+          msg = "Locad dir "+'"'+local_dir+'"'+" must be writable!"
+          Arcadia.ok(self, 'title' => '(Arcadia)', 'msg' => msg, 'level'=>'error')
+          exit
+        
+        end
+      end
+  end
+  
+  def local_dir
+    _local_dir = File.join(ENV["HOME"],'.'+self['applicationParams'].name)  if ENV["HOME"] 
+    if _local_dir && !File.exist?(_local_dir)
+      if FileTest.exist?(ENV["HOME"])
+        Dir.mkdir(_local_dir)
+        @first_run = true
+      else
+        msg = "Locad dir "+'"'+ENV["HOME"]+'"'+" must be writable!"
+        Arcadia.ok(self, 'title' => "(#{self['applicationParams'].name})", 'msg' => msg, 'level'=>'error')
+        exit
+      end
+    end
+    return _local_dir
+  end
+
+  def create(_name, _class)
+    register(_name,_class.new)
+  end
+
+  def objects(_name)
+    return @objs[_name]
+  end
+
+  def [](_name)
+    if @objs[_name]
+      return @objs[_name]
+    else
+      raise RuntimeError, "resurce '"+_name+"' unavabled ", caller
+    end
+  end
+
+  def run
+  end
+end
+
+