rpv_core 0.2

data/Rakefile

@@ -0,0 +1,3 @@
+Dir.glob("tasks/**/*.rake").each do |rake_file|
+  load File.expand_path(File.dirname(__FILE__) + "/" + rake_file)
+end

data/bin/rpv

@@ -0,0 +1,68 @@
+#!/usr/bin/ruby
+#TODO ^
+
+require 'fileutils'
+require 'rpv/inflector'
+
+def usage
+    puts <<-END
+  rpv new APP_NAME 
+    #creates a new app in ./APP_NAME
+  rpv g GENERATOR ARG:VALUE
+    #invokes a generator
+    #call without argument to see what generators are available
+    #This only works when run in an application's directory
+  END
+  exit(0)
+end
+
+def generate
+  $LOAD_PATH << FileUtils.pwd
+  begin
+    require 'app/setup'
+    RPV::Generators.require_all
+  rescue LoadError
+    puts "Could not load ./app/setup.rb; make sure pwd is the application's dir"
+    exit(0)
+  end
+  if ARGV[1].nil?
+    RPV::Generators.all.each do |c|
+      puts "  " + c.to_s.gsub("RPV::Generators::","").underscore.gsub("_generator", "") + ' #' + c.describe
+      puts "    args: " + c.argument_definitions.join(", ")
+    end
+  else
+    args = ARGV.dup
+    args.delete_at(0)
+    generator_class = ("RPV::Generators::" + (args.delete_at(0) + "_generator").camelize).constantize
+    generator_args = {}
+    args.each do |a|
+      if a =~ /(.*):(.*)/
+        generator_args[$1.to_sym] = $2
+      end
+    end
+    generator_class.new.execute *[generator_args.merge({:to_path => '.'})]
+  end
+end
+
+
+
+case ARGV[0]
+  when 'new'
+    usage if ARGV[1].nil?
+    require 'rpv/generators/app_generator'
+    RPV::Generators::AppGenerator.new.execute :to_path => "./#{ARGV[1]}"
+  when 'g' #generate
+    generate
+  when 'r' #run
+    $LOAD_PATH << FileUtils.pwd
+    begin
+      require 'app/main'
+    rescue LoadError
+      puts "Could not load ./app/main.rb; make sure pwd is the application's dir"
+      exit(0)
+    end
+  else nil
+    usage
+end
+
+

data/lib/rpv/autoload.rb

@@ -0,0 +1,36 @@
+require 'rpv/inflector'
+
+module RPV
+  module Autoload
+    def self.setup_paths(*paths)
+      paths = [paths].flatten.map { |p| File.expand_path(p) }
+      add_paths = paths.dup
+      paths.each do |base|
+        #trouble with directory named 'lib' inside jar, seems
+        #like it was not found by Dir[]
+        #puts "--- #{base}"
+        #puts Dir["#{base}/lib/**/*"]
+        Dir["#{base}/**/*"].each do |path|
+          if File.directory?(path)
+            add_paths << path
+          end
+        end
+      end
+      add_paths.each do |path|
+        $LOAD_PATH << path unless $LOAD_PATH.include?(path)
+      end
+    end
+  end
+end
+
+#overwrite 
+class Class
+  def const_missing(sym)
+    begin
+      require sym.to_s.underscore
+    rescue LoadError => e
+      raise NameError.new("Missing constant #{sym.to_s} (#{e.to_s})")
+    end
+    sym.to_s.constantize
+  end
+end

data/lib/rpv/base_presenter.rb

@@ -0,0 +1,41 @@
+require 'rpv/wiring'
+require 'rpv/method_helper'
+require 'rpv/option_extractor'
+
+module RPV
+  class BasePresenter
+    include MethodHelper
+    include OptionExtractor
+    
+    attr_reader :model, :view
+    
+    def self.wires(w = nil)
+      @wires = (@wires || []) << w unless w.nil?
+      @wires || []
+    end
+    
+    def initialize(*args)
+      
+    end
+    
+    def update_view(args = {})
+      update(:view, args)
+    end
+    
+    def update_model(args = {})
+      update(:model, args)
+    end
+    
+    def update_presenter(args = {})
+      update(:presenter, args)
+    end
+    
+  private
+    def update(what, args = {})
+      what = what.to_s
+      self.class.wires.select { |w| w.send("#{what}_match", args) }.each do |w|
+        w.send("update_#{what}", @model, @view, self)
+      end
+    end
+  end
+end

data/lib/rpv/event_publisher.rb

@@ -0,0 +1,125 @@
+module RPV
+  # This module is used to publish events.
+  # Usage:
+  #   class Foo < SomeThing
+  #     include RPV::EventPublisher
+  #     
+  #     fires :some_event
+  #     def bar
+  #       fire :some_event
+  #     end
+  #   end
+  #
+  # Now you can subscribe to the event:
+  #   foo = Foo.new
+  #   foo.subscribe :some_event do
+  #     #do something
+  #   end
+  # Or:
+  #   foo.subscribe :some_event, RPV::Method.new(self, :some_method)
+  # Or (if you included RPV::MethodHelper):
+  #   foo.subscribe :some_event, method(:some_method)
+  module EventPublisher
+    def self.included(base) #:nodoc:
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      # Declare events.
+      #   fires :some_event
+      # You can also declare several events at a time.
+      #   fires :event_a, :event_b, :event_c
+      def fires(*events)
+        #TODO make inheritable?
+        @events ||= []
+        @events += [events].flatten.map { |e| e.to_sym }
+      end
+      
+      # Declare aliases for events.
+      #   alias_event :some_event, :whatever
+      # Event receivers now can subscribe to the event :whatever.
+      # It's also possible to assign the same alias to multiple events.
+      # Aliases can only be used to subscribe to.
+      def alias_event(event, event_alias)
+        @event_aliases ||= Hash.new{|h,k| h[k] = []}
+        @event_aliases[event_alias.to_sym] << event.to_sym
+      end
+      
+      # This method accepts regular expressions for aliasing events.
+      # Given there are following events:
+      # - ok_action_performed
+      # - cancel_action_performed
+      #   alias_events /^(.*)_action_performed$/, "$1_clicked"
+      # Produces the aliases "ok_clicked" and "cancel_clicked"
+      # It can also be used to
+      #   alias_events /^(.*)_action_performed$/, "some_button_clicked"
+      def alias_events(regex, alias_rule)
+        @events ||= []
+        @events.each do |event|
+          if match = regex.match(event.to_s)
+            alias_event event, alias_rule.gsub(/\$([0-9]+)/).each { |e| match[e[1..-1].to_i] }
+          end
+        end
+      end
+      
+      # Returns all registered events.
+      def events
+        @events || []
+      end
+      
+      def event_aliases
+        @event_aliases || Hash.new{|h,k| h[k] = []}
+      end
+      
+      def fires?(event)
+        events.include?(event) || event_aliases.keys.include?(event)
+      end
+    end
+    
+    # Returns all registered events.
+    def events
+      self.class.events
+    end
+    
+    def event_aliases
+      self.class.event_aliases
+    end
+    
+    # Subscribe to an event.
+    # method should be a RPV::Method or some object that responds to call(*args)
+    def subscribe(event, method = nil, &block)
+      @subscriptions ||= Hash.new{|h,k| h[k] = []}
+      if event.is_a?(String) || event.is_a?(Symbol)
+        if events.include? event
+          unless method.nil?
+            @subscriptions[event] << { :receiver => method }
+          else
+            @subscriptions[event] << { :receiver => block }
+          end
+        elsif event_aliases.keys.include? event
+          event_aliases[event].each do |event|
+            subscribe event, method, &block
+          end
+        end
+      elsif event.is_a?(Array)
+        event.uniq.each do |e|
+          subscribe(e, method, &block)
+        end
+      elsif event.is_a?(Regexp)
+        subscribe(events.find_all { |e| e.to_s =~ event }, method, &block)
+      end
+    end
+    
+    alias :when :subscribe
+    
+  private
+    def fire(event, *args)
+      @subscriptions ||= Hash.new{|h,k| h[k] = []}
+      if @subscriptions.has_key? event
+        @subscriptions[event].each do |subscription|
+          subscription[:receiver].call *args
+        end
+      end
+    end
+  end
+end

data/lib/rpv/generators/app_generator.rb

@@ -0,0 +1,17 @@
+require 'rpv/generators/base'
+
+module RPV
+  module Generators
+    class AppGenerator < Base
+      copy_all
+      
+      create_dir 'app/presenters'
+      create_dir 'app/views'
+      create_dir 'app/models'
+      
+      def initialize
+        @template_path = File.join(File.dirname(__FILE__), 'templates/app')
+      end
+    end
+  end
+end

data/lib/rpv/generators/base.rb

@@ -0,0 +1,130 @@
+require 'erb'
+require 'fileutils'
+require 'rpv/inflector'
+
+module RPV
+  module Generators
+    class Base
+      def self.describe
+        ""
+      end
+    
+      def self.argument(name)
+        @argument_definitions ||= []
+        @argument_definitions << name
+      end
+      
+      def self.argument_definitions
+        @argument_definitions || []
+      end
+      
+      def self.copy_all
+        copy '**/*'
+      end
+      
+      def self.copy(glob = nil)
+        @copy = (@copy || []) << glob unless glob.nil?
+        @copy || []
+      end
+      
+      # Adds a directory that should be created, although it is empty.
+      # Actually the directory does not need to exist in the template.
+      # Expects a relative path.
+      def self.create_dir(rel_path = nil)
+        @create_dir = (@create_dir || []) << rel_path unless rel_path.nil?
+        @create_dir || []
+      end
+      
+      
+      def self.parse(rel_path, new_path = nil)
+        @templates ||= {}
+        @templates[rel_path] = new_path || rel_path.gsub(/\.erb$/, '')
+        copy rel_path
+      end
+      
+      def self.templates
+        @templates || {}
+      end
+      
+      def execute(args = {})
+        to_path = File.join(FileUtils.pwd, args[:to_path]) #TODO 
+        FileUtils.mkdir_p to_path
+        @arguments = args
+        parse_args
+        
+        files = self.class.copy.map { |c| Dir.glob(File.join(@template_path, c)) }.flatten.uniq
+        
+        files_new_path = {}
+        files.each do |file|
+          rel_path = relative_path(file, @template_path)
+          if self.class.templates.keys.member? rel_path
+            new_rel_path = eval("\"#{self.class.templates[rel_path]}\"")
+            files_new_path[File.join(to_path, new_rel_path)] = file
+          else
+            files_new_path[File.join(to_path, rel_path)] = file
+          end
+        end
+        
+        files_new_path.keys.sort_by { |p| p.count('/') }.each do |new_path|
+          file = files_new_path[new_path]
+          rel_path = relative_path(new_path, to_path)
+          if File.directory?(file)
+            if File.exists?(new_path)
+              puts "exists #{rel_path}"
+            else
+              FileUtils.mkdir_p new_path
+              puts "create #{rel_path}"
+            end
+          else
+            exists = File.exists?(new_path)
+            if !exists || (exists && overwrite?(rel_path))
+              puts "create #{rel_path}"
+              if self.class.templates.keys.member? relative_path(file, @template_path)
+                FileUtils.mkdir_p(File.dirname(new_path)) unless File.exists?(File.dirname(new_path))
+                erb = ERB.new(File.read(file))
+                output = File.new(new_path, "w")
+                output << erb.result(binding)
+                output.close
+              else
+                FileUtils.cp file, new_path
+              end
+            end
+          end
+        end
+        
+        self.class.create_dir.each do |d|
+          FileUtils.mkdir_p File.join(to_path, d)
+          puts "create dir #{d}"
+        end      
+      end
+      
+      def overwrite?(path)
+        return true if @overwrite_all
+        puts "File #{path} exists. Overwrite? (y(es)/n(o)/a(ll)) "
+        a = STDIN.gets.downcase[0..0]
+        @overwrite_all = a == 'a'
+        @overwrite_all || a == 'y'
+      end
+      
+      def method_missing(name, *args)
+        if @arguments.member? name
+          @arguments[name] rescue nil
+        else
+          raise NoMethodError, "no method #{name} on #{self.class.to_s}"
+        end
+      end
+      
+      def parse_args
+      end
+      
+      # returns a relative path
+      #   relative_path("/home/user/foo/bar.rb", "/home/user") #=> "foo/bar.rb"
+      #   relative_path("/home/user/foo/bar.rb", "/home/user/") #=> "foo/bar.rb"
+      #   relative_path("/home/user/code/home/foo/bar.rb", "/home") #=> "user/code/home/foo/bar.rb"
+      def relative_path(full_path, base_path)
+        rel = full_path.gsub(/^#{base_path}/, '')
+        rel.start_with?('/') ? rel[1..-1] : rel
+      end
+    end
+  end
+end

data/lib/rpv/generators/presenter_generator.rb

@@ -0,0 +1,28 @@
+require 'rpv/generators/base'
+
+module RPV
+  module Generators
+    class PresenterGenerator < RPV::Generators::Base
+      argument :name
+      parse 'presenter.rb.erb', 'app/presenters/#{name}.rb'
+      parse 'presenter_spec.rb.erb', 'spec/presenters/#{name}_spec.rb'
+      
+      def initialize
+        @template_path = File.dirname(__FILE__) + '/templates/presenter'
+      end
+      
+      def parse_args
+        @arguments[:name] = @arguments[:name].underscore + "_presenter"
+        @arguments[:class_name] = @arguments[:name].camelize
+      end
+      
+      def self.show?
+        true
+      end
+      
+      def self.describe
+        "Creates a new presenter"
+      end
+    end
+  end
+end