rpv_core 0.2

data/lib/rpv/wiring/simple.rb

@@ -0,0 +1,19 @@
+require "rpv/wiring/converting"
+
+module RPV
+  module Wiring
+    class Simple < Converting
+      def initialize(args = {})
+        super
+      end
+      
+      def convert_from_view(value)
+        value
+      end
+      
+      def convert_to_view(value)
+        value
+      end
+    end
+  end
+end

data/lib/rpv/wiring/unidirectional.rb

@@ -0,0 +1,38 @@
+module RPV
+  module Wiring
+    # Wraps any other wiring in order to do updates only into one direction.
+    # Valid directions are :model_only, :presenter_only, :view_only
+    class Unidirectional
+      def initialize(wiring, direction)
+        @wiring, @direction = wiring, direction
+      end
+      
+      def update_model(*args)
+        @wiring.update_model(*args) if @direction == :model_only
+      end
+      
+      def update_presenter(*args)
+        @wiring.update_presenter(*args) if @direction == :presenter_only
+      end
+      
+      def update_view(*args)
+        @wiring.update_view(*args) if @direction == :view_only
+      end
+      
+      # Match the view method against a hash of constraints (like { :only => /^bar\.(.*)/, :except => /(.*)\.text$/ })
+      def view_match(args = {})
+        @wiring.view_match(args)
+      end
+      
+      # Match the presenter method against a hash of constraints (like { :only => /^bar\.(.*)/, :except => /(.*)\.text$/ })
+      def presenter_match(args = {})
+        @wiring.presenter_match(args)
+      end
+      
+      # Match the model method against a hash of constraints (like { :only => /^bar\.(.*)/, :except => /(.*)\.text$/ })
+      def model_match(args = {})
+        @wiring.model_match(args)
+      end
+    end
+  end
+end

data/lib/rpv/wiring.rb

@@ -0,0 +1,4 @@
+require 'rpv/wiring/simple'
+require 'rpv/wiring/converting'
+require 'rpv/wiring/callable'
+require 'rpv/wiring/unidirectional'

data/lib/rpv.rb

@@ -0,0 +1,20 @@
+require "rpv/inflector"
+require "rpv/base_presenter"
+require "rpv/event_publisher"
+
+module RPV
+  module Generators
+    Requires = []
+    
+    def self.require_all
+      Requires.each { |r| require r }
+    end
+    
+    def self.all
+      require_all
+      Requires.map { |r| eval(r.camelize.gsub(/Rpv/, "RPV")) }
+    end
+  end
+end
+
+RPV::Generators::Requires << 'rpv/generators/presenter_generator'

data/spec/autoload_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+require 'rpv/autoload'
+
+describe "RPV::Autoload" do
+  before(:all) do
+    RPV::Autoload.setup_paths File.dirname(__FILE__) + '/files/autoload'
+  end
+
+  it "should add the base dir and all beneath it to LOAD_PATH" do
+    $LOAD_PATH.select { |p| p =~ /spec\/files\/autoload$/ }.size.should == 1
+    $LOAD_PATH.select { |p| p =~ /spec\/files\/autoload/ }.size.should == 3
+  end
+  
+  it "should try to require the right files" do
+    a = SomeClass.new
+    b = SomeModule
+  end
+  
+  it "should raise an exception if a file is missing" do
+    lambda { NonExistingClass.new }.should raise_error(NameError)
+  end
+end
+

data/spec/base_presenter_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+require 'rpv/base_presenter'
+
+describe "BasePresenter" do
+  it "should add wires" do
+    c = Class.new(RPV::BasePresenter)
+    c.send(:wires, "foo")
+    c.send(:wires).size.should == 1
+  end
+  
+  it "should not fail to update if there are no wires" do
+    c = Class.new(RPV::BasePresenter)
+    c.new.update_model
+  end
+end

data/spec/event_publisher_spec.rb

@@ -0,0 +1,121 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'rpv/event_publisher'
+
+class Foo
+  include RPV::EventPublisher
+  fires :event_a, :event_b
+  
+  def do_fire(event, *args)
+    fire event, *args
+  end
+end
+
+describe "EventPublisher" do
+  it "should add events" do
+    Foo.events.should include :event_a
+  end
+  
+  it "should alias an event" do
+    Foo.class_eval("alias_event :event_a, :alias")
+    f = Foo.new
+    called = false
+    f.subscribe :alias do 
+      called = true
+    end
+    f.do_fire :event_a
+    called.should be_true
+  end
+  
+  it "should create aliases using a regex" do
+    Foo.class_eval("alias_events /^event_(.+)$/, '$1_happend'")
+    Foo.event_aliases[:a_happend].should == [:event_a]
+    Foo.event_aliases[:b_happend].should == [:event_b]
+    
+    Foo.class_eval("alias_events /^event_.+$/, 'something_happend'")
+    Foo.event_aliases[:something_happend].should == [:event_a, :event_b]
+  end
+  
+  it "should create aliases later" do
+    #for published events, which are not available without an instance
+    pending
+  end
+  
+  it "should call a block" do
+    f = Foo.new
+    called = false
+    f.subscribe :event_a do 
+      called = true
+    end
+    f.do_fire :event_a
+    called.should be_true
+  end
+  
+  it "should pass an argument to the block" do
+    f = Foo.new
+    called = false
+    f.subscribe :event_a do |arg|
+      called = true
+      arg.should == "hello"
+    end
+    f.do_fire :event_a, "hello"
+    called.should be_true
+  end
+  
+  it "should call a method" do
+    r = mock_block("receiver") do |m|
+      m.should_receive(:foo).with(no_args())
+    end
+    f = Foo.new
+    f.subscribe :event_a, RPV::Method.new(r, :foo)
+    f.do_fire :event_a
+  end
+  
+  it "should pass an argument to the method" do
+    r = mock_block("receiver") do |m|
+      m.should_receive(:foo).with("hello")
+    end
+    f = Foo.new
+    f.subscribe :event_a, RPV::Method.new(r, :foo)
+    f.do_fire :event_a, 'hello'
+  end
+  
+  it "should pass any number of arguments to a receiver" do
+    r = mock_block("receiver") do |m|
+      m.should_receive(:foo).with("hello", "i", "have", "lots", :to, "tell")
+    end
+    f = Foo.new
+    f.subscribe :event_a, RPV::Method.new(r, :foo)
+    f.do_fire :event_a, "hello", "i", "have", "lots", :to, "tell"
+  end
+  
+  it "should allow multiple subscriptions on an event" do
+    r = mock_block("receiver") do |m|
+      m.should_receive(:foo)
+      m.should_receive(:bar)
+    end
+    f = Foo.new
+    f.subscribe :event_a, RPV::Method.new(r, :foo)
+    f.subscribe :event_a, RPV::Method.new(r, :bar)
+    f.do_fire :event_a
+  end
+  
+  it "should allow to subscribe by regex" do
+    r = mock_block("receiver") do |m|
+      m.should_receive(:foo).twice
+    end
+    f = Foo.new
+    f.subscribe /^event_.+$/, RPV::Method.new(r, :foo)
+    f.do_fire :event_a
+    f.do_fire :event_b
+  end
+  
+  it "should allow to subscribe to multiple events" do
+    r = mock_block("receiver") do |m|
+      m.should_receive(:foo).twice
+    end
+    f = Foo.new
+    f.subscribe [:event_a, :event_b, :event_a], RPV::Method.new(r, :foo)
+    f.do_fire :event_a
+    f.do_fire :event_b
+  end
+end

data/spec/files/autoload/b/some_module.rb

@@ -0,0 +1,2 @@
+module SomeModule
+end

data/spec/files/autoload/some_class.rb

@@ -0,0 +1,3 @@
+class SomeClass
+
+end

data/spec/files/bar/presenter.rb.erb

@@ -0,0 +1,5 @@
+require 'rpv/base_presenter'
+
+class <%= class_name %>Presenter < RPV::BasePresenter
+
+end

data/spec/files/bar/view.rb.erb

@@ -0,0 +1,3 @@
+class <%= class_name %>View
+
+end

data/spec/files/foo/app/main.rb.erb

@@ -0,0 +1 @@
+<%= main %>

data/spec/files/foo/app/models/templates/lala.html.erb

@@ -0,0 +1,2 @@
+A template that should not be parsed.
+<%= non_existing_variable %>

data/spec/generators/base_spec.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + "/../spec_helper.rb"
+require 'fileutils'
+
+require "rpv/generators/base"
+
+# An application generator
+class FooGenerator < RPV::Generators::Base
+  argument :main
+  copy_all
+  copy 'app/**/*' #redundant, in order to check if stuff is copied only once
+  parse 'app/main.rb.erb' #this file will be parsed and saved to 'app/main.rb'
+  
+  def initialize
+    @template_path = File.expand_path(File.dirname(__FILE__) + '/../files/foo')
+  end
+end
+
+# Generates a view and a presenter
+class BarGenerator < RPV::Generators::Base
+  argument :name
+  parse 'presenter.rb.erb', 'app/presenters/#{name}_presenter.rb'
+  parse 'view.rb.erb', 'app/views/#{name}_view.rb'
+  
+  def initialize
+    @template_path = File.expand_path(File.dirname(__FILE__) + '/../files/bar')
+  end
+  
+  def parse_args
+    @arguments[:name] = @arguments[:name].underscore
+    @arguments[:class_name] = @arguments[:name].camelize
+  end
+end
+
+describe "base generator" do
+  before(:all) do
+    FileUtils.mkdir_p 'spec/tmp'
+  end
+
+  it "should copy files" do
+    g = FooGenerator.new
+    FileUtils.cd 'spec/tmp' do
+      FileUtils.rm_r 'app1' if File.exists? 'app1'
+      g.execute(:to_path => 'app1', :main => "lala")
+    end
+    File.exists?('spec/tmp/app1').should be_true
+    File.exists?('spec/tmp/app1/app/models/templates/lala.html.erb').should be_true
+    File.exists?('spec/tmp/app1/app/main.rb').should be_true
+    File.read('spec/tmp/app1/app/main.rb').should == "lala\n"
+  end
+  
+  it "should eval new paths for parsed files" do
+    g = BarGenerator.new
+    FileUtils.cd 'spec/tmp' do
+      FileUtils.rm_r 'app' if File.exists? 'app'
+      g.execute(:to_path => '', :name => "lala")
+    end
+    File.exists?('spec/tmp/app/presenters').should be_true
+    File.exists?('spec/tmp/app/views').should be_true
+    File.exists?('spec/tmp/app/presenters/lala_presenter.rb').should be_true
+    File.exists?('spec/tmp/app/views/lala_view.rb').should be_true
+    File.read('spec/tmp/app/presenters/lala_presenter.rb').should =~ /LalaPresenter/
+    File.read('spec/tmp/app/views/lala_view.rb').should =~ /LalaView/
+  end
+  
+  it "should ask before overwriting files" do
+    g = RPV::Generators::Base.new
+    file = "huhu/lala/1.rb"
+    g.should_receive(:puts).twice.with("File #{file} exists. Overwrite? (y(es)/n(o)/a(ll)) ")
+    STDIN.should_receive(:gets).twice.and_return("y\n", "a\n")
+    g.overwrite?(file).should be_true
+    g.overwrite?(file).should be_true
+    g.overwrite?(file).should be_true #the second time we answered a(ll), so now we should not be asked again
+  end
+  
+  it "should generate relative paths" do
+    g = RPV::Generators::Base.new
+    g.relative_path("/home/user/foo/bar.rb", "/home/user").should == "foo/bar.rb"
+    g.relative_path("/home/user/foo/bar.rb", "/home/user/").should == "foo/bar.rb"
+    g.relative_path("/home/user/code/home/foo/bar.rb", "/home").should == "user/code/home/foo/bar.rb"
+  end
+end

data/spec/generators/presenter_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + "/../spec_helper.rb"
+require 'fileutils'
+
+require "rpv/generators/presenter_generator"
+
+describe "presenter generator" do
+  before(:all) do
+    FileUtils.mkdir_p 'spec/tmp'
+  end
+  
+  after(:all) do
+    FileUtils.rm_r 'spec/tmp'
+  end
+
+  it "should create a presenter and a spec" do
+    g = RPV::Generators::PresenterGenerator.new
+    FileUtils.cd 'spec/tmp' do
+      FileUtils.rm_r 'app' if File.exists? 'app'
+      FileUtils.rm_r 'spec' if File.exists? 'spec'
+      g.execute(:to_path => '.', :name => "foo")
+    end
+    File.exists?('spec/tmp/app/presenters/foo_presenter.rb').should be_true
+    File.exists?('spec/tmp/spec/presenters/foo_presenter_spec.rb').should be_true
+    File.read('spec/tmp/app/presenters/foo_presenter.rb').should =~ /class FooPresenter/
+    File.read('spec/tmp/spec/presenters/foo_presenter_spec.rb').should =~ /describe FooPresenter/
+  end
+end

data/spec/method_helper_spec.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'rpv/method_helper'
+
+describe "MethodHelper" do
+  it "should return a Method" do
+    instance = Class.new {
+      include RPV::MethodHelper
+      
+      def some_method(foo)
+        foo.to_s
+      end
+    }.new
+    
+    m = instance.method("foo")
+    m.should be_a(RPV::Method)
+    m.method.should == :foo
+    m.object.should == instance
+  end
+end

data/spec/method_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'rpv/method'
+
+describe "Method" do
+  it "should call a method passing all args" do
+    receiver = mock_block("receiver") do |m|
+      m.should_receive(:foo).with(1, "asdf")
+    end
+    m = RPV::Method.new(receiver, :foo)
+    m.call(1, "asdf")
+  end
+end

data/spec/option_extractor_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'rpv/option_extractor'
+
+describe "OptionExtractor" do
+  it "should extract given options from args" do
+    instance = Class.new {
+      include RPV::OptionExtractor
+      
+      def foo(*args)
+        @foo, @bar, @foo_bar = extract_options(args, :foo, :bar, :foo_bar)
+        [@foo, @bar, @foo_bar]
+      end
+      
+      def bar(*args)
+        @lala = extract_options(args, :lala)
+        @lala
+      end
+    }.new
+    instance.foo("some", "arguments", :bar => 1, :foo => 0).should == [0, 1, nil]
+    instance.bar(:lala => 1).should == 1
+  end
+end