ironnails 0.0.1

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ironnails"
+    gem.summary = %Q{IronNails brings rails like development to IronRuby and WPF}
+    gem.description = %Q{IronNails is a framework inspired by the Rails and rucola frameworks. It offers a rails-like way of developing
+applications with IronRuby and Windows Presentation Foundation (WPF).}
+    gem.email = "ivan@flanders.co.nz"
+    gem.homepage = "http://github.com/casualjim/ironnails"
+    gem.authors = ["Ivan Porto Carrero"]
+    gem.add_development_dependency "rspec", ">= 0"
+    gem.files = FileList["[A-Z]*", "{lib}/**/*"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/lib/ironnails"

data/ironnails.gemspec

@@ -0,0 +1,96 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ironnails}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ivan Porto Carrero"]
+  s.date = %q{2010-02-28}
+  s.description = %q{IronNails is a framework inspired by the Rails and rucola frameworks. It offers a rails-like way of developing
+applications with IronRuby and Windows Presentation Foundation (WPF).}
+  s.email = %q{ivan@flanders.co.nz}
+  s.files = [
+    "Rakefile",
+     "VERSION",
+     "init.rb",
+     "ironnails.gemspec",
+     "lib/iron_nails.rb",
+     "lib/ironnails.rb",
+     "lib/ironnails/bin/IronNails.Library.dll",
+     "lib/ironnails/bin/IronRuby.Libraries.Yaml.dll",
+     "lib/ironnails/bin/IronRuby.Libraries.dll",
+     "lib/ironnails/bin/IronRuby.dll",
+     "lib/ironnails/bin/Microsoft.Dynamic.dll",
+     "lib/ironnails/bin/Microsoft.Scripting.Core.dll",
+     "lib/ironnails/bin/Microsoft.Scripting.ExtensionAttribute.dll",
+     "lib/ironnails/bin/Microsoft.Scripting.dll",
+     "lib/ironnails/config/configuration.rb",
+     "lib/ironnails/config/initializer.rb",
+     "lib/ironnails/controller.rb",
+     "lib/ironnails/controller/base.rb",
+     "lib/ironnails/controller/view_operations.rb",
+     "lib/ironnails/core_ext.rb",
+     "lib/ironnails/core_ext/array.rb",
+     "lib/ironnails/core_ext/class.rb",
+     "lib/ironnails/core_ext/class/attribute_accessors.rb",
+     "lib/ironnails/core_ext/fixnum.rb",
+     "lib/ironnails/core_ext/hash.rb",
+     "lib/ironnails/core_ext/kernel.rb",
+     "lib/ironnails/core_ext/string.rb",
+     "lib/ironnails/core_ext/symbol.rb",
+     "lib/ironnails/core_ext/system/net/web_request.rb",
+     "lib/ironnails/core_ext/system/security/secure_string.rb",
+     "lib/ironnails/core_ext/system/windows/markup/xaml_reader.rb",
+     "lib/ironnails/core_ext/system/windows/ui_element.rb",
+     "lib/ironnails/core_ext/time.rb",
+     "lib/ironnails/errors.rb",
+     "lib/ironnails/iron_xml.rb",
+     "lib/ironnails/logger.rb",
+     "lib/ironnails/logging/buffered_logger.rb",
+     "lib/ironnails/logging/class_logger.rb",
+     "lib/ironnails/models.rb",
+     "lib/ironnails/models/base.rb",
+     "lib/ironnails/models/bindable_collection.rb",
+     "lib/ironnails/models/model_mixin.rb",
+     "lib/ironnails/nails_engine.rb",
+     "lib/ironnails/observable.rb",
+     "lib/ironnails/security/secure_string.rb",
+     "lib/ironnails/version.rb",
+     "lib/ironnails/view.rb",
+     "lib/ironnails/view/collections.rb",
+     "lib/ironnails/view/commands.rb",
+     "lib/ironnails/view/commands/add_sub_view_command.rb",
+     "lib/ironnails/view/commands/behavior_command.rb",
+     "lib/ironnails/view/commands/command.rb",
+     "lib/ironnails/view/commands/event_command.rb",
+     "lib/ironnails/view/commands/timed_command.rb",
+     "lib/ironnails/view/view.rb",
+     "lib/ironnails/view/view_model.rb",
+     "lib/ironnails/view/xaml_proxy.rb",
+     "lib/ironnails/wpf.rb",
+     "lib/ironnails/wpf_application.rb"
+  ]
+  s.homepage = %q{http://github.com/casualjim/ironnails}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{IronNails brings rails like development to IronRuby and WPF}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/lib/iron_nails.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/ironnails"

data/lib/ironnails/config/configuration.rb

@@ -0,0 +1,141 @@
+# A wrapper module that will contain all the relevant objects for our twitter application
+module IronNails
+
+  # This structure has been heavily inspired by the rails framework.
+  # The Configuration class holds all the parameters for the Initializer
+  # Usually, you'll create a Configuration file implicitly through the block
+  # running on the Initializer, but it's also possible to create 
+  # the Configuration instance in advance and pass it in
+  # like this:
+  #
+  #   config = IronNails::Configuration.new
+  #   IronNails::Initializer.run(config)
+  class Configuration
+
+    # the root path for our application
+    attr_reader :root_path
+
+    # the search paths for ruby source files
+    attr_reader :application_paths
+
+    # the search paths for .NET binaries
+    attr_reader :assembly_paths
+
+    # the namespaces that need to be included by default
+    attr_reader :namespaces
+
+    # the files that won't be initialized through this procedure
+    attr_reader :excluded_files
+
+    # The log level to use for the default Rails logger. In production mode,
+    # this defaults to <tt>:info</tt>. In development mode, it defaults to
+    # <tt>:debug</tt>.
+    attr_accessor :log_level
+
+    # The path to the log file to use. Defaults to log/#{environment}.log
+    # (e.g. log/development.log or log/production.log).
+    attr_accessor :log_path
+
+    # The specific logger to use. By default, a logger will be created and
+    # initialized using #log_path and #log_level, but a programmer may
+    # specifically set the logger to use via this accessor and it will be
+    # used directly.
+    attr_accessor :logger
+
+    def initialize(rpath = (File.dirname(__FILE__) + '/../../..'))
+      @root_path = rpath
+      initialize_with_defaults
+    end
+
+    def environment
+      ::IRONNAILS_ENV
+    end
+
+    # The paths that contain sources for our application.
+    # We will require these at a later stage
+    def default_application_paths
+      paths = []
+
+      # Followed by the standard includes.
+      paths.concat %w(
+          config
+          lib
+          lib/core_ext
+          app
+          app/models
+          app/controllers
+          app/converters
+          app/helpers
+      ).map { |dir| "#{root_path}/#{dir}" }.select { |dir| File.directory?(dir) }
+    end
+
+    #files to exclude from requiring in our app
+    def default_excluded_files
+      ['config/environment.rb', 'lib/main.rb', 'config/boot.rb', 'bin/IronNails.Library.dll' ].collect{ |dir| "#{root_path}/#{dir}" }
+    end
+
+    def default_log_level
+      (IRONNAILS_ENV == 'development' || IRONNAILS_ENV.nil?) ? :debug : :info
+    end
+
+    def default_log_path
+      File.join(root_path, 'log', "#{environment}.log")
+    end
+
+    # returns wheter or not the specified path is an excluded file
+    def excluded_file?(file_path)
+      excluded_files.include? file_path
+    end
+
+    # The paths that contain .NET binaries
+    def default_assembly_paths
+      paths = []
+      paths.concat %w( bin ).map{ |dir| "#{root_path}/#{dir}"}.select{ |dir| File.directory?(dir) }
+    end
+
+    def default_namespaces
+      %w(
+        System
+        System::Net
+        System::Xml
+        System::IO
+        System::Web
+        System::Text
+        System::Threading
+        System::Windows
+        System::Collections::ObjectModel
+        IronNails::Controller
+        IronNails::View
+      )
+    end
+
+    def initialize_with_defaults
+      set_root_path!
+      @application_paths, @assembly_paths, @namespaces, @excluded_files = default_application_paths, default_assembly_paths, default_namespaces, default_excluded_files
+      @log_level, @log_path = default_log_level, default_log_path
+    end
+
+    # Set the root_path to IRONNAILS_ROOT and canonicalize it.
+    def set_root_path!
+      raise 'IRONNAILS_ROOT is not set' unless defined?(::IRONNAILS_ROOT)
+      raise 'IRONNAILS_ROOT is not a directory' unless File.directory?(::IRONNAILS_ROOT)
+
+      @root_path =
+              # Pathname is incompatible with Windows, but Windows doesn't have
+              # real symlinks so File.expand_path is safe.
+              if ENV['OS'] == 'Windows_NT'.freeze
+                File.expand_path(::IRONNAILS_ROOT)
+
+                # Otherwise use Pathname#realpath which respects symlinks.
+              else
+                Pathname.new(::IRONNAILS_ROOT).realpath.to_s
+              end
+
+      Object.const_set(:RELATIVE_SAILS_ROOT, ::IRONNAILS_ROOT.dup) unless defined?(::RELATIVE_SYLVESTER_ROOT)
+
+      ::IRONNAILS_ROOT.replace @root_path
+    end
+
+  end
+
+end

data/lib/ironnails/config/initializer.rb

@@ -0,0 +1,144 @@
+def include_global_namespaces(namespaces)
+  namespaces.each { |namespace| include(eval(namespace)) }
+end
+
+module IronNails
+
+  class << self
+    # The Configuration instance used to configure the Rails environment
+    def configuration
+      @@configuration
+    end
+
+    def configuration=(configuration)
+      @@configuration = configuration
+    end
+
+    def logger
+      IRONNAILS_DEFAULT_LOGGER
+    end
+
+    def root
+      if defined?(IRONNAILS_ROOT)
+        IRONNAILS_ROOT
+      else
+        nil
+      end
+    end
+
+    def env
+      IRONNAILS_ENV
+    end
+
+    def version
+      IronNails::VERSION::STRING
+    end
+
+  end
+
+  # This structure has been heavily inspired by the rails framework.
+  # The Configuration class holds all the parameters for the Initializer
+  # Usually, you'll create a Configuration file implicitly through the block
+  # running on the Initializer, but it's also possible to create 
+  # the Configuration instance in advance and pass it in
+  # like this:
+  #
+  #   config = IronNails::Configuration.new
+  #   IronNails::Initializer.run(config)
+  class Initializer
+
+    def initialize(configuration)
+      IronNails.configuration = configuration
+
+      initialize_logger
+
+      set_constants
+      require_binaries
+      include_namespaces
+      require_application_files
+    end
+
+    def self.run(configuration = Configuration.new)
+      yield configuration if block_given?
+      initializer = new configuration
+      initializer
+    end
+
+    def configuration
+      IronNails.configuration
+    end
+
+    def set_constants
+      logger.debug "setting application constants", IRONNAILS_FRAMEWORKNAME
+    end
+
+    # If the IRONNAILS_DEFAULT_LOGGER constant is already set, this initialization
+    # routine does nothing. If the constant is not set, and Configuration#logger
+    # is not +nil+, this also does nothing. Otherwise, a new logger instance
+    # is created at Configuration#log_path, with a default log level of
+    # Configuration#log_level.
+    #
+    # If the log could not be created, the log will be set to output to
+    # +STDERR+, with a log level of +WARN+.
+    def initialize_logger
+      # if the environment has explicitly defined a logger, use it
+      return if defined?(IRONNAILS_DEFAULT_LOGGER)
+
+      unless logr = configuration.logger
+        begin
+          logr = IronNails::Logging::BufferedLogger.new(configuration.log_path)
+          logr.level = IronNails::Logging::BufferedLogger.const_get(configuration.log_level.to_s.upcase)
+          if configuration.environment == "production"
+            logr.auto_flushing = false
+            logr.set_non_blocking_io
+          end
+        rescue StandardError => e
+          logr = IronNails::Logging::BufferedLogger.new(STDERR)
+          logr.level = IronNails::Logging::BufferedLogger::WARN
+          logr.warn(
+                  "IronNails Error: Unable to access log file. Please ensure that #{configuration.log_path} exists and is chmod 0666. " +
+                          "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed. #{e}"
+          )
+        end
+        logr.debug "initializing logger", IRONNAILS_FRAMEWORKNAME
+      end
+
+      silence_warnings { Object.const_set "IRONNAILS_DEFAULT_LOGGER", logr }
+    end
+
+    def logger
+      IRONNAILS_DEFAULT_LOGGER
+    end
+
+
+    def require_binaries
+      logger.debug "requiring binaries from bin", IRONNAILS_FRAMEWORKNAME
+      configuration.assembly_paths.each do |path|
+        require_files path, :dll
+      end
+    end
+
+
+    def include_namespaces
+      logger.debug "Including namespaces", IRONNAILS_FRAMEWORKNAME
+      #include_global_namespaces configuration.namespaces
+      configuration.namespaces.each { |namespace| Object.send :include, eval(namespace) }
+    end
+
+    def require_application_files
+      logger.debug "requiring application files", IRONNAILS_FRAMEWORKNAME
+      configuration.application_paths.each do |path|
+        require_files path, :rb
+      end
+    end
+
+    def require_files(path, extension)
+      Dir.glob("#{File.expand_path(path)}/*.#{extension}").each do |file|
+        # puts "#{file}"
+        require "#{file}" unless configuration.excluded_file? file
+      end
+    end
+
+  end
+
+end

data/lib/ironnails/controller/base.rb

@@ -0,0 +1,135 @@
+require File.dirname(__FILE__) + '/view_operations'
+module IronNails
+
+  module Controller
+
+    class Base
+
+      include IronNails::Controller::ViewOperations
+      include IronNails::Logging::ClassLogger
+      include IronNails::Core::Observable
+
+
+      # Gets or sets the objects for the presenter
+      attr_accessor :objects
+
+      # Gets or sets the meta data for binding ui stuff we can't with Xaml (like Password on the PasswordBox)
+      attr_accessor :view_properties
+
+      # Gets or sets the commands for the presenter
+      attr_accessor :commands
+
+      # Gets or sets the presenters collection for this controller
+      attr_accessor :presenters
+
+      def controller_name
+        self.class.to_s.underscore.to_sym
+      end
+
+      def show_view
+        #log_on_error do
+        setup_for_showing_view
+        main_presenter.show_view
+        #end
+      end
+
+      def refresh_view(name=nil)
+        name ||= view_name.to_sym
+        setup_for_showing_view
+        nails_engine.refresh_view(nails_engine.find_view(controller_name, name))
+        on_view(name) do |proxy|
+          proxy.refresh
+        end
+      end
+
+      def on_view(name=nil, options={}, &b)
+        name ||= view_name.to_sym
+        if block_given?
+          setup_for_showing_view
+          nails_engine.on_view(controller_name, name, &b)
+        else
+          if options[:set].nil?
+            nails_engine.from_view(controller_name, name, options[:from], options[:get])
+          else
+            nails_engine.set_on_view(controller_name, name, options[:from], options[:set], options[:value])
+          end
+        end
+      end
+
+#      def from_view(name, options)
+#        name ||= view_name.to_sym
+#        nails_engine.from_view(controller_name, name, options[:from], options[:get])
+#      end
+
+      def child_view(view_name, options)
+        nails_engine.register_child_view :controller => controller_name, :container => options[:in], :name => view_name
+      end
+
+      def view_model(model_name, value)
+        instance_variable_set "@#{model_name}", value
+        refresh_objects
+        nails_engine.set_viewmodel_for self, model_name, value
+      end
+
+      def configure_viewmodel_for_showing
+        nails_engine.configure_view_for_showing
+      end
+
+      def to_update_ui_after(options, &b)
+        nails_engine.to_update_ui_after self, options, &b
+      end
+
+      def on_ui_thread(options=nil, &b)
+        nails_engine.on_ui_thread self, options, &b
+      end
+
+      def play_storyboard(name=nil, storyboard=nil)
+        nails_engine.play_storyboard self, (storyboard.nil? ? view_name : name), (storyboard.nil? ? name : storyboard)
+      end
+
+      def stop_storyboard(name=nil, storyboard=nil)
+        nails_engine.stop_storyboard self, (storyboard.nil? ? view_name : name), (storyboard.nil? ? name : storyboard)
+      end
+
+      def init_controller
+      end
+
+      def __init_controller__
+        @command_builder = CommandBuilder.new self
+        init_controller
+      end
+
+
+      class << self
+
+        alias_method :old_nails_controller_new, :new
+
+        def new
+          ctrlr = old_nails_controller_new
+          ctrlr.__init_controller__
+          ctrlr
+        end
+
+        def view_action(name, options={}, &b)
+          @commands ||= {}
+          options[:action] = b if block_given?
+          @commands[name] = options
+        end
+
+        def view_object(name, options = nil)
+          @objects ||= {}
+          @view_properties ||={}
+          unless options.is_a?(Hash) && !options[:element].nil?
+            @objects[name] = options.is_a?(Hash) ? options[:value] : options
+          else
+            @view_properties[name] = options
+          end
+
+        end
+
+      end
+    end
+
+  end
+
+end

data/lib/ironnails/controller/view_operations.rb

@@ -0,0 +1,101 @@
+module IronNails
+
+  module Controller
+
+    # Encapsulates all the operations that have to do with the 
+    # view model in controllers.
+    module ViewOperations
+
+      attr_accessor :nails_engine
+
+      # gets the view name for the class that includes this module
+      def view_name
+        self.class.demodulize.underscore.gsub(/_controller$/, '')
+      end
+
+      # gets the name of the view model class
+      def view_model_name
+        "#{view_name}_view_model"
+      end
+
+      def nails_engine=(value)
+        @nails_engine = value
+        init_view_manager
+      end
+
+      # initializes a new instance of the ViewManager      
+      def init_view_manager
+
+        nails_engine.add_observer :refreshing_view, controller_name do
+          setup_for_showing_view
+        end
+        copy_vars
+        #end
+      end
+
+      def synchronise_with_view_model
+        nails_engine.synchronise_to_controller self
+        refresh_instance_variables
+      end
+
+      # setup the viewmodel for the current objects and command defintions
+      def setup_for_showing_view
+        #log_on_error do
+        objs = ModelCollection.generate_for refresh_objects
+        cmds = @command_builder.generate_for commands
+        cmds.each do |cmd|
+          cmd.add_observer(:reading_input) do
+            synchronise_with_view_model
+          end
+        end
+        nails_engine.initialize_with cmds, objs
+        logger.debug "initialized the view manager", IRONNAILS_FRAMEWORKNAME
+        #end
+      end
+
+      def add_action(name, options, &b)
+        options[:action] = b if block_given?
+        cmd_def = { "#{name}".to_sym => options }
+        nails_engine.add_command_to_view cmd_def
+      end
+
+      def refresh_objects
+        instance_variables.each do |var|
+          sym = var.gsub(/@/, "").to_sym
+          if objects.has_key?(sym)
+            val = instance_variable_get(var)
+            objects[sym] = val
+          end
+        end
+        objects
+      end
+
+      def refresh_instance_variables
+        objects.each do |k, v|
+          instance_variable_set "@#{k}", v
+        end
+        view_properties.each do |k, v|
+          val = on_view v[:view], :from => v[:element], :get => v[:property]
+          instance_variable_set "@#{k}", val
+        end
+      end
+
+      # copies an instance variable from the class object to this instance
+      def instance_variable_copy(var)
+        log_on_error do
+          val = self.class.instance_variable_get var
+          instance_variable_set var, val
+        end
+      end
+
+      # copies the instance variables from the class object to this instance
+      def copy_vars
+        self.class.instance_variables.each { |var| instance_variable_copy var }
+      end
+
+
+    end
+
+  end
+
+end

data/lib/ironnails/controller.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/controller/view_operations'
+require File.dirname(__FILE__) + '/controller/base'

data/lib/ironnails/core_ext/array.rb

@@ -0,0 +1,15 @@
+class Array
+
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)           # => {}
+  #   options(1, 2, :a => :b) # => {:a=>:b}
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+end