rugui 1.2.0

data/lib/rugui/initializer.rb

@@ -0,0 +1,162 @@
+require 'rugui'
+require 'rugui/gem_dependency'
+
+module RuGUI
+  class Initializer
+    include RuGUI::LogSupport
+
+    # The configuration for this application.
+    attr_reader :configuration
+
+    # Whether or not all the gem dependencies have been met
+    attr_reader :gems_dependencies_loaded
+
+    @@processed = false
+
+    # Runs the initializer.
+    #
+    # It runs the process procedure by default, by this can be changed by
+    # specifying a command when calling this method. A block can be given
+    # in order to change the application configuration.
+    #
+    def self.run(command = :process, configuration = Configuration.new)
+      yield configuration if block_given?
+      initializer = new configuration
+      RuGUI.configuration = configuration
+      initializer.send(command)
+      @@processed = (command == :process) ? true : false
+      initializer
+    end
+
+    # Create a new Initializer instance that references the given Configuration
+    # instance.
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    # Sequentially step through all of the available initialization routines,
+    # in order (view execution order in source).
+    def process
+      load_environment
+      load_logger
+
+      start_initialization_process_log
+
+      set_load_path
+      add_gem_load_paths
+      
+      set_autoload_paths
+      load_framework_adapter
+
+      load_gems
+      load_plugins
+
+      # pick up any gems that plugins depend on
+      add_gem_load_paths
+      load_gems
+      check_gem_dependencies
+
+      # bail out if gems are missing - note that check_gem_dependencies will have
+      # already called abort() unless $gems_rake_task is set
+      return unless gems_dependencies_loaded
+
+      finish_initialization_process_log
+     end
+
+    # Set the <tt>$LOAD_PATH</tt> based on the value of
+    # Configuration#load_paths. Duplicates are removed.
+    def set_load_path
+      load_paths = configuration.load_paths
+      load_paths.reverse_each { |dir| $LOAD_PATH.unshift(dir) if File.directory?(dir) }
+      $LOAD_PATH.uniq!
+    end
+
+    # Set the paths from which RuGUI will automatically load source files.
+    def set_autoload_paths
+      ActiveSupport::Dependencies.load_paths = configuration.load_paths.uniq
+    end
+
+    # Loads the environment specified by Configuration#environment_path, which
+    # is typically one of development, or production.
+    def load_environment
+      return if @environment_loaded
+      @environment_loaded = true
+
+      if File.exist?(configuration.environment_path)
+        config = configuration
+        constants = self.class.constants
+
+        eval(IO.read(configuration.environment_path), binding, configuration.environment_path)
+
+        (self.class.constants - constants).each do |const|
+          Object.const_set(const, self.class.const_get(const))
+        end
+      end
+    end
+
+    def load_plugins
+      plugin_loader.load_plugins
+    end
+
+    def add_gem_load_paths
+      RuGUI::GemDependency.add_frozen_gem_path
+      unless @configuration.gems.empty?
+        require "rubygems"
+        @configuration.gems.each { |gem| gem.add_load_paths }
+      end
+    end
+
+    def load_gems
+      unless $gems_build_rake_task
+        @configuration.gems.each { |gem| gem.load }
+      end
+    end
+
+    def check_gem_dependencies
+      unloaded_gems = @configuration.gems.reject { |g| g.loaded? }
+      if unloaded_gems.size > 0
+        @gems_dependencies_loaded = false
+        # don't print if the gems rake tasks are being run
+        unless $gems_rake_task
+          abort <<-end_error
+Missing these required gems:
+  #{unloaded_gems.map { |gem| "#{gem.name}  #{gem.requirement}" } * "\n  "}
+
+You're running:
+  ruby #{Gem.ruby_version} at #{Gem.ruby}
+  rubygems #{Gem::RubyGemsVersion} at #{Gem.path * ', '}
+
+Run `rake gems:install` to install the missing gems.
+          end_error
+        end
+      else
+        @gems_dependencies_loaded = true
+      end
+    end
+
+    def load_logger
+      RuGUILogger.logger
+    end
+
+    def start_initialization_process_log
+      logger.info "Starting RuGUI application with #{configuration.environment} environment..." unless silence_logs?
+    end
+
+    def finish_initialization_process_log
+      logger.info "RuGUI application configurations loaded." unless silence_logs?
+    end
+
+    def plugin_loader
+      @plugin_loader || RuGUI::Plugin::Loader.new(self, configuration)
+    end
+
+    def load_framework_adapter
+      require "rugui/framework_adapters/#{RuGUI.configuration.framework_adapter}"
+    end
+
+    private
+      def silence_logs?
+        @@processed or $gems_build_rake_task or $gems_rake_task
+      end
+  end
+end

data/lib/rugui/log_support.rb

@@ -0,0 +1,118 @@
+require 'logger'
+
+module RuGUI
+  #
+  # A simple log support for registering problems, infos and debugs.
+  #
+  module LogSupport
+    # Returns the logger object.
+    def logger
+      @logger ||= RuGUILogger.logger
+      @logger.formatter = RuGUI::LogSupport::Formatter.new(self.class.name)
+      @logger
+    end
+
+    module ClassMethods
+      def logger
+        @@logger ||= RuGUILogger.logger
+        @@logger.formatter = RuGUI::LogSupport::Formatter.new(self.name)
+        @@logger
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    private
+      class Formatter
+        def initialize(classname = nil)
+          @classname = classname
+        end
+
+        def call(severity, timestamp, progname, msg)
+          timestamp = timestamp.strftime(RuGUI.configuration.logger[:format] || "%Y-%m-%d %H:%M:%S")
+          "#{timestamp} (#{severity}) (#{@classname}) #{msg}\n"
+        end
+      end
+  end
+  
+  class RuGUILogger
+    class << self
+      def logger
+        @@rugui_logger ||= RuGUILogger.new
+        @@rugui_logger.logger
+      end
+    end
+      
+    def logger
+      @@logger
+    end
+    
+    private
+      def initialize
+        setup_logger
+      end
+    
+      #
+      # Setup a new log support object. If a problem occurs a logger is setted up
+      # to warn level.
+      #
+      def setup_logger
+        begin
+          @@logger = Logger.new(defined_output)
+          @@logger.level = defined_level
+        rescue StandardError => e
+          @@logger = Logger.new(STDERR)
+          @@logger.level = LEVELS[:warn]
+          @@logger.warn "Log support problems: The log level has been raised to WARN and the output directed to STDERR until the problem is fixed."
+          @@logger.error "#{e} #{e.backtrace.join("\n")}"
+        end
+      end
+      
+      #
+      # Defines a output based on params informed by user, params setted up in
+      # the configuration file, or default values.
+      #
+      def defined_output
+        output = RuGUI.configuration.logger[:output]
+        if output.nil? or [:stdout, :stderr].include?(output)
+          DEFAULT_OUTPUT
+        else
+          File.join(RuGUI.root, 'log', output)
+        end
+      end
+
+      #
+      # Defines a level based on params informed by user, params setted up in
+      # the configuration file, or default values.
+      #
+      def defined_level
+        level = RuGUI.configuration.logger[:level]
+        unless level
+          level = DEFAULT_LEVEL
+        else
+          level = LEVELS[level]
+        end
+        level
+      end
+
+      def defined_classname(classname)
+        classname || self.class.name
+      end
+      
+      LEVELS = {
+        :debug => Logger::DEBUG,
+        :info => Logger::INFO,
+        :warn => Logger::WARN,
+        :error => Logger::ERROR,
+        :fatal => Logger::FATAL
+      }
+      
+      #
+      # Default values to the log support object - aka logger
+      #
+      DEFAULT_OUTPUT = STDOUT
+      DEFAULT_LEVEL = LEVELS[:debug]
+  end
+end

data/lib/rugui/observable_property_proxy.rb

@@ -0,0 +1,73 @@
+module RuGUI
+  # A proxy class for observable properties.
+  #
+  # When creating an <code>ObservablePropertyProxy</code> you pass an
+  # instance of any object to it (which will now be the context for this
+  # proxy), the observable and the property name.
+  #
+  # The <code>ObservablePropertyProxy</code> instance will work as a
+  # proxy for each method send to the context. If the context is changed,
+  # it will notify any <code>PropertyObservers</code> registered for its
+  # <code>observable</code>, by calling their
+  # <code>property_changed</code> method.
+  #
+  # CAUTION: When using observable string properties as keys in a Hash make
+  # sure you call the Object#to_s or Object#to_sym methods before putting
+  # the property value as key. Hashes uses the method Object#eql? when
+  # comparing keys, and for some unknown reason it is always returning false
+  # when comparing observable string properties.
+  #
+  class ObservablePropertyProxy < BaseObject
+    include RuGUI::LogSupport
+
+    def initialize(context, observable, property)
+      @context = context
+      @observable = observable
+      @property = property
+    end
+
+    private
+      NON_DELEGATABLE_METHODS = ['__id__', '__send__']
+
+      # Delegating Object's methods to context. Since none of these methods
+      # really change the object we just send them to the context.
+      self.methods.each do |method_name|
+        unless NON_DELEGATABLE_METHODS.include?(method_name)
+          self.class_eval <<-class_eval
+            def #{method_name}(*args)
+              @context.send(:#{method_name}, *args)
+            end
+          class_eval
+        end
+      end
+
+      # Here we reimplement the method missing, adding code to notify observers
+      # when the property has changed, i.e., when the context before calling the
+      # method is different than the context after the method is called.
+      def method_missing(method, *args, &block)
+        old_context = get_context_copy
+        return_value = @context.send(method, *args, &block)
+
+        context_changed(@context, old_context) unless @context == old_context
+        return_value
+      end
+
+      # Returns a copy of the context.
+      def get_context_copy
+        begin
+          return @context.clone
+        rescue TypeError
+          return @context
+        end
+      end
+
+      #
+      # Called when the context has changed.
+      #
+      # Notifies all registered observers
+      #
+      def context_changed(new_value, old_value)
+        @observable.property_changed(@property, new_value, old_value)
+      end
+  end
+end

data/lib/rugui/observable_property_support.rb

@@ -0,0 +1,251 @@
+require 'rugui/observable_property_proxy'
+
+module RuGUI
+  # Adds support to observable properties.
+  module ObservablePropertySupport
+    # Initializes the observable properties. If you override this method, make
+    # sure that you call the <code>initialize_observable_property_support</code>
+    # method, so that the observable properties are initialized.
+    def initialize(observable_properties_values = {})
+      initialize_observable_property_support(observable_properties_values)
+    end
+
+    # Initializes observable properties, setting their initial value.
+    def initialize_observable_property_support(observable_properties_values = {})
+      self.class.observable_properties_options.each do |property, options|
+        value = (observable_properties_values.with_indifferent_access[property] || clone_if_possible(options[:initial_value]))
+        send("#{property}=", value)
+      end
+    end
+
+    # Registers an observer for this model.
+    #
+    # The observer must implement a method with this signature:
+    #
+    #   property_updated(observable, property, new_value, old_value)
+    #
+    # This method is called whenever a property has changed its value. One
+    # option is to include the PropertyObserver module in the observer class.
+    #
+    # Optionally, if <code>observable_name</code> can be given, a method with
+    # this signature will also be called:
+    #
+    #   named_observable_property_updated(observable_name, observable, property, new_value, old_value)
+    #
+    def register_observer(observer, observable_name = nil)
+      initialize_observers_if_needed
+      @observers << observer
+      @named_observers[observable_name] = observer unless observable_name.nil?
+    end
+
+    # Called whenver the a property has changed.
+    def property_changed(property, new_value, old_value)
+      initialize_observers_if_needed
+      @observers.each do |observer|
+        observer.property_updated(self, property, new_value, old_value) if observer.respond_to?(:property_updated)
+      end
+      @named_observers.each do |observable_name, observer|
+        observer.named_observable_property_updated(observable_name, self, property, new_value, old_value) if observer.respond_to?(:named_observable_property_updated)
+      end
+    end
+
+    # Resets all observable properties for this observer.
+    #
+    # Since an observable property may be another observable there may exist
+    # some observers observing this other observable. In this scenario one
+    # should not attempt to set a new object into the observable property,
+    # because the observers would still be looking for the old observable.
+    #
+    # By calling <code>reset!</code> all observable properties are reset to the
+    # values specified when creating it. Also if the property respond to reset
+    # the method will be called, unless a *reset_value* is configured, i.e., it
+    # is not <code>nil</code>. Also, if *prevent_reset* is true, that property
+    # will not be reseted, even if it has a *reset_value* configured.
+    def reset!
+      self.class.observable_properties_options.each do |property, options|
+        unless options[:prevent_reset]
+          property_value = send(property)
+          if options[:reset_value].nil? and property_value.respond_to?(:reset!)
+            property_value.reset!
+          else
+            send("#{property}=", clone_if_possible(options[:reset_value]))
+          end
+        end
+      end
+    end
+
+    # Returns <code>true</code> if <code>obj</code> is equals to
+    # <code>self</code>.
+    #
+    # This method checks if <code>obj</code> is of the same type of
+    # <code>self</code> and if all *core* observable_properties are equals.
+    def ==(obj)
+      if obj.is_a?(self.class)
+        self.class.core_observable_properties.each do |property|
+          return false unless obj.respond_to?(property) and respond_to?(property)
+          return false unless send(property) == obj.send(property)
+        end
+        return true
+      end
+    end
+
+    # Copies all observable properties from _other_observable_ to _self_
+    def copy_observable_properties_from(other_observable, deep = true)
+      self.class.observable_properties.each do |property|
+        if other_observable.respond_to?(property)
+          other_property_value = other_observable.send(property)
+          if other_property_value.class.include?(ObservablePropertySupport)
+            send(property).copy_observable_properties_from(other_property_value) if deep
+          else
+            send("#{property}=", other_property_value)
+          end
+        end
+      end
+    end
+
+    # Returns a map of all observable properties with theirs values.
+    def observable_properties
+      self.class.observable_properties.inject({}) { |properties, property| properties.merge!({ property => send(property) }) }
+    end
+
+    # Update observable properties values given a map of values
+    def update_observable_properties(values = {})
+      values.each { |property, value| send("#{property}=", value) if self.respond_to?("#{property}=") }
+    end
+
+    module ClassMethods
+      # Creates the necessary class inheritable attributes an initializes them.
+      def create_class_inheritable_attributes
+        self.class_inheritable_accessor :observable_properties_options
+
+        self.observable_properties_options = {}
+      end
+
+      # Register a observable properties for this model.
+      #
+      # Properties may be given as symbols, or strings. You can pass some
+      # options, in a hash, which will be used when the observable is created:
+      #
+      # - *initial_value*: The initial value for the property. This value will
+      # be set when the observable instance is initialized (i.e., when the
+      # <code>initialize</code> method is called). Defaults to <code>nil</code>.
+      # - *reset_value*: The reset value for the property. This value will be
+      # set when the observable instance is reset (i.e., when the
+      # <code>reset!</code> method is called). If this is not given, the
+      # <code>initial_value</code> will be used instead.
+      # - *core*: Defines whether the property should be used when comparing two
+      # observables. Defaults to <code>false</code>.
+      # - *prevent_reset*: If this is <code>true</code> the property will not be
+      # reseted. Defaults to false.
+      # - *boolean*: If this is <code>true</code> a "question" method will be
+      # created for the property (i.e., for a property named <code>foo</code>
+      # a method named <code>foo?</code> will be created).
+      #
+      # Examples:
+      #
+      #   class MyObservable
+      #     include RuGUI::ObservablePropertySupport
+      #
+      #     observable_property :foo, :initial_value => "bar"
+      #     observable_property :bar, :initial_value => "foo", :reset_value => "bar"
+      #     observable_property :core_property, :core => true
+      #     observable_property :non_resetable_property, :prevent_reset => true
+      #
+      #     # And so on...
+      #   end
+      def observable_property(property, options = {})
+        create_observable_property_options(property, options)
+        create_observable_property_accessors(property)
+        create_observable_property_boolean_readers(property, options)
+      end
+
+      # Returns the names of core observable properties for this class.
+      def core_observable_properties
+        core_observable_properties = []
+        observable_properties_options.each do |property, options|
+          core_observable_properties << property if options[:core] == true
+        end
+        core_observable_properties
+      end
+
+      # Returns the names of all observable properties for this class.
+      def observable_properties
+        observable_properties_options.keys
+      end
+
+      private
+        def create_observable_property_options(property, options = {})
+          self.observable_properties_options[property.to_sym] = prepare_options(options)
+        end
+
+        def create_observable_property_accessors(property)
+          self.class_eval <<-class_eval
+            def #{property}
+              @#{property}
+            end
+
+            def #{property}=(value)
+              old_value = get_old_value(@#{property})
+              if has_changed?(value, old_value)
+                @#{property} = ObservablePropertyProxy.new(value, self, '#{property}')
+                property_changed('#{property}', value, old_value)
+              end
+            end
+          class_eval
+        end
+
+        def create_observable_property_boolean_readers(property, options)
+          if options[:boolean]
+            self.class_eval <<-class_eval
+              def #{property}?
+                self.#{property} == true
+              end
+            class_eval
+          end
+        end
+
+        def prepare_options(options)
+          options = default_options.merge(options)
+          if options[:reset_value].nil? and not options[:initial_value].class.include?(ObservablePropertySupport)
+            options[:reset_value] = options[:initial_value]
+          end
+          options
+        end
+
+        def default_options
+          { :core => false,
+            :initial_value => nil,
+            :reset_value => nil }
+        end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.create_class_inheritable_attributes
+    end
+
+    private
+      def initialize_observers_if_needed
+        @observers = [] if not defined?(@observers) or @observers.nil?
+        @named_observers = {} if not defined?(@named_observers) or @named_observers.nil?
+      end
+
+      def get_old_value(property)
+        begin
+          return property.clone
+        rescue TypeError
+          return property
+        end
+      end
+
+      def has_changed?(new_value, old_value)
+        !(new_value.kind_of?(old_value.class) && old_value == new_value)
+      end
+
+      def clone_if_possible(value)
+        value.clone
+      rescue TypeError
+        value
+      end
+  end
+end

data/lib/rugui/plugin/loader.rb

@@ -0,0 +1,77 @@
+module RuGUI
+  module Plugin
+    class Loader
+      attr_accessor :initializer
+      attr_accessor :configurations
+      cattr_accessor :located_plugins
+
+      def initialize(initializer, configurations)
+        self.initializer = initializer
+        self.configurations = configurations
+        @@located_plugins ||= []
+      end
+
+      def load_plugins
+        plugins.each do |plugin|
+          plugin.load unless plugin.loaded?
+          register_as_loaded(plugin)
+        end
+      end
+
+      def plugins
+        @plugins ||= locate_plugins
+      end
+
+      protected
+        # Locate all plugins in APPLICATION_ROOT/vendor/plugins
+        def locate_plugins
+          Dir.glob(File.join(APPLICATION_ROOT, "vendor", "plugins", "*")).each do |dir|
+            @@located_plugins << Location.new(dir)
+          end
+          @@located_plugins
+        end
+
+        # Register plugins as loaded.
+        def register_as_loaded(plugin)
+          plugin.loaded = true
+        end
+    end
+
+    # This class is a representation of RuGUI plugins.
+    class Location
+      attr_accessor :plugin_name
+      attr_accessor :dir
+      attr_accessor :loaded
+
+      include RuGUI::LogSupport
+
+      def initialize(dir)
+        self.dir = dir
+        self.plugin_name = dir.split(File::SEPARATOR).last
+      end
+
+      # Load plugins.
+      def load
+        $LOAD_PATH.unshift(File.join(self.dir, "lib")) if File.directory?(self.dir)
+        $LOAD_PATH.uniq!
+
+        init_file = File.expand_path(File.join(self.dir, "init.rb"))
+        if File.exist?(init_file)
+          require_for init_file
+        else
+          logger.warn "The init file for (#{self.plugin_name}) was not found."
+        end
+      end
+
+      def require_for(init_file)
+        require init_file
+      rescue Exception
+        logger.error "An error occurred while loading #{self.plugin_name}. Checks its init file: #{$!}"
+      end
+
+      def loaded?
+        self.loaded ||= false
+      end
+    end
+  end
+end