rugui 1.2.0

data/lib/rugui/framework_adapters/Qt4.rb

@@ -0,0 +1,171 @@
+require 'Qt4'
+require 'qtuitools'
+
+module Qt
+  def Qt.create_application
+    @@application = Qt::Application.new(ARGV)
+  end
+
+  def Qt.application
+    @@application
+  end
+end
+
+Qt.create_application
+
+module RuGUI
+  module FrameworkAdapters
+    module Qt4
+      class BaseController < RuGUI::FrameworkAdapters::BaseFrameworkAdapter::BaseController
+        def queue(&block)
+          block.call
+        end
+      end
+
+      class BaseMainController < RuGUI::FrameworkAdapters::Qt4::BaseController
+        def run
+          Qt.application.exec
+        end
+
+        def quit
+          Qt.application.exit
+        end
+      end
+
+      class BaseView < RuGUI::FrameworkAdapters::BaseFrameworkAdapter::BaseView
+        # Queues the block call, so that it is only gets executed in the main thread.
+        def queue(&block)
+          block.call
+        end
+
+        # Adds a widget to the given container widget.
+        def add_widget_to_container(widget, container_widget)
+          widget.parent = container_widget
+        end
+
+        # Removes a widget from the given container widget.
+        def remove_widget_from_container(widget, container_widget)
+          widget.parent = nil
+        end
+
+        # Removes all children from the given container widget.
+        def remove_all_children(container_widget)
+          container_widget.children.each do |child|
+            child.parent = nil
+          end
+        end
+
+        # Sets the widget name for the given widget if given.
+        def set_widget_name(widget, widget_name)
+          widget.object_name = widget_name
+        end
+
+        # Autoconnects signals handlers for the view. If +other_target+ is given
+        # it is used instead of the view itself.
+        def autoconnect_signals(view, other_target = nil)
+          # Qt4 doesn't provides a method for autoconnecting signals.
+        end
+
+        # Connects the signal from the widget to the given receiver block.
+        # The block is executed in the context of the receiver.
+        def connect_declared_signal_block(widget, signal, receiver, block)
+          widget.connect(SIGNAL(signal)) do |*args|
+            receiver.instance_exec(*args, &block)
+          end
+        end
+
+        # Connects the signal from the widget to the given receiver method.
+        def connect_declared_signal(widget, signal, receiver, method)
+          widget.connect(SIGNAL(signal)) do |*args|
+            receiver.send(method, *args)
+          end
+        end
+
+        # Builds widgets from the given filename, using the proper builder.
+        def build_widgets_from(filename)
+          ui_file_root_widget = load_ui_file(filename)
+          @view_root_widget = root_widget_from(ui_file_root_widget)
+          create_attributes_for_widget_and_children(@view_root_widget)
+          @view_root_widget.show if self.adapted_object.display_root?
+        end
+
+        # Registers widgets as attributes of the view class.
+        def register_widgets
+          register_widget_and_children(@view_root_widget)
+        end
+
+        class << self
+          # Returns the builder file extension to be used for this view class.
+          def builder_file_extension
+            'ui'
+          end
+        end
+
+        private
+          def load_ui_file(filename)
+            file = Qt::File.new(filename)
+            file.open(Qt::File::ReadOnly)
+            loader = Qt::UiLoader.new
+            loader.load(file, nil)
+          end
+
+          def root_widget_from(ui_file_root_widget)
+            self.adapted_object.root.nil? ? ui_file_root_widget : find_child(ui_file_root_widget, self.adapted_object.root)
+          end
+
+          def create_attributes_for_widget_and_children(widget)
+            self.adapted_object.send(:create_attribute_for_widget, widget.object_name)
+            widget.children.each do |child|
+              create_attributes_for_widget_and_children(child) unless child.object_name.blank?
+            end
+          end
+
+          # Registers widgets as attributes of the view class.
+          def register_widget_and_children(widget)
+            register_widget(widget)
+            widget.children.each do |child|
+              register_widget_and_children(child)
+            end
+          end
+
+          def register_widget(widget)
+            unless widget.object_name.nil?
+              self.adapted_object.send("#{widget.object_name}=", widget)
+              self.adapted_object.widgets[widget.object_name] = widget
+            else
+              self.adapted_object.unnamed_widgets << widget
+            end
+          end
+
+          # XXX: Qt's find_child is not working, so we do it ourselves, this is surely not optimal.
+          def find_child(widget, widget_name)
+            for child in widget.children
+              if child.object_name == widget_name
+                return child
+              else
+                child_found = find_child(child, widget_name)
+                return child_found unless child_found.blank?
+              end
+            end
+          end
+      end
+    end
+  end
+end
+
+module RuGUI
+  class BaseView < BaseObject
+    # An utility method to connect Qt signals between two Qt::Object.
+    #
+    # If receiver is given, it will be used instead of the view itself.
+    def connect(sender, signal, slot, receiver = nil)
+      sender = from_widget_or_name(sender)
+      receiver = receiver.nil? ? self : from_widget_or_name(receiver)
+      if receiver.is_a?(Qt::Object)
+        Qt::Object.connect(sender, SIGNAL(signal), receiver, SLOT(slot))
+      elsif receiver.is_a?(RuGUI::BaseObject)
+        sender.connect(SIGNAL(signal)) { |*args| receiver.send(slot, *args) if receiver.respond_to?(slot) }
+      end
+    end
+  end
+end

data/lib/rugui/framework_adapters/base_framework_adapter.rb

@@ -0,0 +1,90 @@
+module RuGUI
+  module FrameworkAdapters
+    module BaseFrameworkAdapter
+      class Base
+        attr_accessor :adapted_object
+
+        def initialize(adapted_object)
+          self.adapted_object = adapted_object
+        end
+      end
+
+      # Adapts the BaseController methods specific for the framework.
+      class BaseController < Base
+        # Queues the block call, so that it is only gets executed in the main thread.
+        def queue(&block)
+        end
+      end
+
+      # Adapts the BaseMainController methods specific for the framework.
+      class BaseMainController < RuGUI::FrameworkAdapters::BaseFrameworkAdapter::BaseController
+        # Runs the application, starting anything the framework needs.
+        def run
+        end
+
+        # Exits the application, freeing any resources used by the framework.
+        def quit
+        end
+      end
+
+      # Adapts the BaseModel methods specific for the framework
+      class BaseModel < Base
+      end
+
+      # Adapts the BaseView methods specific for the framework
+      class BaseView < Base
+        # Queues the block call, so that it is only gets executed in the main thread.
+        def queue(&block)
+        end
+
+        # Adds a widget to the given container widget.
+        def add_widget_to_container(widget, container_widget)
+        end
+
+        # Removes a widget from the given container widget.
+        def remove_widget_from_container(widget, container_widget)
+        end
+
+        # Removes all children from the given container widget.
+        def remove_all_children(container_widget)
+        end
+
+        # Sets the widget name for the given widget if given.
+        def set_widget_name(widget, widget_name)
+        end
+
+        # Autoconnects signals handlers for the view. If +other_target+ is given
+        # it is used instead of the view itself.
+        def autoconnect_signals(view, other_target = nil)
+        end
+
+        # Connects the signal from the widget to the given receiver block.
+        # The block is executed in the context of the receiver.
+        def connect_declared_signal_block(widget, signal, receiver, block)
+        end
+
+        # Connects the signal from the widget to the given receiver method.
+        def connect_declared_signal(widget, signal, receiver, method)
+        end
+
+        # Builds widgets from the given filename, using the proper builder.
+        def build_widgets_from(filename)
+        end
+
+        # Registers widgets as attributes of the view class.
+        def register_widgets
+        end
+
+        class << self
+          # Returns the builder file extension to be used for this view class.
+          def builder_file_extension
+          end
+        end
+      end
+
+      # Adapts the BaseViewHelper methods specific for the framework
+      class BaseViewHelper
+      end
+    end
+  end
+end

data/lib/rugui/framework_adapters/framework_adapter_support.rb

@@ -0,0 +1,35 @@
+ require 'rugui/framework_adapters/base_framework_adapter'
+
+module RuGUI
+  module FrameworkAdapters
+    module FrameworkAdapterSupport
+      def framework_adapter_for(class_name)
+        @framework_adapter ||= {}
+        load_framework_adapter(class_name) unless @framework_adapter[class_name]
+        @framework_adapter[class_name]
+      end
+
+      def load_framework_adapter(class_name)
+        @framework_adapter[class_name] = class_adapter_for(class_name).new(self)
+      end
+
+      module CommonClassAndInstanceMethods
+        def adapter_module_name(framework_adapter = RuGUI.configuration.framework_adapter)
+          "RuGUI::FrameworkAdapters::#{framework_adapter.camelize}"
+        end
+
+        def class_adapter_for(class_name)
+          "#{adapter_module_name}::#{class_name}".constantize
+        rescue
+          # Fallback to the base_framework_adapter.
+          "#{adapter_module_name('base_framework_adapter')}::#{class_name}".constantize
+        end
+      end
+
+      def self.included(base)
+        base.send(:include, CommonClassAndInstanceMethods)
+        base.extend(CommonClassAndInstanceMethods)
+      end
+    end
+  end
+end

data/lib/rugui/gem_builder.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'rubygems/installer'
+
+module RuGUI
+
+  # this class hijacks the functionality of Gem::Installer by overloading its
+  # initializer to only provide the information needed by
+  # Gem::Installer#build_extensions (which happens to be what we have)
+  class GemBuilder < Gem::Installer
+
+    def initialize(spec, gem_dir)
+      @spec    = spec
+      @gem_dir = gem_dir
+    end
+
+    # silence the underlying builder
+    def say(message)
+    end
+
+  end
+end

data/lib/rugui/gem_dependency.rb

@@ -0,0 +1,282 @@
+require 'rugui/vendor_gem_source_index'
+
+module Gem
+  def self.source_index=(index)
+    @@source_index = index
+  end
+end
+
+module RuGUI
+  class GemDependency < Gem::Dependency
+    attr_accessor :lib, :source, :dep
+
+    def self.unpacked_path
+      @unpacked_path ||= File.join(APPLICATION_ROOT, 'vendor', 'gems')
+    end
+
+    @@framework_gems = {}
+
+    def self.add_frozen_gem_path
+      @@paths_loaded ||= begin
+        source_index = RuGUI::VendorGemSourceIndex.new(Gem.source_index)
+        Gem.clear_paths
+        Gem.source_index = source_index
+        # loaded before us - we can't change them, so mark them
+        Gem.loaded_specs.each do |name, spec|
+          @@framework_gems[name] = spec
+        end
+        true
+      end
+    end
+
+    def initialize(name, options = {})
+      require 'rubygems' unless Object.const_defined?(:Gem)
+
+      if options[:requirement]
+        req = options[:requirement]
+      elsif options[:version]
+        req = Gem::Requirement.create(options[:version])
+      else
+        req = Gem::Requirement.default
+      end
+
+      @lib      = options[:lib]
+      @source   = options[:source]
+      @loaded   = @frozen = @load_paths_added = false
+
+      super(name, req)
+    end
+
+    def add_load_paths
+      self.class.add_frozen_gem_path
+      return if @loaded || @load_paths_added
+      if framework_gem?
+        @load_paths_added = @loaded = @frozen = true
+        return
+      end
+      gem self
+      @spec = Gem.loaded_specs[name]
+      @frozen = @spec.loaded_from.include?(self.class.unpacked_path) if @spec
+      @load_paths_added = true
+    rescue Gem::LoadError
+    end
+
+    def dependencies
+      return [] if framework_gem?
+      return [] unless installed?
+      specification.dependencies.reject do |dependency|
+        dependency.type == :development
+      end.map do |dependency|
+        GemDependency.new(dependency.name, :requirement => dependency.version_requirements)
+      end
+    end
+
+    def specification
+      # code repeated from Gem.activate. Find a matching spec, or the currently loaded version.
+      # error out if loaded version and requested version are incompatible.
+      @spec ||= begin
+        matches = Gem.source_index.search(self)
+        matches << @@framework_gems[name] if framework_gem?
+        if Gem.loaded_specs[name] then
+          # This gem is already loaded.  If the currently loaded gem is not in the
+          # list of candidate gems, then we have a version conflict.
+          existing_spec = Gem.loaded_specs[name]
+          unless matches.any? { |spec| spec.version == existing_spec.version } then
+            raise Gem::Exception,
+                  "can't activate #{@dep}, already activated #{existing_spec.full_name}"
+          end
+          # we're stuck with it, so change to match
+          version_requirements = Gem::Requirement.create("=#{existing_spec.version}")
+          existing_spec
+        else
+          # new load
+          matches.last
+        end
+      end
+    end
+
+    def requirement
+      r = version_requirements
+      (r == Gem::Requirement.default) ? nil : r
+    end
+
+    def built?
+      # TODO: If Rubygems ever gives us a way to detect this, we should use it
+      false
+    end
+
+    def framework_gem?
+      @@framework_gems.has_key?(name)
+    end
+
+    def frozen?
+      @frozen ||= vendor_rugui? || vendor_gem?
+    end
+
+    def installed?
+      Gem.loaded_specs.keys.include?(name)
+    end
+
+    def load_paths_added?
+      # always try to add load paths - even if a gem is loaded, it may not
+      # be a compatible version (ie random_gem 0.4 is loaded and a later spec
+      # needs >= 0.5 - gem 'random_gem' will catch this and error out)
+      @load_paths_added
+    end
+
+    def loaded?
+      @loaded ||= begin
+        if vendor_rugui?
+          true
+        elsif specification.nil?
+          false
+        else
+          # check if the gem is loaded by inspecting $"
+          # specification.files lists all the files contained in the gem
+          gem_files = specification.files
+          # select only the files contained in require_paths - typically in bin and lib
+          require_paths_regexp = Regexp.new("^(#{specification.require_paths*'|'})/")
+          gem_lib_files = gem_files.select { |f| require_paths_regexp.match(f) }
+          # chop the leading directory off - a typical file might be in
+          # lib/gem_name/file_name.rb, but it will be 'require'd as gem_name/file_name.rb
+          gem_lib_files.map! { |f| f.split('/', 2)[1] }
+          # if any of the files from the above list appear in $", the gem is assumed to
+          # have been loaded
+          !(gem_lib_files & $").empty?
+        end
+      end
+    end
+
+    def vendor_rugui?
+      Gem.loaded_specs.has_key?(name) && Gem.loaded_specs[name].loaded_from.empty?
+    end
+
+    def vendor_gem?
+      specification && File.exists?(unpacked_gem_directory)
+    end
+
+    def build
+      require 'rugui/gem_builder'
+      unless built?
+        return unless File.exists?(unpacked_specification_filename)
+        spec = YAML::load_file(unpacked_specification_filename)
+        RuGUI::GemBuilder.new(spec, unpacked_gem_directory).build_extensions
+        puts "Built gem: '#{unpacked_gem_directory}'"
+      end
+      dependencies.each { |dep| dep.build }
+    end
+
+    def install
+      unless installed?
+        cmd = "#{gem_command} #{install_command.join(' ')}"
+        puts cmd
+        puts %x(#{cmd})
+      end
+    end
+
+    def load
+      return if @loaded || @load_paths_added == false
+      require(@lib || name) unless @lib == false
+      @loaded = true
+    rescue LoadError
+      puts $!.to_s
+      $!.backtrace.each { |b| puts b }
+    end
+
+    def refresh
+      RuGUI::VendorGemSourceIndex.silence_spec_warnings = true
+      real_gems = Gem.source_index.installed_source_index
+      exact_dep = Gem::Dependency.new(name, "= #{specification.version}")
+      matches = real_gems.search(exact_dep)
+      installed_spec = matches.first
+      if frozen?
+        if installed_spec
+          # we have a real copy
+          # get a fresh spec - matches should only have one element
+          # note that there is no reliable method to check that the loaded
+          # spec is the same as the copy from real_gems - Gem.activate changes
+          # some of the fields
+          real_spec = Gem::Specification.load(matches.first.loaded_from)
+          write_specification(real_spec)
+          puts "Reloaded specification for #{name} from installed gems."
+        else
+          # the gem isn't installed locally - write out our current specs
+          write_specification(specification)
+          puts "Gem #{name} not loaded locally - writing out current spec."
+        end
+      else
+        if framework_gem?
+          puts "Gem directory for #{name} not found - check if it's loading before rugui."
+        else
+          puts "Something bad is going on - gem directory not found for #{name}."
+        end
+      end
+    end
+
+    def unpack(options={})
+      unless frozen? || framework_gem?
+        FileUtils.mkdir_p unpack_base
+        Dir.chdir unpack_base do
+          Gem::GemRunner.new.run(unpack_command)
+        end
+        # Gem.activate changes the spec - get the original
+        real_spec = Gem::Specification.load(specification.loaded_from)
+        write_specification(real_spec)
+      end
+      dependencies.each { |dep| dep.unpack } if options[:recursive]
+    end
+
+    def write_specification(spec)
+      # copy the gem's specification into GEMDIR/.specification so that
+      # we can access information about the gem on deployment systems
+      # without having the gem installed
+      File.open(unpacked_specification_filename, 'w') do |file|
+        file.puts spec.to_yaml
+      end
+    end
+
+    def ==(other)
+      self.name == other.name && self.requirement == other.requirement
+    end
+    alias_method :"eql?", :"=="
+
+    private
+
+      def gem_command
+        case RUBY_PLATFORM
+          when /win32/
+            'gem.bat'
+          when /java/
+            'jruby -S gem'
+          else
+            'gem'
+        end
+      end
+
+      def install_command
+        cmd = %w(install) << name
+        cmd << "--version" << %("#{requirement.to_s}") if requirement
+        cmd << "--source"  << @source  if @source
+        cmd
+      end
+
+      def unpack_command
+        cmd = %w(unpack) << name
+        cmd << "--version" << "= "+specification.version.to_s if requirement
+        cmd
+      end
+
+      def unpack_base
+        RuGUI::GemDependency.unpacked_path
+      end
+
+      def unpacked_gem_directory
+        File.join(unpack_base, specification.full_name)
+      end
+
+      def unpacked_specification_filename
+        File.join(unpacked_gem_directory, '.specification')
+      end
+
+  end
+end

data/lib/rugui/initialize_hooks.rb

@@ -0,0 +1,36 @@
+module RuGUI
+  # Adds before/after hooks for initialize method of a class.
+  module InitializeHooks
+    def self.included(base)
+      self.update_initialize_method(base)
+    end
+
+    def self.update_initialize_method(base)
+      base.class_eval <<-class_eval
+        alias :original_initialize :initialize
+
+        def initialize(*args)
+          initialize_with_hooks(*args)
+        end
+      class_eval
+    end
+
+    # Calls the original initialize method with before/after hooks.
+    def initialize_with_hooks(*args)
+      before_initialize
+      original_initialize(*args)
+      after_initialize
+    end
+
+    protected
+      # Called before the initialize method. Subclasses can reimplement this in
+      # order to have custom behavior.
+      def before_initialize
+      end
+
+      # Called after the initialize method. Subclasses can reimplement this in
+      # order to have custom behavior.
+      def after_initialize
+      end
+  end
+end