ironnails 0.0.1

data/lib/ironnails/logging/buffered_logger.rb

@@ -0,0 +1,137 @@
+# Inspired by the Buffered Logger from Ezra (Merb)
+# Taken from active_support
+module IronNails
+
+  module Logging
+
+
+    class BufferedLogger
+      module Severity
+        DEBUG   = 0
+        INFO    = 1
+        WARN    = 2
+        ERROR   = 3
+        FATAL   = 4
+        UNKNOWN = 5
+      end
+      include Severity
+
+      MAX_BUFFER_SIZE = 1000
+
+      # Set to false to disable the silencer
+      cattr_accessor :silencer
+      self.silencer = true
+
+      # Silences the logger for the duration of the block.
+      def silence(temporary_level = ERROR)
+        if silencer
+          begin
+            old_logger_level, self.level = level, temporary_level
+            yield self
+          ensure
+            self.level = old_logger_level
+          end
+        else
+          yield self
+        end
+      end
+
+      attr_accessor :level
+      attr_reader :auto_flushing
+      attr_reader :buffer
+
+      def initialize(log, level = DEBUG)
+        @level         = level
+        @buffer        = []
+        @auto_flushing = 1
+        @no_block = false
+
+        if log.respond_to?(:write)
+          @log = log
+        elsif File.exist?(log)
+          @log = File.open(log, (File::WRONLY | File::APPEND))
+          @log.sync = true
+        else
+          FileUtils.mkdir_p(File.dirname(log))
+          @log = File.open(log, (File::WRONLY | File::APPEND | File::CREAT))
+          @log.sync = true
+          @log.write("# Logfile created on %s" % [Time.now.to_s])
+        end
+      end
+
+      def set_non_blocking_io
+        if !RUBY_PLATFORM.match(/java|mswin/) && !(@log == STDOUT) && @log.respond_to?(:write_nonblock)
+          @no_block = true
+        end
+      end
+
+      def add(severity, message = nil, progname = nil, &block)
+        from_framework = progname == IRONNAILS_FRAMEWORKNAME
+        fw_logging = defined?(IronNails::Logging::FRAMEWORK_LOGGING) && IronNails::Logging::FRAMEWORK_LOGGING
+        return if @level > severity || (from_framework && !fw_logging )
+        message = (message || (block && block.call) || progname).to_s
+        puts message if defined?(IronNails::Logging::CONSOLE_LOGGING) && IronNails::Logging::CONSOLE_LOGGING
+        # If a newline is necessary then create a new message ending with a newline.
+        # Ensures that the original message is not mutated.
+        message = "IRONNAILS: #{Severity.constants[severity]}: #{message}" if from_framework
+        message = "[#{Time.now.strftime("%d/%m/%Y %H:%M:%S.#{Time.now.usec}")}] #{message}\n" unless message[-1] == ?\n
+        buffer << message
+        auto_flush
+        message
+      end
+
+      for severity in Severity.constants
+        class_eval <<-EOT, __FILE__, __LINE__
+        def #{severity.downcase}(message = nil, progname = nil, &block)
+          add(#{severity}, message, progname, &block)
+        end
+
+        def #{severity.downcase}?
+          #{severity} >= @level
+        end
+        EOT
+      end
+
+      # Set the auto-flush period. Set to true to flush after every log message,
+      # to an integer to flush every N messages, or to false, nil, or zero to
+      # never auto-flush. If you turn auto-flushing off, be sure to regularly
+      # flush the log yourself -- it will eat up memory until you do.
+      def auto_flushing=(period)
+        @auto_flushing =
+                case period
+                  when true;
+                    1
+                  when false, nil, 0;
+                    MAX_BUFFER_SIZE
+                  when Integer;
+                    period
+                  else
+                    raise ArgumentError, "Unrecognized auto_flushing period: #{period.inspect}"
+                end
+      end
+
+      def flush
+        unless buffer.empty?
+          if @no_block
+            @log.write_nonblock(buffer.slice!(0..-1).join)
+          else
+            @log.write(buffer.slice!(0..-1).join)
+          end
+        end
+      end
+
+      def close
+        flush
+        @log.close if @log.respond_to?(:close)
+        @log = nil
+      end
+
+      protected
+      def auto_flush
+        flush if buffer.size >= @auto_flushing
+      end
+    end
+
+  end
+
+end

data/lib/ironnails/logging/class_logger.rb

@@ -0,0 +1,29 @@
+module IronNails
+
+  module Logging
+
+    module ClassLogger
+
+      # provides access for the logger we are using
+      # you can override this logger as long as it responds to
+      # the methods: debug, info, warn, error, fatal
+      def logger
+        IRONNAILS_DEFAULT_LOGGER
+      end
+
+      # Ensures that a message is logged when the execution of 
+      # the specified block throws an error. It will then re-raise the error.
+      def log_on_error
+        begin
+          yield if block_given?
+        rescue Exception => e
+          logger.error "IronNails Error: #{e}"
+          raise e
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ironnails/models/base.rb

@@ -0,0 +1,16 @@
+module IronNails
+
+  module Models
+
+
+
+
+    class Base
+
+      include IronNails::Models::ModelMixin
+
+    end
+
+  end
+
+end

data/lib/ironnails/models/bindable_collection.rb

@@ -0,0 +1,15 @@
+module IronNails
+
+  module Models
+
+    class BindableCollection < System::Collections::ObjectModel::ObservableCollection.of(System::Object)
+
+      def initialize(*list)
+        list.map { |item| self.add item }
+      end
+
+    end
+
+  end
+
+end

data/lib/ironnails/models/model_mixin.rb

@@ -0,0 +1,69 @@
+module IronNails
+
+  module Models
+
+    module ModelMixin
+
+      include IronNails::Logging::ClassLogger
+
+    end
+
+    module Databinding
+
+      module ClassMethods
+
+        # defines a write-only attribute on an object
+        # this would map to a property setter in different languages
+        def attr_writer(*names)
+          names.each do |nm|
+            mn = nm
+            self.send :define_method, "#{nm}=".to_sym do |arg|
+              __vr__ =  instance_variable_get :"@#{mn}"
+              return __vr__ if __vr__ == arg
+              instance_variable_set :"@#{mn}", arg
+              raise_property_changed mn
+            end
+          end
+        end
+
+        # defines a read/write attribute on an object.
+        # this would map to a property with a getter and a setter in different langauages
+        def attr_accessor(*names)
+          attr_reader *names
+          attr_writer *names
+        end
+
+
+      end
+
+      # extend the class with the class methods defined in this module
+      def self.included(base)
+        base.send :include, System::ComponentModel::INotifyPropertyChanged unless base.ancestors.include? System::ComponentModel::INotifyPropertyChanged
+        base.extend ClassMethods
+      end
+
+      def add_PropertyChanged(handler=nil)
+        @__handlers__ ||= []
+        @__handlers__ << handler
+      end
+
+      def remove_PropertyChanged(handler=nil)
+        @__handlers__ ||= []
+        @__handlers__.delete handler
+      end
+
+      private
+      def raise_property_changed(name)
+        return unless @__handlers__
+        @__handlers__.each do |ev|
+          ev.invoke self, System::ComponentModel::PropertyChangedEventArgs.new(name) if ev.respond_to? :invoke
+          ev.call self, System::ComponentModel::PropertyChangedEventArgs.new(name) if ev.respond_to? :call
+        end
+      end
+
+    end
+
+
+  end
+
+end

data/lib/ironnails/models.rb

@@ -0,0 +1,3 @@
+require File.dirname(__FILE__) + '/models/model_mixin'
+require File.dirname(__FILE__) + '/models/bindable_collection'
+require File.dirname(__FILE__) + '/models/base' 

data/lib/ironnails/nails_engine.rb

@@ -0,0 +1,398 @@
+require File.dirname(__FILE__) + "/view/collections"
+require File.dirname(__FILE__) + "/view/view_model"
+require File.dirname(__FILE__) + "/view/xaml_proxy"
+require File.dirname(__FILE__) + "/observable"
+
+module IronNails
+
+  module Core
+
+    module ViewOperations
+
+      def init_view_operations
+      end
+
+      def build_view(options)
+        logger.debug "View to load: #{options[:name]}", IRONNAILS_FRAMEWORKNAME
+        vw = IronNails::View::View.new(options)
+        #vw.add_observer(:loaded) { |sender| set_data_context_for(sender) }
+        vw
+      end
+
+      def register_child_view(options)
+        vw = registry.view_for options[:controller]
+        vw.add_child(options)
+      end
+
+      def register_view_for(controller)
+        vw = build_view(:name => controller.view_name.to_sym, :controller => controller.controller_name)
+        vw.add_observer(:configuring) { |sender| configure_view(sender) }
+        registry.register_view_for controller, vw
+      end
+
+      def on_view(controller, name = nil, &b)
+        find_view(controller, name).on_proxy(&b) #unless vw.nil?
+      end
+
+      def from_view(controller, name, target, method)
+        find_view(controller, name).get_property(target, method)
+      end
+
+      def to_update_ui_after(controller, options, &b)
+#        if options.is_a? Hash
+#          klass = options[:class]||BindableCollection
+#          request = options[:request]
+#        else
+#          klass = BindableCollection
+#          request = options
+#        end
+#        cb = System::Threading::WaitCallback.new do
+#          begin
+#            registry.view_for(controller).dispatcher.begin_invoke(DispatcherPriority.normal, Action.of(klass).new(&b), request.call)
+#          rescue WebException => e
+#            MessageBox.Show("There was a problem logging in to Twitter. #{e.message}");
+#          rescue RequestLimitException => e
+#            MessageBox.Show(e.message)
+#          rescue SecurityException => e
+#            MessageBox.Show("Incorrect username or password. Please try again");
+#          end
+#        end
+#        System::Threading::ThreadPool.queue_user_work_item cb  
+        cb = nil
+        cb = options[:callback] unless options[:callback].nil?
+        options[:callback] = lambda do |vw|
+          b.call
+          refresh_view(vw)
+        end
+        find_view(controller, name).to_update_ui_after(options, &b)
+      end
+
+      def on_ui_thread(controller, options=nil, &b)
+        if options.is_a? Hash
+          data = options[:data]
+          klass = options[:class] || data.class
+        else
+          unless options.nil?
+            klass = options.class
+            data = options
+          end
+        end
+        b.call
+        #registry.view_for(controller).dispatcher.begin_invoke(DispatcherPriority.normal, options.nil? ? Action.new(&b) : Action.of(klass).new(&b), data)
+      end
+
+      alias_method :on_ui_thread_with, :on_ui_thread
+
+      def play_storyboard(controller, name, storyboard)
+        logger.debug "finding controller #{controller.controller_name} and view #{name} to play #{storyboard}"
+        vw = find_view(controller, name)
+        find_view(controller, name).play_storyboard(storyboard)
+      end
+
+      def stop_storyboard(controller, view_name, storyboard)
+        find_view(controller, name).stop_storyboard(storyboard)
+      end
+
+      def find_view(controller, name)
+        registry.view_for(controller).find(name)
+      end
+    end
+
+    module ViewModelObjectOperations
+
+      # gets or sets the models that wil be used in the view to bind to
+      attr_accessor :model_queue
+
+      def init_object_operations
+        @model_queue = ModelCollection.new
+      end
+
+      # flags the view model as in need of wiring up and 
+      # sets the model collection
+      def model_queue=(value)
+        unless model_queue == value
+          @configured = false
+          @model_queue = value
+        end
+      end
+
+      # adds a new model to the queue for synchronisation to the view
+      def add_model_to_queue_on(model)
+        if model.respond_to?(:has_model?)
+          model.each do |m|
+            enqueue_model(m)
+          end
+        elsif model.is_a?(Hash)
+          enqueue_model(model)
+        end
+      end
+
+      alias_method :add_models_to_queue_on, :add_model_to_queue_on
+
+      private
+
+      def enqueue_model(model)
+        key = model.keys[0]
+        unless model_queue.has_model?(model) && model_queue[key] == model[key]
+          model_queue.add_model model
+          @configured = false
+        end
+      end
+
+    end
+
+    module ViewModelCommandOperations
+
+      # gets or sets the command_queue to respond to user actions in the view.
+      attr_accessor :command_queue
+
+      def init_command_operations
+        @command_queue = CommandCollection.new
+      end
+
+      # flags the view model as in need of wiring up and 
+      # sets the command collection
+      def command_queue=(value)
+        unless command_queue == value
+          @configured = false
+          @command_queue = value
+        end
+      end
+
+      # adds a command or a command collection to the queue
+      def add_command_to_queue(cmd)
+
+        if cmd.respond_to?(:has_command?)
+          cmd.each do |c|
+            enqueue_command(c)
+          end
+        elsif cmd.respond_to?(:execute) && cmd.respond_to?(:refresh_view) # define some sort of contract
+          enqueue_command(cmd)
+        end
+      end
+
+      alias_method :add_commands_to_queue, :add_command_to_queue
+
+      private
+
+      def enqueue_command(cmd)
+        if !command_queue.has_command?(cmd) || cmd.changed?
+          cmd.add_observer(:refreshing_view) do |sender|
+            refresh_view(registry.view_for(sender.controller))
+          end
+          command_queue << cmd
+          @configured = false
+        end
+      end
+
+    end
+
+    module ViewModelOperations
+
+      # gets the view model instance to manipulate with this builder
+      attr_accessor :view_models
+
+      include ViewModelObjectOperations
+      include ViewModelCommandOperations
+
+      def init_viewmodel_operations
+        init_object_operations
+        init_command_operations
+        @view_models = {}
+      end
+
+      def register_viewmodel_for(controller)
+        vm_class_name = controller.view_model_name.camelize
+        Object.const_set vm_class_name, Class.new unless Object.const_defined? vm_class_name
+
+        # TODO: There is an issue with namespacing and CLR classes, they aren't registered as constants with
+        #       IronRuby. This makes it hard to namespace viewmodels. If the namespace is included everything 
+        #       should work as normally. Will revisit this later to properly fix it.        
+        vm_name = controller.view_model_name
+        klass = Object.const_get vm_class_name
+        klass.send :include, IronNails::Models::Databinding
+        klass.send :include, IronNails::View::ViewModelMixin
+        key = vm_name.to_sym
+        view_models[key] = klass.new if view_models[key].nil?
+        registry.register_viewmodel_for controller, view_models[key]
+        view_models[key]
+      end
+
+    end
+
+    class ComponentRegistryItem
+
+      attr_accessor :viewmodel
+
+      attr_accessor :view
+
+      def initialize(options={})
+        @view = options[:view]
+        @viewmodel = options[:viewmodel]
+      end
+
+    end
+
+    class ComponentRegistry
+
+      attr_accessor :components
+
+      def initialize
+        @components = {}
+      end
+
+      def register(controller)
+        components[controller.controller_name] = ComponentRegistryItem.new
+      end
+
+      def register_view_for(controller, view)
+        find_controller(controller).view = view
+      end
+
+      def register_viewmodel_for(controller, model)
+        find_controller(controller).viewmodel = model
+      end
+
+      def find_controller(controller)
+        con_name = controller.respond_to?(:controller_name) ? controller.controller_name : controller.to_sym
+        components[con_name]
+      end
+
+      def viewmodel_for(controller)
+        find_controller(controller).viewmodel
+      end
+
+      def view_for(controller)
+        find_controller(controller).view
+      end
+    end
+
+    # This could be viewed as the life support for the Nails framework
+    # It serves as the glue between the different components.
+    # One of its main functions is to manage communication between the controller,
+    # view model and view.
+    class NailsEngine
+
+      include IronNails::Logging::ClassLogger
+      include ControllerObservable
+      include ViewOperations
+      include ViewModelOperations
+
+      # Stores the registered components and does lookup on them
+      attr_accessor :registry
+
+      def set_viewmodel_for(controller, key, value)
+        model = registry.viewmodel_for controller
+        model.set_model key, value
+      end
+
+      # configures the properties for the view model
+      def configure_models(model)
+        model_queue.each do |o|
+          o.each do |k, v|
+            model.add_model k, v
+          end unless o.nil?
+        end
+      end
+
+      # processes the command queue.
+      def configure_events(model, view)
+        command_queue.each do |cmd|
+          case
+            when cmd.is_a?(EventCommand)
+              view.add_command(cmd)
+            when cmd.is_a?(TimedCommand)
+              view.add_timer(cmd)
+              view.proxy.start_timer(cmd)
+            when cmd.is_a?(BehaviorCommand)
+              model.add_command cmd
+          end unless cmd.attached?
+        end
+      end
+
+      # configures the view
+      def configure_view(view)
+        model = registry.viewmodel_for view.controller
+        configure_models(model)
+        configure_events(model, view)
+        view.data_context = model unless view.has_datacontext? && !view.sets_datacontext?
+        @configured = true
+      end
+
+      # refreshes the data for the view.
+      def refresh_view(view)
+        notify_observers :refreshing_view, view.controller, self, view
+        view.configure
+        view.proxy.refresh
+        @configured = true
+      end
+
+      # synchronises the data in the viewmodel with the controller
+      def synchronise_with_controller
+        notify_observers :reading_input, self, view
+      end
+
+      def add_command_to_view(commands)
+        add_commands_to_queue commands
+      end
+
+      def synchronise_to_controller(controller)
+        objects = controller.instance_variable_get "@objects"
+        #model = registry.viewmodel_for controller #.objects.collect { |kvp| kvp.key.to_s.underscore.to_sym }
+        vw = registry.view_for controller
+        model = vw.proxy.data_context
+        objects.each do |k, v|
+          if model.respond_to?(k.to_sym)
+            val = model.send k.to_sym
+            objects[k] = val
+            controller.instance_variable_set "@#{k}", val
+          end
+        end
+        view_properties = controller.instance_variable_get "@view_properties"
+        view_properties.each do |k, v|
+          val = from_view controller, (v[:view]||controller.view_name), v[:element], v[:property]
+          instance_variable_set "@#{k}", val
+        end
+      end
+
+      # returns whether this view needs configuration or not
+      def configured?
+        !!@configured
+      end
+
+      def initialize
+        @configured, @registry = false, ComponentRegistry.new
+        init_viewmodel_operations
+        init_view_operations
+      end
+
+      def register_controller(controller)
+        logger.debug "registering controller #{controller.controller_name}", IRONNAILS_FRAMEWORKNAME
+        registry.register(controller)
+        register_viewmodel_for controller
+        register_view_for controller
+        controller.nails_engine = self
+        logger.debug "controller #{controller.controller_name} registered", IRONNAILS_FRAMEWORKNAME
+      end
+
+      def show_initial_window(controller)
+        logger.debug "setting up controller", IRONNAILS_FRAMEWORKNAME
+        #controller.setup_for_showing_view      
+        registry.view_for(controller).load
+        controller.default_action if controller.respond_to? :default_action
+        controller.setup_for_showing_view
+        yield registry.view_for(controller).instance if block_given?
+      end
+
+      def initialize_with(command_definitions, models)
+        add_commands_to_queue command_definitions
+        add_models_to_queue_on models
+        logger.debug "Added commands to queue on view manager.", IRONNAILS_FRAMEWORKNAME
+        logger.debug "Added models to queue on view manager.", IRONNAILS_FRAMEWORKNAME
+      end
+
+    end
+
+  end
+
+end