action_tree 0.1.0

data/lib/action_tree.rb

@@ -0,0 +1,47 @@
+
+require 'set'
+require 'backports'
+
+module ActionTree
+
+  require 'action_tree/eval_scope'
+  require 'action_tree/capture_hash'
+  require 'action_tree/dialect_helper'
+
+  module Plugins
+    require 'action_tree/plugins/tilt'
+  end
+
+
+  module Dialect
+    def new(*prms, &blk)
+      self::Node.new(*prms, &blk)
+    end
+    def apply(mod)
+      self::Node.send(:include, mod::NodeMixin)
+      self::Match.send(:include, mod::MatchMixin)
+      self::Match::DEFAULT_HELPERS << mod::Helpers
+    end
+  end
+
+  # load basic dialect
+  module Basic
+    extend Dialect
+    require "action_tree/basic/node"
+    require "action_tree/basic/match"
+  end
+
+  # shorthand
+  def self.new(&blk)
+    Basic.new(&blk)
+  end
+
+  # layer proc wrapper
+  class Layer < Proc; end
+  def layer(*prms, &blk)
+    Layer.new(*prms, &blk)
+  end
+
+end
+
+

data/spec/01_support_lib_spec.rb

@@ -0,0 +1,41 @@
+
+require 'action_tree'
+
+
+
+describe ActionTree::EvalScope do
+  it 'has access to local variables' do
+    @say = 'tra la la a ring a ding ding'
+    ActionTree::EvalScope.new(self).instance_eval do
+      @say
+    end.should == 'tra la la a ring a ding ding'
+  end
+
+  it 'extends modules' do
+    module Hooga
+      def words_of_wisdom
+        'touch my tra la la my ding ding dong'
+      end
+    end
+    ActionTree::EvalScope.new(Hooga).words_of_wisdom.should ==
+      'touch my tra la la my ding ding dong'
+  end
+
+  it 'overwrites sooner with later extensions' do
+    prepare = Proc.new  { @greeting = 'Hello' }
+    greet =   Proc.new  { "#{@greeting} #{get_name}" }
+    module Booga
+      def get_name
+        'Melchior'
+      end
+    end
+    module Shooga
+      def get_name
+        'Baltazar'
+      end
+    end
+    scope = ActionTree::EvalScope.new(Booga, Shooga, self)
+    scope.instance_eval(&prepare)
+    scope.instance_eval(&greet).should == 'Hello Baltazar'
+  end
+end

data/spec/02_node_spec.rb

@@ -0,0 +1,149 @@
+
+require 'action_tree'
+
+describe ActionTree::Basic::Node do
+
+  
+  # PATH PARSING AND DESCENDING
+
+  describe 'descend' do
+    it 'returns self when descending to nil, "", "/" or []' do
+      [nil, '', '/', []].each do |location|
+        subject.descend(location).should == subject
+      end
+    end
+
+    it 'returns a new node when descending one level' do
+      n = subject.descend('/the')
+      n.should be_a(ActionTree::Basic::Node)
+      n.should_not == subject
+    end
+
+    it 'returns a new node when descending two levels' do
+      n = subject.descend('/the/world')
+      n.should be_a(ActionTree::Basic::Node)
+      n.should_not == subject
+      n.should_not == subject.descend('/the')
+    end
+
+    it 'gives same node when descending two times, one level' do
+      subject.descend('/the').should == subject.descend('/the')
+    end
+
+    it 'gives same node when descending two times, three levels' do
+      subject.descend('/the/world/is').should == subject.descend('/the/world/is')
+    end
+
+    it 'gives birth recursively and selectively when descending' do
+       n = subject.descend('/the/world/is/good')
+       n.token.should == 'good'
+       n.should == subject.descend('the').descend('world/is').descend('good')
+    end
+  end
+
+  
+
+  # TOKEN DIFFERENTIATION
+
+  describe 'with string token' do
+    subject { ActionTree::Basic::Node.new('noodles') }
+
+    it 'matches the same token' do
+      subject.match?('noodles').should be_true
+    end
+
+    it 'does not match another token' do
+      subject.match?('naddles').should be_false
+    end
+
+    it 'names no captures' do
+      subject.capture_names.should == []
+    end
+
+  end
+
+  describe 'with string token with four/five captures' do
+    subject do
+      ActionTree::Basic::Node.new(':year-:month-:day-:word-and-:word')
+    end
+
+    it 'matches a valid match' do
+      subject.match?('2007-08-20-widgets-and-gadgets').should be_true
+    end
+
+    it 'does not match invalid match' do
+      subject.match?('2007-08-20-widgets-gadgets').should be_false
+    end
+
+    it 'names the four captures' do
+      subject.capture_names.should == %w{year month day word word}
+    end
+
+  end
+
+  describe 'with regexp capture' do
+    subject { ActionTree::Basic::Node.new(/[0-9]+\.[0-9]+/) }
+
+    it 'matches the same token' do
+      subject.match?('65.2').should be_true
+    end
+
+    it 'does not match another token' do
+      subject.match?('beef').should be_false
+      subject.match?('abba.beatles').should be_false
+    end
+
+    it 'captures to "match"' do
+      subject.capture_names.should == ['match']
+    end
+
+  end
+
+  describe 'with grouped regexp capture' do
+    subject { ActionTree::Basic::Node.new(/([0-9]+)\.([0-9]+)/) }
+
+    it 'matches the same token' do
+      subject.match?('65.2').should be_true
+    end
+
+    it 'does not match another token' do
+      subject.match?('beef').should be_false
+      subject.match?('abba.beatles').should be_false
+    end
+
+    it 'captures to "match"' do
+      subject.capture_names.should == ['match']
+    end
+
+  end
+
+
+  describe 'with symbol capture' do
+    subject { ActionTree::Basic::Node.new(:hometown) }
+
+    it 'matches any word' do
+      %w{Osaka Oslo Baden-Baden}.each do |town|
+        subject.match?(town).should be_true
+      end
+    end
+
+    it 'names the capture' do
+      subject.capture_names.should == ['hometown']
+    end
+
+  end
+
+  describe 'dsl' do
+    it 'mounts' do
+      pending
+    end
+
+    it 'defines helpers' do
+      subject.helpers { def guru; 'Ramana'; end }
+      o = Object.new
+      o.extend(subject.helper_scope)
+      o.guru.should == 'Ramana'
+    end
+  end
+
+end

data/spec/03_match_spec.rb

@@ -0,0 +1,120 @@
+
+
+require 'action_tree'
+
+
+
+
+describe ActionTree::Basic::Match do
+
+  describe 'captures' do
+
+    subject do
+      ActionTree.new do
+        r :genus do
+          a { @genus }
+          r ':species-:subspecies' do
+            a { "#{@genus} #{@species} #{@subspecies}" }
+          end
+        end
+      end
+    end
+
+    it 'no values when no match' do
+      subject.match('/one/two/three/bobsleigh').run.should be_nil
+    end
+
+    it 'one value' do
+      subject.match('/Homo').run.should == 'Homo'
+    end
+
+    it 'values and GET variables' do
+      subject.match('/Homo/Sapiens-Sapiens').run.should ==
+        'Homo Sapiens Sapiens'
+    end
+  end
+
+
+
+
+
+
+
+
+  describe 'universe integration test' do
+
+    subject do
+      ActionTree::Basic::Node.new do
+        before { @altitude = :astronomical }
+        after { @boring = false }
+        action { "no sound at #{@altitude} altitudes" }
+        helpers { def infinite?; true; end }
+        not_found { 'nix nada zip' }
+        route :world do
+          before { @status = :threatened }
+          helpers { def infinite?; false; end }
+          route :continent do
+            before { @order = 'political' }
+            route :country do
+              before { @context = 'national' }
+              after { @context = 'life' }
+              helpers { def violent?; false; end }
+              action('show') { 'not much to see' }
+              route :municipality do
+                before { @boring = true }
+                helpers { def boring?; true; end }
+                action { [@world, @continent, @country, @municipality] if boring? }
+              end
+            end
+          end
+        end
+      end
+    end
+
+    it 'runs root action witin same scope as root before filter' do
+      subject.match('/').run.should == 'no sound at astronomical altitudes'
+    end
+
+    it 'allows overwriting root actions' do
+      subject.action { 'Zarathustra' }
+      subject.match('').run.should == 'Zarathustra'
+    end
+
+    it 'root has access to root helper' do
+      subject.action { "Infinite!" if infinite? }
+      subject.match('/').run.should == 'Infinite!'
+    end
+
+    it 'root invokes root not found' do
+      subject.match('/earth/europe/norway/akershus/super-cheese').run.should == 'nix nada zip'
+    end
+
+    it 'sets instance variables from captures' do
+      subject.match('/earth/europe/norway/akershus').run.should ==
+        %w{earth europe norway akershus}
+    end
+
+    # self
+
+
+
+
+
+    # inherited
+    
+    it 'runs ancestors before filters' do
+    end
+
+    it 'runs ancestors after filters' do
+    end
+
+    it 'has access to ancestors helpers' do
+    end
+
+    it 'invokes ancestors not_found handler' do
+    end
+  end
+
+end
+
+

data/spec/04_integration_spec.rb

@@ -0,0 +1,140 @@
+
+require 'action_tree'
+require 'fileutils'
+
+
+
+describe ActionTree do
+
+  describe 'integration' do
+    
+    subject do
+      ActionTree.new do
+        helpers { def h1; 'bob';  end }
+        helpers { def h1; '1';    end }
+        helpers { def h2; h1;     end }
+        helpers { def h4; '6';    end }
+        before { @v = h2 + '2' }
+        before { @v = @v + '3' }
+        before { @v2 = 'sleigh' }
+        a { @v }
+        helpers('/a') {def h3; @v2; end}
+        before('/a') { @v2 = '4' }
+        before('/a') { @v3 = @v + h3 }
+        a('/a') { @v3 }
+        before('/a/b') { @v4 = @v3 + '5' }
+        before('/a/b') { @v5 = @v4 }
+        a('/a/b') { @v5 }
+        not_found('a/b') { @v5 + h4 }
+      end
+    end
+
+    it 'works, if only just a bit' do
+      subject.match('/').run.should == '123'
+    end
+
+    it 'works' do
+      subject.match('a/b').run.should == '12345'
+    end
+
+    it 'works with not_found' do
+      subject.match('a/b/y').run.should ==
+        '123456'
+    end
+  end
+
+
+
+
+  describe 'integration scenario' do
+  
+    subject do
+
+      ActionTree.new do
+        before { @msg = 'root hook ok' }
+        with('houses') do
+          action { 'house index' }
+          action('create') {'newly built house'}
+          with(:id) do
+            action { "showing house #{@id}" }
+            action('edit') { "editing house #{@id}" }
+            action('destroy') { "destroying house #{@id}" }
+            action(/[0-9]+/) {'number match'}
+          end
+        end
+        before('houses/:id') { @msg = 'house hook ok' }
+        action('long/action/weird/url') { 'long' }
+        action(/[0-9]+/) { 'root number match' }
+      end
+
+
+    end
+
+
+    it 'matches "" => self' do
+      subject.match('').node.should == subject
+    end
+
+    it 'matches "/" => self' do
+      subject.match('/').node.should == subject
+    end
+
+    it 'returns nil for nonexistant level one node' do
+      subject.match('/nothing').found?.should be_false
+    end
+
+    it 'returns nil for nonexistant level two node' do
+      subject.match('/long/nothing').found?.should be_false
+    end
+
+    it 'matches a first level request' do
+      subject.match('/houses').node.should == subject.descend('houses')
+    end
+
+    it 'matches a second level request' do
+      subject.match('/houses/create').node.should == subject.descend('houses/create')
+    end
+
+    it 'matches a second level capture' do
+      subject.match('/houses/4').node.should == subject.descend('houses/:id')
+    end
+
+    it 'matches beneath second level capture' do
+      subject.match('/houses/4/edit').node.should == subject.descend('houses/:id/edit')
+    end
+
+    it 'returns nil for nonexistant node beneath capture' do
+      subject.match('/houses/4/nothing_here').found?.should be_false
+    end
+
+    it 'gets the path right' do
+      subject.match('/long/action/weird/url').path.should == '/long/action/weird/url'
+    end
+
+    it 'gets the path right with captures' do
+      subject.match('/houses/53/edit').path.should == '/houses/53/edit'
+    end
+
+    it 'ignores trailing slashes' do
+      subject.match('/long/action').node.should ==
+        subject.match('long/action/').node
+    end
+
+    it 'matches regexp in root scope' do
+      subject.match('/346').node.should == subject.descend([/[0-9]+/])
+    end
+
+    it 'fills in path for regexp in root scope' do
+      subject.match('/346').path.should == '/346'
+    end
+
+    it 'matches regexp in capture scope' do
+      subject.match('/houses/5/4').node.should == subject.descend(['houses', :id, /[0-9]+/])
+    end
+
+    it 'fills in path for regexp in capture scope' do
+      subject.match('/houses/5/4').path.should == '/houses/5/4'
+    end
+  end
+
+end