redcar-dev 0.12.17dev

data/plugins/core/lib/core.rb

@@ -0,0 +1,41 @@
+
+require 'fileutils'
+
+require "core/reentry_helpers"
+require "core/controller"
+require "core/gui"
+require "core/has_spi"
+require "core/interface"
+require "core/model"
+require "core/observable"
+require "core/observable_struct"
+require "core/persistent_cache"
+require "core/plugin"
+require "core/plugin/storage"
+
+begin
+  require 'java'
+  require "core/task"
+  require "core/task_queue"
+  require "core/resource"
+rescue LoadError => e
+end
+
+module Redcar
+  def self.tmp_dir
+    path = File.join(Redcar.user_dir, "tmp")
+    unless File.exists?(path)
+      FileUtils.mkdir(path)
+    end
+    path
+  end
+    
+  class Core
+    def self.loaded
+      unless File.exist?(Redcar.user_dir)
+        FileUtils.mkdir(Redcar.user_dir)
+      end
+      PersistentCache.storage_dir = File.join(Redcar.user_dir, "cache")
+    end
+  end
+end

data/plugins/core/lib/core/controller.rb

@@ -0,0 +1,23 @@
+module Redcar
+  module Controller
+    attr_accessor :model
+    
+    def self.included(klass)
+      klass.class_eval <<-RUBY
+        def self.model_listeners
+          @model_listeners ||= []
+        end
+      
+        def self.model_listener(name)
+          model_listeners << name
+        end
+        
+        def create_model_listeners
+          self.class.model_listeners.each do |name|
+            @model.add_listener(name, &method(name))
+          end
+        end
+      RUBY
+    end
+  end
+end

data/plugins/core/lib/core/gui.rb

@@ -0,0 +1,100 @@
+
+module Redcar
+  class Gui
+    class << self
+      # All defined GUIs
+      def all
+        @all ||= []
+      end
+    end
+    
+    attr_reader :name
+    
+    # Initialize a new named gui.
+    #
+    # @param [String] name for the gui
+    def initialize(name)
+      @name = name
+      @controllers = Hash.new {|h,k| h[k] = []}
+      Gui.all << self
+    end
+    
+    # Set the event loop object for this gui.
+    #
+    # @param [Object] the event loop, which must implement
+    #        start and stop methods
+    def register_event_loop(event_loop)
+      @event_loop = event_loop
+    end
+    
+    # Starts the event loop for this gui.
+    def start
+      if ARGV.include?("--quit-immediately")
+        Redcar.log.info("Quitting straight away")
+        exit
+      else
+        Redcar.log.info("Starting event loop")
+        @event_loop.start
+      end
+    end
+
+    # Lets the even loop run until block returns false
+    def yield_until(&block)
+      @event_loop.yield_until(&block)
+    end
+
+    # Stops the event loop for this gui.
+    def stop
+      @event_loop.stop
+    end
+    
+    # Set the cucumber features runner for this gui.
+    #
+    # @param [Object] the feature runner, which must implement
+    #         a run_features(args) method, where args is the cucumber
+    #         arguments
+    def register_features_runner(feature_runner)
+      @feature_runner = feature_runner
+    end
+    
+    # Run cucumber features
+    #
+    # @param [Array[String]] run cucumber features with these args
+    def run_features(args)
+      @feature_runner.run_features(args)
+    end
+    
+    # Associates a model class and a controller class within this Gui.
+    # Not always necessary, because controllers usually know which
+    # controller to use.
+    #
+    # @param [Hash] model_class => controller_class
+    def register_controllers(options)
+      options.each do |model_class, controller_class|
+        @controllers[model_class] << controller_class
+      end
+    end
+    
+    # Returns the controller class for the given model, or nil
+    #
+    # @param [Object] an instance of a Redcar model
+    def controller_for(model)
+      klass, controller_class = model.class, nil
+      while controller_class == nil and klass != Object
+        unless controller_class = @controllers[klass].first
+          klass = klass.superclass
+        end
+      end
+      raise "no controller for #{model.class}" unless controller_class
+      controller_class
+    end
+    
+    attr_reader :dialog_adapter
+    
+    # Set the dialog adapter for this gui. A dialog adapter must respond to the
+    # standard dialog methods defined in Application::Dialog
+    def register_dialog_adapter(dialog_adapter)
+      @dialog_adapter = dialog_adapter
+    end
+  end
+end

data/plugins/core/lib/core/has_spi.rb

@@ -0,0 +1,10 @@
+
+module Redcar
+  module HasSPI
+    def assert_interface(object, interface)
+      unless object.is_a?(interface)
+        raise "#{object.inspect} expected to be a #{interface}"
+      end
+    end
+  end
+end

data/plugins/core/lib/core/interface.rb

@@ -0,0 +1,73 @@
+# This module helps API authors to document the interfaces their API requires objects
+# to implement.
+# 
+# Example.
+#
+# The EditView class allows plugins to register tab handlers. A tab handler must implement
+# the "handle" method:
+#
+#   class MyTabHandler
+#     def handle(edit_view)
+#     end
+#   end
+#
+# The EditView class wants to check that the object (at least minimally) conforms to the
+# tab handler interface, so it defines an 'example' module and mixes in Interface::Abstract.
+#
+#   class EditView
+#     module Handler
+#       include Interface::Abstract
+#       
+#       def handle(edit_view)
+#       end
+#     end
+#
+# The Abstract module will not allow this example interface to be mixed in anywhere.
+# To verify that any given object conforms to the interface, EditView calls verify_interface!:
+#
+#     def self.register_tab_handler(tab_handler)
+#       EditView::Handler.verify_interface!(tab_handler)
+#       @tab_handlers << tab_handler
+#     end
+#   end
+#
+# This will raise an error if the instance does not implement all the methods in the example
+# interface with the correct aritys.
+class Interface
+  module Abstract
+    def self.included(klass)
+      klass.class_eval do
+        def self.included(klass)
+          raise "#{klass} is trying to mixin #{self}, which is an abstract interface"
+        end
+        
+        def self.verify_interface!(instance)
+          Interface.verify!(self, instance)
+        end
+      end
+    end
+  end
+      
+  class BadInterfaceError < StandardError; end
+  
+  def self.verify(interface, instance)
+    interface.instance_methods.all? do |method_name| 
+      method = interface.instance_method(method_name)
+      instance.respond_to?(method_name) and 
+        instance.method(method_name).arity == method.arity
+    end
+  end
+  
+  def self.verify!(interface, instance)
+    interface.instance_methods.each do |method_name| 
+      method = interface.instance_method(method_name)
+      unless instance.respond_to?(method_name)
+        raise BadInterfaceError, "expected #{instance.inspect} to implement #{interface}, but was missing :#{method_name}"
+      end
+      unless instance.method(method_name).arity == method.arity
+        raise BadInterfaceError, "expected #{instance.inspect} to implement #{interface}, but :#{method_name} arity was not #{method.arity}"
+      end
+    end
+    true
+  end
+end

data/plugins/core/lib/core/model.rb

@@ -0,0 +1,11 @@
+module Redcar
+  module Model
+    include Redcar::ReentryHelpers
+    
+    attr_reader :controller
+    
+    def controller=(controller)
+      @controller = controller
+    end
+  end
+end

data/plugins/core/lib/core/observable.rb

@@ -0,0 +1,115 @@
+
+module Redcar
+  # When mixed into a class this module gives an interface for registering
+  # listeners to particular events. Most Redcar models include this interface.
+  #
+  # ## Examples
+  #
+  # Adding a listener
+  #
+  #     @obj.add_listener :MyHook do
+  #       puts "code to run when MyHook is triggered"
+  #     end
+  #
+  # Triggering a hook (from within the observed class)
+  #
+  #     notify_listeners(:MyHook)
+  #
+  # ## Before and After Hooks
+  #
+  # You can attach code to run before and after an event:
+  #
+  #     @obj.add_listener :after => "MyHook" do
+  #       puts "code to run after MyHook"
+  #     end
+  #     
+  #     @obj.add_listener :before => "MyHook" do
+  #       puts "code to run before MyHook"
+  #     end
+  #
+  # And then the :before blocks are guaranteed to run before the after blocks
+  # and the blocks attached without specifying before and after.
+  #
+  # The event can also be triggered with a block:
+  #
+  #     notify_listeners :MyHook do
+  #       puts "stuff that happens"
+  #     end
+  # 
+  # then the output will be:
+  #
+  #    code to run before MyHook
+  #    stuff that happens
+  #    code to run after MyHook
+  #
+  # ## Triggering with Objects
+  # 
+  # An object may pass an object or objects to its listeners:
+  #
+  #     @obj.add_listener :NewTab do |new_tab|
+  #       puts "do some stuff with the new tab: " + new_tab.to_s
+  #     end
+  #     
+  #     notify_listeners(:NewTab, new_tab)
+  module Observable
+    class UnknownEvent < RuntimeError; end
+    ASPECTS = {
+      :before => 0,
+      :after => 1
+    }
+    
+    # Attach a block to be called when any of the hooks in event_names are 
+    # called.
+    #
+    # @param [Array<Symbol>] names of the events to attach to
+    # @return [Handler] event handler for this object
+    def add_listener(*event_names, &block)
+      if event_names.first.is_a?(Hash)
+        event_names.first.each do |aspect, event_name|
+          observable_events(event_name.to_s)[ASPECTS[aspect]] << block
+        end
+      else
+        event_names.each do |event_name|
+          observable_events(event_name.to_s)[ASPECTS[:after]] << block
+        end
+      end
+      block
+    end
+    
+    # Remove a listener from this object.
+    #
+    # @param [Handler] an event handler as returned by add_listener
+    def remove_listener(handler)
+      @events.each do |_, a|
+        a[0].delete(handler)
+        a[1].delete(handler)
+      end
+    end
+
+    # Run all the listeners attached to this event. 
+    #
+    # @param [Symbol] name of event being run
+    # @param [*Object] event parameters
+    def notify_listeners(event_name, *args)
+      observable_run_blocks(event_name, :before, args)
+      yield if block_given?
+      observable_run_blocks(event_name, :after, args)
+    end
+    
+    private
+    
+    def observable_run_blocks(event_name, aspect, args)
+      blocks = observable_events(event_name.to_s)[ASPECTS[aspect]].clone
+      blocks.map {|b| b.call(*args) }
+    end
+    
+    def observable_events(event_name)
+      @events ||= {}
+      @events[event_name.to_s] ||= [[], []]
+    end
+  end
+end
+
+
+
+

data/plugins/core/lib/core/observable_struct.rb

@@ -0,0 +1,34 @@
+
+# Adds Redcar::Observable to Struct. e.g:
+#
+#   irb> Customer = ObservableStruct.new(:name, :address) 
+#   => Customer
+#   irb> customer = Customer.new("Dave", "123 Main")
+#   => #<Customer name="Dave", address="123 Main">
+#   irb> customer.add_listener(:changed_name) { |new_name| puts "the new name is: #{new_name}" }
+#   => #<Proc:0x65f4cdd2@(irb):203>
+#   irb> customer.name = "Dan"
+#   the new name is Dan
+#   => #<Customer name="Dan", address="123 Main">
+class ObservableStruct
+  def self.new(*args)
+    klass = Struct.new(*args)
+    klass.send(:include, Redcar::Observable)
+    if args.first.is_a?(String)
+      accessors = args[1..-1]
+    else
+      accessors = args
+    end
+    accessors.each do |accessor|
+      klass.class_eval %Q{
+        alias_method :set_#{accessor}, :#{accessor}=
+        def #{accessor}=(val)
+          notify_listeners(:changed_#{accessor}, val) do
+            self.set_#{accessor}(val)
+          end
+        end
+      }
+    end
+    klass
+  end
+end

data/plugins/core/lib/core/persistent_cache.rb

@@ -0,0 +1,57 @@
+
+module Redcar
+  class PersistentCache
+    class << self
+      attr_accessor :storage_dir
+    end
+    
+    def self.all
+      Dir[File.join(storage_dir, "*.cache")].map do |fn|
+        PersistentCache.new(File.basename(fn)[/^(.*)\.cache$/, 1])
+      end
+    end
+    
+    attr_reader :name
+    
+    def initialize(name)
+      @name = name
+    end
+    
+    def cache
+      if result = read_cache_file
+        result
+      else
+        result = yield
+        write_cache_file(Marshal.dump(result))
+        result
+      end
+    end
+    
+    def clear
+      FileUtils.rm_f(cache_file_name)
+    end
+    
+    def cache_file_name
+      File.expand_path(File.join(PersistentCache.storage_dir, name)) + ".cache"
+    end
+    
+    private
+  
+    def write_cache_file(contents)
+      FileUtils.mkdir_p(PersistentCache.storage_dir)
+      File.open(cache_file_name, "w") {|f| f.puts contents }
+    end
+    
+    def read_cache_file
+      if File.exist?(cache_file_name)
+        begin
+          Marshal.load(File.read(cache_file_name))
+        rescue => e
+          puts "WARNING: couldn't load #{cache_file_name}, despite it existing."
+          puts e.class.name + " " + e.message
+          puts e.backtrace
+        end
+      end
+    end
+  end
+end