ironnails 0.0.1

data/lib/ironnails/observable.rb

@@ -0,0 +1,117 @@
+# This is an implementation of the observer pattern
+# It serves to mimic the event system that is known 
+# in the CLR world.
+# while ruby has a standard observable module that 
+# one doesn't allow us to listen for specific events
+module IronNails::Core
+
+  module Observable
+
+    #
+    # Add +observer+ as an observer on this object. +observer+ will now receive
+    # notifications. +observer+ is interest in the specified +event+
+    #
+    def add_observer(event, &observer)
+      @observers = [] unless defined? @observers
+      unless observer.respond_to? :call
+        raise NoMethodError, "observer needs to respond to 'update'"
+      end
+      @observers << { :event => event, :observer => observer }
+    end
+
+    #
+    # Delete +observer+ as an observer on this object. It will no longer receive
+    # notifications of the specified +event+.
+    #
+    def delete_observer(event, &observer)
+      evt = { :event => event, :observer => observer }
+      @observers.delete evt if defined? @observers
+    end
+
+    #
+    # Delete all observers associated with this object.
+    #
+    def delete_observers
+      @observers.clear if defined? @observers
+    end
+
+    #
+    # Return the number of observers associated with this object.
+    #
+    def count_observers
+      if defined? @observers
+        @observers.size
+      else
+        0
+      end
+    end
+
+    #
+    # Notifies the registered observers that some interesting
+    # +event+ has occurred. It will notify the interested parties
+    # by calling the block and passing it some context
+    #
+    def notify_observers(event, sender, *args)
+      @observers.select {|evt| evt[:event] == event }.each {|evt| evt[:observer].call sender, *args } unless count_observers.zero?
+    end
+
+
+  end
+
+  module ControllerObservable
+
+    #
+    # Add +observer+ as an observer on this object. +observer+ will now receive
+    # notifications. +observer+ is interest in the specified +event+
+    # +controller+ is the name of the controller that listens for this event
+    #
+    def add_observer(event, controller, &observer)
+      @controller_observers = [] unless defined? @controller_observers
+      unless observer.respond_to? :call
+        raise NoMethodError, "observer needs to respond to 'update'"
+      end
+      @controller_observers << { :event => event.to_sym, :observer => observer, :controller => controller.to_sym }
+    end
+
+    #
+    # Delete +observer+ as an observer on this object. It will no longer receive
+    # notifications of the specified +event+.
+    #
+    def delete_observer(event, controller, &observer)
+      evt = { :event => event.to_sym, :observer => observer, :controller => controller.to_sym }
+      @controller_observers.delete evt if defined? @controller_observers
+    end
+
+    #
+    # Delete all observers associated with this object.
+    #
+    def delete_observers
+      @controller_observers.clear if defined? @controller_observers
+    end
+
+    #
+    # Return the number of observers associated with this object.
+    #
+    def count_observers
+      if defined? @controller_observers
+        @controller_observers.size
+      else
+        0
+      end
+    end
+
+    #
+    # Notifies the registered observers that some interesting
+    # +event+ has occurred. It will notify the interested parties
+    # by calling the block and passing it some context
+    #
+    def notify_observers(event, controller, sender, *args)
+      @controller_observers.
+              select {|evt| evt[:event] == event.to_sym && evt[:controller] == controller.to_sym  }.
+              each {|evt| evt[:observer].call sender, *args }
+    end
+
+
+  end
+
+end

data/lib/ironnails/security/secure_string.rb

@@ -0,0 +1,61 @@
+module IronNails
+
+  module Security
+
+    class SecureString
+
+      ENCRYPTION_SALT = "SailsPasswordSalt".freeze
+
+
+
+      @@entropy = System::Text::Encoding.unicode.get_bytes(ENCRYPTION_SALT)
+
+      class << self
+        include System::Security::Cryptography
+        include System::Runtime::InteropServices
+
+        def encrypt_string(input)
+          encrypted_data = ProtectedData.protect(
+                  System::Text::Encoding.unicode.get_bytes(unsecure_string(input)),
+                  @@entropy,
+                  DataProtectionScope.current_user)
+          System::Convert.to_base64_string(encrypted_data)
+        end
+
+        def secure_string(input)
+          secure = System::Security::SecureString.new
+          input.to_s.to_clr_string.to_char_array.each {|c| secure.append_char c }
+          secure.make_read_only
+          secure
+        end
+
+        def unsecure_string(input)
+          result = ""
+          ptr = System::Runtime::InteropServices::Marshal.SecureStringToBSTR(input);
+          begin
+            result = System::Runtime::InteropServices::Marshal.PtrToStringBSTR(ptr);
+          ensure
+            System::Runtime::InteropServices::Marshal.ZeroFreeBSTR(ptr);
+          end
+          result.to_s
+        end
+
+        def decrypt_string(encrypted_data)
+          begin
+            decrypted_data = ProtectedData.unprotect(
+                    Convert.from_base64_string(encrypted_data),
+                    @@entropy,
+                    DataProtectionScope.current_user);
+            secure_string(System::Text::Encoding.unicode.get_bytes(decrypted_data));
+          rescue
+            System::Security::SecureString.new
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/ironnails/version.rb

@@ -0,0 +1,11 @@
+module IronNails
+
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 2
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+
+end

data/lib/ironnails/view/collections.rb

@@ -0,0 +1,117 @@
+module IronNails
+
+  module Core
+
+    class Collection
+
+      include Enumerable
+
+      def initialize(*items)
+        @items = items || []
+      end
+
+      def each
+        @items.each do |item|
+          yield item
+        end
+      end
+
+      def <<(item)
+        @items << item
+      end
+
+      def [](value)
+        @items[value]
+      end
+
+      def to_a
+        @items
+      end
+
+
+    end
+
+  end
+
+  module View
+
+    class CommandCollection < Core::Collection
+
+      def has_command?(command)
+        !self.find do |cmd|
+          command == cmd
+        end.nil?
+      end
+
+    end
+
+    class ViewCollection < Core::Collection
+
+      def has_view?(view)
+        find_view(view[:name]).nil?
+      end
+
+      def find_view(name)
+        self.find { |vw| vw[:name] == name }
+      end
+
+    end
+
+    class ViewModelCollection < Core::Collection
+
+      def has_viewmodel?(view_model)
+        if view_model.is_a?(String)
+          find_viewmodel(view_model).nil?
+        else
+          find_viewmodel(view_model.__view_model_name_).nil?
+        end
+      end
+
+      def find_viewmodel(name)
+        self.find { |vm| vm.__view_model_name_ == name }
+      end
+
+      def <<(model)
+        @items << model unless has_viewmodel?(model)
+        find_viewmodel(model.__view_model_name_)
+      end
+
+    end
+
+    class ModelCollection < Core::Collection
+
+      def has_model?(model)
+        !get_model(model).nil?
+      end
+
+      def add_model(model)
+        key = model.keys[0]
+        has_model?(model) ? get_model(model)[key] = model[key] : @items << model
+      end
+
+      def get_model(model)
+        @items.find do |m|
+          model.keys[0] == m.keys[0]
+        end
+      end
+
+      class << self
+
+        # Given a set of +objects+ it will generate
+        # a collection of objects for the view model
+        def generate_for(objects)
+          models = new
+          objects.each do |k, v|
+            models << { k => v }
+          end
+          models
+        end
+
+      end
+
+    end
+
+
+  end
+
+end

data/lib/ironnails/view/commands/add_sub_view_command.rb

@@ -0,0 +1,33 @@
+module IronNails
+
+  module View
+
+    class AddSubViewCommand < Command
+
+      # the controller for the subview
+      attr_accessor :controller
+
+      # the target that will contain the view for this controller
+      attr_accessor :target
+
+      alias_method :nails_base_command_read_options, :read_options
+
+      def read_options(options)
+        nails_base_command_read_options options
+        raise ArgumentError.new("We need a target to be defined by the :to parameter") if options[:to].nil?
+        raise ArgumentError.new("We need a controller instance to be defined in the :controller parameter") if options[:controller].nil? || !options[:controller].respond_to?(:current_view)
+
+        @controller = options[:controller]
+        @target = options[:to]
+      end
+
+      # executes this command (it calls the action)
+      def execute
+        view.add_control target, controller.current_view.instance
+      end
+
+    end
+
+  end
+
+end

data/lib/ironnails/view/commands/behavior_command.rb

@@ -0,0 +1,29 @@
+module IronNails
+
+  module View
+
+    class BehaviorCommand < Command
+
+      def to_clr_command
+        # I have to wrap the method calls into blocks because .to_proc hasn't been implemented yet on method
+        # the Func's have to be wrapped in lambda's to preserve the return statement.
+        unless asynchronous?
+          delegate_command.new(Action.new { execute }, Func[System::Boolean].new(&lambda{ can_execute? } ))
+        else
+          async_delegate_command.new(Action.new { execute }, Action.new { refresh_view },
+                                     Func[System::Boolean].new(&lambda{ can_execute? }))
+        end
+      end
+
+      def delegate_command
+        IronNails::Library::DelegateCommand
+      end
+
+      def async_delegate_command
+        IronNails::Library::AsynchronousDelegateCommand
+      end
+    end
+
+  end
+
+end

data/lib/ironnails/view/commands/command.rb

@@ -0,0 +1,208 @@
+module IronNails
+
+  module View
+
+    # The base class for view commands in IronNails.
+    class Command
+
+      include IronNails::Logging::ClassLogger
+      include IronNails::Core::Observable
+
+      # the view this command is bound to
+      attr_accessor :view
+
+      # indicates whether to execute this command on the ui thread or on a different thread.
+      attr_accessor :mode
+
+      # the name of this command
+      attr_accessor :name
+
+      # the action that will be triggered 
+      attr_accessor :action
+
+      # the predicate that decides whether this command can execute or not
+      attr_accessor :condition
+
+      # the name of the controller that built this command
+      attr_accessor :controller
+
+      # for asynchronous actions this gets executed after the view has been refreshed as a new command
+      attr_accessor :callback
+
+      def initialize(options)
+        read_options options
+      end
+
+      def read_options(options)
+        raise ArgumentError.new("A name is necesary") if options[:name].nil?
+        raise ArgumentError.new("An action is necesary") if options[:action].nil?
+        options.each do |k, v|
+          instance_variable_set "@#{k}", v
+        end
+        @mode ||= :synchronous
+      end
+
+      # flag to indicate whether this command needs a refresh in the view model
+      def changed?
+        !!@changed
+      end
+
+      def can_execute?
+        !!(condition.nil?||condition.call)
+      end
+
+      def asynchronous?
+        mode == :asynchronous
+      end
+
+      def has_callback?
+        !callback.nil?
+      end
+
+      def refresh_view
+        callback.call if asynchronous? && has_callback?
+        notify_observers :refreshing_view, self
+      end
+
+      def synchronise_viewmodel_with_controller
+        notify_observers :reading_input, self
+      end
+
+      def attached?
+        !view.nil?
+      end
+
+      # executes this command (it calls the action)
+      def execute
+        #log_on_error do
+        puts "calling the action"
+        synchronise_viewmodel_with_controller
+        action.call
+        refresh_view unless asynchronous?
+        #end if can_execute?
+      end
+
+      def ==(command)
+        self.name == command.name
+      end
+
+      alias_method :===, :==
+      alias_method :equals, :==
+
+      def <=>(command)
+        self.name <=> command.name
+      end
+
+      alias_method :compare_to, :<=>
+
+    end
+
+    class CommandBuilder
+
+      attr_accessor :controller
+
+      attr_accessor :command_mapping
+
+
+      def initialize(controller)
+        @controller = controller
+        @command_mapping= {
+                :event => EventCommand,
+                :timed => TimedCommand,
+                :behavior => BehaviorCommand
+        }
+      end
+
+      # Given a set of +command_definitions+ it will generate
+      # a collection of Command objects for the view model
+      def generate_for(cmd_def)
+        norm = normalize_command_definitions(cmd_def)
+        cmds = generate_command_collection_from_normalized_definitions norm
+        cmds
+      end
+
+      def view_model
+        WpfApplication.current.nails_engine
+      end
+
+      # Generates the command definitions for our view model.
+      def normalize_command_definitions(definitions)
+        command_definitions = {}
+
+        definitions.each do |k, v|
+          command_definitions[k] = normalize_command_definition(k, v)
+        end unless definitions.nil?
+
+        command_definitions
+      end
+
+      # Generates a command definition for our view model.
+      # When it can't find a key :action in the options hash for the view_action
+      # it will default to using the name as the command as the connected option.
+      # It will generate a series of commands for items that have more than one trigger      
+      def normalize_command_definition(name, options)
+        mode = options[:mode]
+        act = options[:action]||name
+        action = act
+        action = controller.method(act) if act.is_a?(Symbol) || act.is_a?(String)
+        if options.has_key?(:triggers) && !options[:triggers].nil?
+          triggers = options[:triggers]
+
+          cmd_def =
+                  if  triggers.is_a?(String) || triggers.is_a?(Symbol)
+                    {
+                            :element => triggers,
+                            :event   => :click,
+                            :action  => action,
+                            :mode    => mode,
+                            :type    => :event
+                    }
+                  elsif triggers.is_a?(Hash)
+                    {:action => action, :mode => mode, :type => :event }.merge triggers
+                  elsif triggers.is_a?(Array)
+                    defs = []
+                    triggers.each do |trig|
+                      trig = { :element => trig, :event => :click } unless trig.is_a? Hash
+                      trig[:event] = :click unless trig.has_key? :event
+                      defs << { :action => action, :mode => mode, :type => :event }.merge(trig)
+                    end
+                    defs
+                  end
+          cmd_def
+        else
+          exec = options[:execute]
+          execute = exec
+          execute = controller.method(exec) if exec.is_a?(Symbol) || exec.is_a?(String)
+          callback = options[:callback]
+          callback = controller.method(callback) if callback.is_a?(Symbol) || callback.is_a?(String)
+          controller_action, controller_condition = execute || action, options[:condition]
+          res = {
+                  :action => controller_action,
+                  :condition => controller_condition,
+                  :mode => mode,
+                  :callback => callback,
+                  :type => options[:type] || :behavior
+          }
+          res[:interval] = options[:interval] if options.key? :interval
+          res
+        end
+      end
+
+      def generate_command_collection_from_normalized_definitions(definitions)
+        commands = CommandCollection.new
+        definitions.each do |name, cmd_def|
+          cmd = create_command_from(cmd_def.merge({ :view_model => view_model, :name => name, :controller => controller.controller_name }))
+          commands << cmd
+        end if definitions.is_a?(Hash)
+        commands
+      end
+
+      def create_command_from(definition)
+        command_mapping[definition[:type]||:behavior].new definition
+      end
+
+    end
+
+  end
+
+end

data/lib/ironnails/view/commands/event_command.rb

@@ -0,0 +1,32 @@
+module IronNails
+
+  module View
+
+    # Encapsulates commands that will be attached to elements in the views.
+    class EventCommand < Command
+
+      # the name of the event that will trigger the action
+      attr_accessor :trigger
+
+      # the name of the element that will trigger the action
+      attr_accessor :element
+
+      # the name of the on which this command needs to be invoked
+      attr_accessor :affinity
+
+      alias_method :nails_base_command_read_options, :read_options
+
+      def read_options(options)
+        nails_base_command_read_options options
+        raise ArgumentException.new("An element name is necesary") if options[:element].nil?
+
+        @trigger = options[:event]||:click
+        @element = options[:element]
+        @affinity = options[:affinity]
+      end
+
+    end
+
+  end
+
+end

data/lib/ironnails/view/commands/timed_command.rb

@@ -0,0 +1,40 @@
+module IronNails
+
+  module View
+
+    class TimedCommand < Command
+
+      # gets the name to use for the timer     
+      attr_reader :timer_name
+
+      attr_accessor :interval
+
+      alias_method :nails_base_command_read_options, :read_options
+
+      def read_options(options)
+        nails_base_command_read_options options
+
+        @timer_name = get_timer_name
+      end
+
+      # This stops the timer in the view proxy
+      def stop_timer
+        view.stop_timer self
+      end
+
+      # This starts the timer in the view proxy
+      def start_timer
+        view.start_timer self
+      end
+
+      private
+
+      def get_timer_name
+        "__#{name}_ironnails_view_timer"
+      end
+
+    end
+
+  end
+
+end

data/lib/ironnails/view/commands.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/commands/command'
+require File.dirname(__FILE__) + '/commands/event_command'
+require File.dirname(__FILE__) + '/commands/timed_command'
+require File.dirname(__FILE__) + '/commands/behavior_command'
+require File.dirname(__FILE__) + '/commands/add_sub_view_command'