intelitiva-rugui 1.2.0

data/Changelog

@@ -0,0 +1,54 @@
+1.2.0
+- Added support for gems dependency mechanism
+
+1.1.2
+- Updated README docs
+
+1.1.1
+- Added support to prevent root widgets of views from being displayed by passing false to use_builder class method.
+- Created a find_child in QT adapter since QT's one is not working.
+- Fixing a error when creating views which doesn't use builder files.
+- Removed unnecessary requires in framework files
+
+1.1.0
+- Added support to Qt4 as well as GTK as backend GUI frameworks.
+- Added a DSL to connect signals to controllers and views.
+
+1.0.0
+- Created a RuGUI::BaseObject which implements the inspect method for RuGUI related objects.
+- Added some generators (for models, controllers and views with its resources).
+- Added support for before/after initialize hooks for Controller, View, ViewHelper and Model base classes.
+- Using Pathname to wrap Configuration#root_path. Now you can use configuration.root_path.join('my_path'), instead of File.join(configuration.root_path, 'my_path')
+
+0.6.0
+- Added a method to quickly get the main controller from any BaseController.
+- Now the application generator creates a /bin directory with a bash and bat scripts to run the application
+- Fixing a small bug with update_observable_properties method
+
+0.5.0
+- Added a method to update observable properties values.
+- Added support to set initial values of observable properties while instancing an object, using a map (property + value).
+- Added a method to get all observable properties of an object with theirs values.
+- Using class_inheritable_accessor instead of using class variables for observable properties options in ObservablePropertySupport
+- Using class_inheritable_accessor instead of creating fake class attributes in BaseView
+- Added method setup_view_helpers in BaseView, so that one can register more helpers if needed.
+- Fixed a bug where named observable property change methods were not being called when an observable property was changed.
+- Added :prevent_reset option to observable properties.
+- Added :boolean options to observable properties, which automatically creates 'question' methods for the properties.
+- Added a method to copy all observable properties from one observable to another.
+- Fixed an issue which caused observable properties not to be copied when a hash with string keys was given when creating an observable or when updating its observable properties
+- Boolean observable properties 'question' accessors now can be used directly in if's
+
+0.4.0
+- Added plugins support
+
+0.3.0
+- PropertyObserver was receiving notifications from named observables even when the name of the observer was the same as the class name.
+- Migrated tests from TestUnit to RSpec.
+- Added application generator.
+
+0.2.1
+- Adding support to execute RuGUI application in various environments
+
+0.2.0
+- Initial Release, forked from RubyGtkMvc code.

data/LICENSE

@@ -0,0 +1,165 @@
+		   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions. 
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version. 
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README

@@ -0,0 +1,67 @@
+= RuGUI
+
+RuGUI is a framework which aims to help building desktop applications. RuGUI was
+mostly inspired by the *Ruby on Rails* framework, taking most of its features
+from it.
+
+RuGUI approach is to provide a MVC design for the application, separating
+business logic from application presentation, making it easy to maintain and
+evolve the application.
+
+Also, a Observer/Observable pattern is implemented so that you can define
+observable properties in your model which are observed by controllers that
+should react to changes in the model. This makes the application code even more
+clean when dealing with applications that have multiple data entry points. For
+example, when receiving data from a network one may update a value in a model,
+and the controller will update all needed widgets (progress bars, labels, status
+bar, etc).
+
+The initial framework was based on the great Ruby/GTK API, but RuGUI has evolved
+so that you may use other GUI frameworks with it. Since version 1.1.x it has
+placed all functionality specific for GTK wrapped in a framework adapter. This
+has made it possible to write a QT adapter and now it is possible to use all of
+the RuGUI features together with QT. As the framework evolve other framework
+adapters may be written, enabling the use of RuGUI with any other GUI frameworks.
+
+== Instalation
+
+Download the source from:
+
+    http://github.com/intelitiva/rugui/tree/master
+
+Next, build and install the gem:
+
+    gem build rugui.gemspec
+    gem install rugui-X.X.X.gem
+
+To check if the installation was successful type in a console:
+
+    rugui -v
+
+== Dependencies
+
+RuGUI depends, of course, on the Ruby binding for the GUI framework that you'll
+use. It is known to work on Linux and Windows plataforms. Currently it depends
+on the ActiveSupport gem, which can be installed by:
+
+  gem install activesupport
+
+To be able to generate applications and controllers/models/views, you will need
+the rubigen gem, which can be installed by:
+
+  gem install rubigen
+
+== Generating an Application
+
+To generate an application, go to the directory where you want to create the
+application and type:
+
+    rugui <app_name>
+
+For more options type:
+
+    rugui -h
+
+== More info
+
+http://rugui.org

data/Rakefile

@@ -0,0 +1,11 @@
+#
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'rubygems'
+require 'rugui/tasks/rugui_framework'

data/bin/rugui

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rubigen'
+
+if %w(-v --version).include? ARGV.first
+  require 'rugui/version'
+  puts "RuGUI #{RuGUI::VERSION::STRING}"
+  exit(0)
+end
+
+require 'rubigen/scripts/generate'
+source = RubiGen::PathSource.new(:application, File.join(File.dirname(__FILE__), "../rugui_generators"))
+RubiGen::Base.reset_sources
+RubiGen::Base.append_sources source
+RubiGen::Scripts::Generate.new.run(ARGV, :generator => 'rugui')

data/lib/rugui/base_controller.rb

@@ -0,0 +1,194 @@
+module RuGUI
+  #
+  # Base class for all controllers.
+  #
+  class BaseController < BaseObject
+    include RuGUI::PropertyObserver
+    include RuGUI::LogSupport
+    include RuGUI::SignalSupport
+
+    attr_accessor :models
+    attr_accessor :views
+    attr_accessor :controllers
+    attr_accessor :parent_controller
+
+    def initialize(parent_controller = nil)
+      @models = {}
+      @views = {}
+      @controllers = {}
+
+      if parent_controller.nil?
+        @parent_controller = self
+      else
+        @parent_controller = parent_controller
+      end
+
+      setup_models
+      setup_views
+      setup_controllers
+    end
+
+    # This is included here so that the initialize method is properly updated.
+    include RuGUI::InitializeHooks
+
+    # Returns the framework_adapter for this class.
+    def framework_adapter
+      framework_adapter_for('BaseController')
+    end
+
+    #
+    # Registers a model for this controller.
+    #
+    # If the given model is a string or symbol, it will be camelized and
+    # a new instance of the model class will be created.
+    #
+    def register_model(model, name = nil)
+      model = create_instance(model) if model.is_a?(String) or model.is_a?(Symbol)
+      name ||= model.class.to_s.underscore
+      model.register_observer(self, name)
+      @models[name.to_sym] = model
+      create_model_attribute_reader(name)
+
+      model.post_registration(self)
+    end
+
+    #
+    # Registers a view for this controller.
+    #
+    # If the given view is a string or symbol, it will be camelized and a new
+    # instance of the view class will be created.
+    #
+    def register_view(view, name = nil)
+      view = create_instance(view) if view.is_a?(String) or view.is_a?(Symbol)
+      name ||= view.class.to_s.underscore
+      view.register_controller(self)
+      @views[name.to_sym] = view
+      create_view_attribute_reader(name)
+
+      view.post_registration(self)
+    end
+
+    #
+    # Registers a child controller for this controller.
+    #
+    # If the given controller is a string or symbol, it will be camelized and
+    # a new instance of the controller class will be created.
+    #
+    def register_controller(controller, name = nil)
+      controller = create_instance(controller, self) if controller.is_a?(String) or controller.is_a?(Symbol)
+      name ||= controller.class.to_s.underscore
+      controller.parent_controller = self
+      @controllers[name.to_sym] = controller
+      create_controller_attribute_reader(name)
+
+      controller.post_registration
+    end
+
+    #
+    # Called after the controller is registered in another one.
+    #
+    def post_registration
+    end
+
+    # Returns the main controller instance.
+    #
+    # This is an useful way to quickly access the main controller from any other
+    # controller. Since applications may have only one main controller and it is
+    # always the 'root' of the tree of controllers, this provides indirect
+    # access to any other controller in the application.
+    #
+    # NOTE: The main controller is cached, so that subsequent calls are faster.
+    def main_controller
+      @main_controller ||= find_main_controller
+    end
+
+    protected
+      #
+      # Subclasses should reimplement this to register models.
+      #
+      def setup_models
+      end
+
+      #
+      # Subclasses should reimplement this to register views.
+      #
+      def setup_views
+      end
+
+      #
+      # Subclasses should reimplement this to register controllers.
+      #
+      def setup_controllers
+      end
+
+    private
+      def create_instance(klass_name, *args)
+        klass_name.to_s.camelize.constantize.new(*args)
+      end
+
+      # Creates an attribute reader for the model.
+      def create_model_attribute_reader(name)
+        create_attribute_reader(:models, name)
+      end
+
+      # Creates an attribute reader for the view.
+      def create_view_attribute_reader(name)
+        create_attribute_reader(:views, name)
+      end
+
+      # Creates an attribute reader for the controller.
+      def create_controller_attribute_reader(name)
+        create_attribute_reader(:controllers, name)
+      end
+
+      # Creates an attribute reader for the some entity.
+      def create_attribute_reader(entity, name)
+        self.class.class_eval <<-class_eval
+          def #{name}
+            @#{entity}[:#{name}]
+          end
+        class_eval
+      end
+      
+      # Navigates through the controllers hierarchy trying to find the main
+      # controller (i.e., a class that extends RuGUI::BaseMainController).
+      def find_main_controller
+        if self.parent_controller.is_a?(RuGUI::BaseMainController)
+          self.parent_controller
+        elsif self.parent_controller == self
+          return nil
+        else
+          self.parent_controller.main_controller
+        end
+      end
+  end
+
+  #
+  # A base class for main controllers.
+  #
+  # Provides a method for running the application as well as a method to quit.
+  #
+  class BaseMainController < BaseController
+    # Returns the framework_adapter for this class.
+    def framework_adapter
+      framework_adapter_for('BaseMainController')
+    end
+
+    #
+    # Runs the application.
+    #
+    def run
+      logger.info "Starting the application through #{self.class.name}."
+      self.framework_adapter.run
+    end
+
+    #
+    # Exits from the application.
+    #
+    def quit
+      logger.info "Exiting the application through #{self.class.name}."
+      self.framework_adapter.quit
+      logger.info "Application finished."
+    end
+  end
+end

data/lib/rugui/base_model.rb

@@ -0,0 +1,22 @@
+module RuGUI
+  class BaseModel < BaseObject
+    include RuGUI::ObservablePropertySupport
+    include RuGUI::LogSupport
+    
+    def initialize(observable_properties_values = {})
+      initialize_observable_property_support(observable_properties_values)
+    end
+
+    # This is included here so that the initialize method is properly updated.
+    include RuGUI::InitializeHooks
+
+    # Returns the framework_adapter for this class.
+    def framework_adapter
+      framework_adapter_for('BaseModel')
+    end
+
+    # Called after the model is registered in a controller.
+    def post_registration(controller)
+    end
+  end
+end

data/lib/rugui/base_object.rb

@@ -0,0 +1,73 @@
+module RuGUI
+  # A base object for all RuGUI classes.
+  #
+  # It mainly defines customized inspect which will display only some of the
+  # instance variables, avoiding excessive overhead when generating tracebacks.
+  class BaseObject
+    # All RuGUI objects can have access to framework adapters.
+    include RuGUI::FrameworkAdapters::FrameworkAdapterSupport
+
+    # Returns a string containing a human-readable representation of obj.
+    #
+    # It will display each instance variable value unless it is also a
+    # RuGUI::BaseObject.
+    def inspect
+      instance_variables_values = instance_variables.collect do |instance_variable_name|
+        instance_variable_value = instance_variable_get(instance_variable_name)
+        inspected_instance_variable_value = nil
+        if instance_variable_value.is_a?(RuGUI::BaseObject)
+          inspected_instance_variable_value = inspect_base_object(instance_variable_value)
+        elsif instance_variable_value.is_a?(Array)
+          inspected_instance_variable_value = inspect_array(instance_variable_value)
+        elsif instance_variable_value.is_a?(Hash)
+          inspected_instance_variable_value = inspect_hash(instance_variable_value)
+        else
+          inspected_instance_variable_value = instance_variable_value.inspect
+        end
+
+        "#{instance_variable_name}=#{inspected_instance_variable_value}"
+      end
+
+      "#<#{self.class.name} #{instance_variables_values.join(" ")}>"
+    end
+
+    protected
+      def inspect_base_object(base_object_value)
+        "#<#{base_object_value.class.inspect}>"
+      end
+
+      def inspect_array(array_value)
+        array_values = array_value.collect do |item|
+          if item.is_a?(RuGUI::BaseObject)
+            inspect_base_object(item)
+          elsif item.is_a?(Array)
+            inspect_array(item)
+          elsif item.is_a?(Hash)
+            inspect_hash(item)
+          else
+            item.inspect
+          end
+        end
+
+        "[#{array_values.join(', ')}]"
+      end
+
+      def inspect_hash(hash_value)
+        hash_values = hash_value.collect do |key, value|
+          inspected_value = nil
+          if value.is_a?(RuGUI::BaseObject)
+            inspected_value = inspect_base_object(value)
+          elsif value.is_a?(Array)
+            inspected_value = inspect_array(value)
+          elsif value.is_a?(Hash)
+            inspected_value = inspect_hash(value)
+          else
+            inspected_value = value.inspect
+          end
+          "#{key.inspect}=>#{inspected_value}"
+        end
+
+        "{#{hash_values.join(', ')}}"
+      end
+  end
+end