reactive-mvc 0.2.0

data/lib/reactive-mvc/view/renderable_partial.rb

@@ -0,0 +1,49 @@
+module Reactive::Mvc::View
+  # NOTE: The template that this mixin is being included into is frozen
+  # so you cannot set or modify any instance variables
+  module RenderablePartial #:nodoc:
+    extend ActiveSupport::Memoizable
+
+    def variable_name
+      name.sub(/\A_/, '').to_sym
+    end
+    memoize :variable_name
+
+    def counter_name
+      "#{variable_name}_counter".to_sym
+    end
+    memoize :counter_name
+
+=begin
+    def render(view, local_assigns = {})
+      if defined? ActionController
+        ActionController::Base.benchmark("Rendered #{path_without_format_and_extension}", Logger::DEBUG, false) do
+          super
+        end
+      else
+        super
+      end
+    end
+=end
+    def render_partial(view, object = nil, local_assigns = {}, as = nil)
+      object ||= local_assigns[:object] ||
+        local_assigns[variable_name]
+
+      if view.respond_to?(:controller)
+        ivar = :"@#{variable_name}"
+        object ||=
+          if view.controller.instance_variable_defined?(ivar)
+            ActiveSupport::Deprecation::DeprecatedObjectProxy.new(
+              view.controller.instance_variable_get(ivar),
+              "#{ivar} will no longer be implicitly assigned to #{variable_name}")
+          end
+      end
+
+      # Ensure correct object is reassigned to other accessors
+      local_assigns[:object] = local_assigns[variable_name] = object
+      local_assigns[as] = object if as
+
+      render_template(view, local_assigns)
+    end
+  end
+end

data/lib/reactive-mvc/view/template.rb

@@ -0,0 +1,110 @@
+module Reactive::Mvc
+  module View #:nodoc:
+    class Template
+      extend TemplateHandlers
+      extend ActiveSupport::Memoizable
+      include Renderable
+
+      attr_accessor :filename, :load_path, :base_path, :name, :format, :extension
+      delegate :to_s, :to => :path
+
+      def initialize(template_path, load_paths = [])
+        template_path = template_path.dup
+        @base_path, @name, @format, @extension = split(template_path)
+        @base_path.to_s.gsub!(/\/$/, '') # Push to split method
+        @load_path, @filename = find_full_path(template_path, load_paths)
+
+        # Extend with partial super powers
+        extend RenderablePartial if @name =~ /^_/
+      end
+
+      def format_and_extension
+        (extensions = [format, extension].compact.join(".")).blank? ? nil : extensions
+      end
+      memoize :format_and_extension
+
+      def multipart?
+        format && format.include?('.')
+      end
+
+      def content_type
+        format.gsub('.', '/')
+      end
+
+      def path
+        [base_path, [name, format, extension].compact.join('.')].compact.join('/')
+      end
+      memoize :path
+
+      def path_without_extension
+        [base_path, [name, format].compact.join('.')].compact.join('/')
+      end
+      memoize :path_without_extension
+
+      def path_without_format_and_extension
+        [base_path, name].compact.join('/')
+      end
+      memoize :path_without_format_and_extension
+
+      def relative_path
+        path = File.expand_path(filename)
+        path.sub(/^#{Regexp.escape(Reactive.configuration.root_dir)}\//, '')
+      end
+      memoize :relative_path
+
+      def source
+        File.read(filename)
+      end
+      memoize :source
+
+      def method_segment
+        relative_path.to_s.gsub(/([^a-zA-Z0-9_])/) { $1.ord }
+      end
+      memoize :method_segment
+
+      def render_template(view, local_assigns = {})
+        render(view, local_assigns)
+      rescue Exception => e
+        raise e unless filename
+        if TemplateError === e
+          e.sub_template_of(relative_path)
+          raise e
+        else
+          raise TemplateError.new(relative_path, source, e)
+        end
+      end
+
+      private
+        def valid_extension?(extension)
+          Template.template_handler_extensions.include?(extension)
+        end
+
+        def find_full_path(path, load_paths)
+          load_paths = Array(load_paths) + [nil]
+          load_paths.each do |load_path|
+            file = [load_path, path].compact.join('/')
+            return load_path, file if File.file?(file)
+          end
+          raise MissingTemplate.new(load_paths, path)
+        end
+
+        # Returns file split into an array
+        #   [base_path, name, format, extension]
+        def split(file)
+          if m = file.match(/^(.*\/)?([^\.]+)\.?(\w+)?\.?(\w+)?\.?(\w+)?$/)
+            if m[5] # Multipart formats
+              [m[1], m[2], "#{m[3]}.#{m[4]}", m[5]]
+            elsif m[4] # Single format
+              [m[1], m[2], m[3], m[4]]
+            else
+              if valid_extension?(m[3]) # No format
+                [m[1], m[2], nil, m[3]]
+              else # No extension
+                [m[1], m[2], m[3], nil]
+              end
+            end
+          end
+        end
+    end
+  end
+end

data/lib/reactive-mvc/view/template_error.rb

@@ -0,0 +1,9 @@
+module Reactive::Mvc
+  module View
+    # The TemplateError exception is raised when the compilation of the template fails. This exception then gathers a
+    # bunch of intimate details and uses it to report a very precise exception message.
+    class TemplateError < Error #:nodoc:
+      include Reactive::TemplateError
+    end
+  end
+end

data/lib/reactive-mvc/view/template_handler.rb

@@ -0,0 +1,9 @@
+# Legacy TemplateHandler stub
+
+module Reactive::Mvc::View
+  class TemplateHandler
+    def self.call(template)
+      new.compile(template)
+    end
+  end
+end

data/lib/reactive-mvc/view/template_handlers.rb

@@ -0,0 +1,43 @@
+require 'reactive-mvc/view/template_handler'
+#require 'reactive-mvc/view/template_handlers/builder'
+require 'reactive-mvc/view/template_handlers/erb'
+require 'reactive-mvc/view/template_handlers/ruby_code'
+
+module Reactive::Mvc
+  module View #:nodoc:
+    module TemplateHandlers #:nodoc:
+      def self.extended(base)
+        base.register_default_template_handler :rb, TemplateHandlers::RubyCode
+        base.register_template_handler :erb, TemplateHandlers::ERB
+#        base.register_template_handler :builder, TemplateHandlers::Builder
+      end
+
+      @@template_handlers = {}
+      @@default_template_handlers = nil
+
+      # Register a class that knows how to handle template files with the given
+      # extension. This can be used to implement new template types.
+      # The constructor for the class must take the Reactive::View::Base instance
+      # as a parameter, and the class must implement a +render+ method that
+      # takes the contents of the template to render as well as the Hash of
+      # local assigns available to the template. The +render+ method ought to
+      # return the rendered template as a string.
+      def register_template_handler(extension, klass)
+        @@template_handlers[extension.to_sym] = klass
+      end
+
+      def template_handler_extensions
+        @@template_handlers.keys.map(&:to_s).sort
+      end
+
+      def register_default_template_handler(extension, klass)
+        register_template_handler(extension, klass)
+        @@default_template_handlers = klass
+      end
+
+      def handler_class_for_extension(extension)
+        (extension && @@template_handlers[extension.to_sym]) || @@default_template_handlers
+      end
+    end
+  end
+end

data/lib/reactive-mvc/view/template_handlers/builder.rb

@@ -0,0 +1,15 @@
+require 'builder'
+
+module Reactive::Mvc::View
+  module TemplateHandlers
+    class Builder < TemplateHandler
+      def compile(template)
+        "_set_controller_content_type(Mime::XML);" +
+          "xml = ::Builder::XmlMarkup.new(:indent => 2);" +
+          "self.output_buffer = xml.target!;" +
+          template.source +
+          ";xml.target!;"
+      end
+    end
+  end
+end

data/lib/reactive-mvc/view/template_handlers/erb.rb

@@ -0,0 +1,20 @@
+require 'erb'
+
+module Reactive::Mvc::View
+  module TemplateHandlers
+    class ERB < TemplateHandler
+      # Specify trim mode for the ERB compiler. Defaults to '-'.
+      # See ERb documentation for suitable values.
+      cattr_accessor :erb_trim_mode
+      self.erb_trim_mode = '-'
+
+      def compile(template)
+        src = ::ERB.new("<% __in_erb_template=true %>#{template.source}", nil, erb_trim_mode, '@output_buffer').src
+
+        # Ruby 1.9 prepends an encoding to the source. However this is
+        # useless because you can only set an encoding on the first line
+        RUBY_VERSION >= '1.9' ? src.sub(/\A#coding:.*\n/, '') : src
+      end
+    end
+  end
+end

data/lib/reactive-mvc/view/template_handlers/ruby_code.rb

@@ -0,0 +1,9 @@
+module Reactive::Mvc::View
+  module TemplateHandlers
+    class RubyCode < TemplateHandler
+      def compile(template)
+        template.source.inspect
+      end
+    end
+  end
+end

data/reactive_app_generators/mvc/USAGE

@@ -0,0 +1,10 @@
+Description:
+    Creates the required directories for MVC files which by default are:
+      app/models
+      app/controllers
+      app/helpers
+      app/views
+      
+    Creates the application controller.
+    
+    Modifies the config file to setup the default dispatcher (see config/config.rb)

data/reactive_app_generators/mvc/mvc_generator.rb

@@ -0,0 +1,48 @@
+class MvcGenerator < RubiGen::Base
+  attr_reader :app_name
+    
+  def initialize(runtime_args, runtime_options = {})
+    super
+    @destination_root = runtime_args.shift || '.'
+    @app_name = File.basename(File.expand_path(@destination_root))
+    extract_options
+  end
+
+  def manifest
+    record do |m|
+      [:mvc, :views, :model, :helper, :controller, :test].each do |dir_id|
+        m.directory(Reactive.relative_path_for(dir_id))
+      end
+    
+      m.file "application_controller.rb", Reactive.relative_path_for(:controller, "application_controller.rb")
+    
+      unless options[:pretend]
+        # Find the beginning of the config block, then skip all gems statments, insert here.
+        m.gsub_file Reactive.relative_path_for(:config, "config.rb"), /with Reactive\.configuration do \|config\|.*config.gem.*?$/mi do |match|
+          "#{match}\n\n  config.dispatcher.default_dispatcher = :mvc\n"
+        end
+      end
+      
+    end
+  end
+
+  protected
+  
+    def add_options!(opts)
+      # opts.separator ''
+      # opts.separator 'Options:'
+      # # For each option below, place the default
+      # # at the top of the file next to "default_options"
+      # opts.on("-r", "--ruby=path", String,
+      #        "Path to the Ruby binary of your choice (otherwise scripts use env, dispatchers current path).",
+      #        "Default: #{DEFAULT_SHEBANG}") { |options[:shebang]| }
+    end
+    
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+  
+end

data/reactive_app_generators/mvc/templates/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < Reactive::Mvc::Controller::Base
+end

data/reactive_generators/controller/USAGE

@@ -0,0 +1,7 @@
+Description:
+    Generate an empty controller.
+
+    Pass the name of the controller as the first argument.
+
+Examples:
+    `./script/generate controller product`

data/reactive_generators/controller/controller_generator.rb

@@ -0,0 +1,24 @@
+class ControllerGenerator < Reactive::NamedBaseGenerator
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions(path, "#{plural_class_name}Controller")
+    
+      # Controller, helper, views, and test directories.
+      m.directory(Reactive.relative_path_for(:controller, path))
+
+      m.template('controller.rb', Reactive.relative_path_for(:controller, path, "#{plural_name}_controller.rb"))
+#      m.template('functional_test.rb', File.join('test/functional', controller_class_path, "#{controller_file_name}_controller_test.rb"))
+    end
+  end
+
+  protected
+    # Override with your own usage banner.
+    def banner
+      "Usage: #{$0} controller [name]"
+    end
+
+    def add_options!(opt)
+    end
+  
+end

data/reactive_generators/controller/templates/controller.rb

@@ -0,0 +1,2 @@
+class <%= plural_class_name %>Controller < ApplicationController
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: reactive-mvc
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Pascal Hurni
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-12 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: reactive-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+description: Provides a local MVC machinery to handle requests of the reactive application. The machinery is mapped to what is done in RubyOnRails, so you'll have rails like controllers, rails like views and helpers.  Because Reactive is Model and View agnostic, this plugin alone will not do the complete job.
+email: phi@ruby-reactive.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- README
+- LICENSE
+- Manifest
+- Rakefile
+- lib/reactive-mvc.rb
+- lib/reactive-mvc/controller.rb
+- lib/reactive-mvc/controller/base.rb
+- lib/reactive-mvc/controller/filters.rb
+- lib/reactive-mvc/controller/flash.rb
+- lib/reactive-mvc/controller/helpers.rb
+- lib/reactive-mvc/controller/layout.rb
+- lib/reactive-mvc/controller/output.rb
+- lib/reactive-mvc/controller/rescue.rb
+- lib/reactive-mvc/dispatcher.rb
+- lib/reactive-mvc/view.rb
+- lib/reactive-mvc/view/base.rb
+- lib/reactive-mvc/view/helpers.rb
+- lib/reactive-mvc/view/partials.rb
+- lib/reactive-mvc/view/paths.rb
+- lib/reactive-mvc/view/renderable.rb
+- lib/reactive-mvc/view/renderable_partial.rb
+- lib/reactive-mvc/view/template.rb
+- lib/reactive-mvc/view/template_error.rb
+- lib/reactive-mvc/view/template_handler.rb
+- lib/reactive-mvc/view/template_handlers.rb
+- lib/reactive-mvc/view/template_handlers/builder.rb
+- lib/reactive-mvc/view/template_handlers/erb.rb
+- lib/reactive-mvc/view/template_handlers/ruby_code.rb
+- reactive_app_generators/mvc/USAGE
+- reactive_app_generators/mvc/mvc_generator.rb
+- reactive_app_generators/mvc/templates/application_controller.rb
+- reactive_generators/controller/USAGE
+- reactive_generators/controller/controller_generator.rb
+- reactive_generators/controller/templates/controller.rb
+has_rdoc: true
+homepage: http://www.ruby-reactive.org
+post_install_message: 
+rdoc_options: 
+- -x
+- Manifest
+- -x
+- Rakefile
+- -x
+- .*\.rake
+- -m
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: reactive-mvc
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Reactive plugin that dispatches requests to a local MVC machinery.
+test_files: []
+