lanes 0.1.6 → 0.1.7

data/lib/lanes/concerns/pub_sub.rb

@@ -1,15 +1,5 @@
 module Lanes::Concerns
 
-    module PendingEventListeners
-        # @private
-        @@listeners = Hash.new{ |hash, klass| hash[klass] = Hash.new{ |kh, event| kh[event]=Array.new } }
-        # @api private
-        def self.all
-            @@listeners
-        end
-    end
-
-
     # Event subscription and publishing for Stockor Models
     # Every model has certain built-in events (:save, :create, :update, :destroy)
     # And may also implement custom events that reflect the models domain
@@ -24,6 +14,33 @@ module Lanes::Concerns
     module PubSub
         extend ActiveSupport::Concern
 
+
+        module PendingListeners
+            # @private
+            @@listeners = Hash.new{ |hash, klass|
+                hash[klass] = Hash.new{ |kh, event|
+                    kh[event]=Array.new
+                }
+            }
+            class << self
+
+                # @api private
+                def claim(class_name)
+                    if @@listeners.has_key?(class_name)
+                        return @@listeners.delete(class_name)
+                    else
+                        return {}
+                    end
+                end
+
+                # @api private
+                def add(class_name)
+                    @@listeners[class_name]
+                end
+            end
+        end
+
+
         class InvalidEvent < RuntimeError
         end
 
@@ -31,35 +48,41 @@ module Lanes::Concerns
 
             class_attribute :valid_event_names
             class_attribute :_event_listeners
-            self.valid_event_names = [ :save, :create, :update, :destroy ]
+            base.valid_event_names = [ :save, :create, :update, :destroy ]
 
-            after_save    :fire_after_save_events
-            after_create  :fire_after_create_events
-            after_update  :fire_after_update_events
-            after_destroy :fire_after_destroy_events
+            base.after_save    :fire_after_save_events
+            base.after_create  :fire_after_create_events
+            base.after_update  :fire_after_update_events
+            base.after_destroy :fire_after_destroy_events
         end
 
         module ClassMethods
             def inherited(base)
                 super
                 klass = base.to_s.demodulize
-                if PendingEventListeners.all.has_key?( klass )
-                    events = PendingEventListeners.all.delete(klass)
-                    events.each{ | name, procs | base.event_listeners[name] += procs  }
-                end
-            end
 
-            def event_listeners
-             self._event_listeners ||= Hash.new{ |hash, key| hash[key]=Array.new }
-            end
+                #p klass
+                # if klass=="Tester"
+                #     binding.pry
+                # end
+                events = PubSub::PendingListeners.claim( klass )
+                events.each{ | name, procs | base.event_listeners[name] += procs  }
 
-            def _add_event_listener( name, proc )
-                self.event_listeners[name].push( proc ) unless self.event_listeners[name].include?(proc)
             end
 
             def observe( event, &block )
                 _ensure_validate_event( event )
-                _add_event_listener( event.to_sym, block )
+                _add_event_listener( event.to_sym, &block )
+            end
+
+            private
+
+            def _add_event_listener(name, &block)
+                self._event_listeners ||= Hash.new{ |hash, key| hash[key]=Array.new }
+                listeners = self._event_listeners[name].dup
+                listeners << block
+                self._event_listeners = self._event_listeners.dup
+                self._event_listeners[name] = listeners
             end
 
             def _ensure_validate_event(event)
@@ -68,14 +91,13 @@ module Lanes::Concerns
                 end
             end
 
-            protected
-
             def has_additional_events( *names )
                 self.valid_event_names += names.map{ |name| name.to_sym }
             end
         end
 
         protected
+
         def fire_after_destroy_events
             _fire_event(:update, self )
         end
@@ -96,9 +118,12 @@ module Lanes::Concerns
         end
 
         private
+
         def _fire_event( name, *arguments )
-            self.class.event_listeners[ name.to_sym ].each{ | block | block.call(*arguments) }
-            return true
+            return if self.class._event_listeners.nil? ||
+                           !self.class._event_listeners.has_key?(name.to_sym)
+
+            self.class._event_listeners[ name.to_sym ].each{ | block | block.call(*arguments) }
         end
     end
 

data/lib/lanes/guard_tasks.rb

@@ -26,15 +26,19 @@ module Lanes
                 spec_dir: "spec/#{app_name}", console: :always, debug: false
             })
 
+            minitest_options = {
+              all_on_start: true, test_folders: 'spec/server'
+            }
+
             dsl.guard :jasmine, jasmine_options do
                 dsl.watch(%r{^client/(.+?)\.(js|coffee)$}){ |m| "spec/#{m[1]}Spec.#{m[2]}" }
                 dsl.watch(%r{^spec/.*(?:_s|S)pec\.coffee$})
                 matchers.client_matches.call if matchers.client_matches
             end
 
-            dsl.guard :minitest, :all_on_start => true do
-                dsl.watch(%r{^spec/spec_helper\.rb}) { 'test' }
-                dsl.watch(%r{^spec/.+_spec\.rb})
+            dsl.guard :minitest, minitest_options do
+                dsl.watch(%r{^spec/server/spec_helper\.rb}) { 'test' }
+                dsl.watch(%r{^spec/server/.+_spec\.rb})
                 dsl.watch(%r{^spec/fixtures/#{app_name}/(.+)s\.yml})   { |m| "spec/server/#{m[1]}_spec.rb" }
                 dsl.watch(%r{^lib/#{app_name}/(.+)\.rb})               { |m| "spec/server/#{m[1]}_spec.rb" }
                 matchers.server_matches.call if matchers.server_matches

data/lib/lanes/version.rb

@@ -1,5 +1,5 @@
 module Lanes
 
-    VERSION = "0.1.6"
+    VERSION = "0.1.7"
 
 end

data/{appy-app → spec/command-reference-files/initial}/Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
-gem "lanes", '0.1.5'
+gem "lanes", '0.1.6'
 
 gem "rake"
 gem 'puma'

data/spec/lanes/models/BaseSpec.coffee

@@ -12,12 +12,12 @@ describe "Lanes.Models.Base", ->
             props:
                 saved: 'string'
         }, {bar: 'baz'})
-        expect(model.isDirty()).toBe(false)
+        expect(model.isDirty).toBe(false)
         model.foo = 'baz' # session prop
-        expect(model.isDirty()).toBe(false)
+        expect(model.isDirty).toBe(false)
         expect(model.unsavedAttributes()).toBeEmptyObject()
         model.set( saved: 'true' )
-        expect(model.isDirty()).toBe(true)
+        expect(model.isDirty).toBe(true)
 
 
     it "can tell if it has attributes", ->
@@ -62,7 +62,7 @@ describe "Lanes.Models.Base", ->
                 bar: 'string'
 
         }, { foo: 'one, two, three'} )
-        expect(model.isDirty()).toBe(true)
+        expect(model.isDirty).toBe(true)
         expect(model.unsavedAttributes()).toEqual( foo: 'one, two, three' )
         model.save()
         expect(model.sync).toHaveBeenCalledWith('create', model, jasmine.any(Object))

data/spec/server/command_spec.rb

@@ -7,7 +7,7 @@ describe Lanes::Command do
     let(:app_name)  { "appy-app" }
     let(:lanes)     { Pathname.new(__FILE__).dirname.join('..','..','bin','lanes') }
     let(:generated_path) { Pathname.pwd }
-    let(:reference_path) { Pathname(__FILE__).dirname.join("command-reference-files") }
+    let(:reference_path) { Pathname(__FILE__).dirname.join("..","command-reference-files") }
 
     around do |test|
         Dir.mktmpdir do |dir|
@@ -34,6 +34,10 @@ describe Lanes::Command do
 
     it "generates an application" do
         reference = reference_path.join('initial')
+        gemfile = reference.join("Gemfile")
+        gemfile.write gemfile.read.gsub(/gem \"lanes\", \'\d+\.\d+\.\d+\'/, "gem \"lanes\", '#{Lanes::VERSION}'")
+
+
         compare_generated(reference)
         generated_path.find.each do | path |
             relative = path.relative_path_from(generated_path)

data/spec/server/concerns/association_extensions_spec.rb

@@ -11,14 +11,6 @@ class AssociationExtensionsTest < Lanes::TestCase
         assert_match( /does not have an inverse_of specified./, err.message )
     end
 
-    def test_adds_listener
-        Tmhm.belongs_to(:tm)
-        TestModel.has_one(:tmhm,:listen=>{:save=>:on_tmhm_save}, :inverse_of=>:tm)
-        tm = TestModel.new
-        tm.expects(:on_tmhm_save)
-        tm.build_tmhm
-        assert tm.save
-    end
 
     def test_exports_associations
         TestModel.expects(:export_associations).with(:tmhm,{})

data/spec/server/concerns/pub_sub_spec.rb

@@ -1,35 +1,79 @@
 require_relative "../spec_helper"
 
-class PubSubTest < Lanes::TestCase
+describe "PubSub" do
 
-    class EventTester
-        def self.after_save(*args);    end
-        def self.after_create(*args);  end
-        def self.after_update(*args);  end
-        def self.after_destroy(*args); end
+    include ActiveRecordMocks::IncludeMe
+    around do | test |
+        with_mocked_tables do |m|
+            m.create_table do |t|
+                t.model_name :Evbt
+                t.belongs_to :evhm, class_name: "Evhm", listen: { create: 'on_create_hm' },
+                             inverse_of: :evbt
+                t.layout do |l|
+                    l.integer :evhm_id
+                end
+                t.parent_class "Lanes::Model"
+            end
+            class Evbt
+                has_additional_events :test_one
+                def on_create_hm(*args)
+                    32
+                end
+            end
+
+            m.create_table do |t|
+                t.model_name :EventTester
+                t.parent_class "Lanes::Model"
+                t.belongs_to :evbt, class_name: 'Evhm'
+
+                t.has_many   :evhm, class_name: 'Evhm', inverse_of: :event_tester
+
+                t.layout do |l|
+                    l.integer :bt_id
+                    l.string :name, :number
+                end
+            end
+
+            table = m.create_table do |t|
+                t.model_name :Evhm
+                t.belongs_to :evbt, class_name: "Evbt", listen: { save: 'on_create_bt' },
+                             inverse_of: :evhm
+                t.belongs_to :event_tester, class_name: "EventTester", inverse_of: :evhm,
+                             listen: { save: 'on_save_event_tester' }
+                t.parent_class "Lanes::Model"
+                t.layout do | l |
+                    l.string :mumble
+                    l.integer :evbt_id, :event_tester_id
+                end
+            end
+            def table.on_save_event_tester(*args)
+            end
 
-        include Lanes::Concerns::PubSub
 
-        def trigger( event, *args )
-            fire_event(event, *args )
+
+            test.call
         end
     end
 
-    class Ev1 < EventTester
-        has_additional_events :test_one
-    end
+    it "listens to other associations" do
+        e=Evbt.new
+        assert_equal 32, e.on_create_hm
+        b=e.build_evhm
+        b.expects(:on_create_bt)
+        assert e.save
 
-    class Ev2 < EventTester
-        has_additional_events :test_two
+        et = EventTester.new
+        evh = et.evhm.build
+        evh.expects(:on_save_event_tester)
+        assert et.save
     end
 
-
-    def test_event_name_registration
+    it "registers" do
         assert_equal [ :save, :create, :update, :destroy ],EventTester.valid_event_names
-        assert_equal [ :save, :create, :update, :destroy, :test_one ],Ev1.valid_event_names
+        assert_equal [ :save, :create, :update, :destroy, :test_one ],Evbt.valid_event_names
     end
 
-    def test_only_valid
+    it "can only observe valid events" do
         assert_raises( EventTester::InvalidEvent) do
             EventTester.observe(:invalid_event) do | ev |
             end
@@ -37,45 +81,47 @@ class PubSubTest < Lanes::TestCase
         assert_raises( EventTester::InvalidEvent) do
             EventTester.observe(:save) do | ev |
             end
-            EventTester.new.trigger(:invalid_event)
+            EventTester.new.send(:fire_event,:invalid_event)
         end
         assert_raises( EventTester::InvalidEvent) do
-            Ev1.observe(:test_two) do | ev |
+            Evbt.observe(:test_two) do | ev |
             end
         end
         assert_raises( EventTester::InvalidEvent) do
-            Ev2.observe(:test_one) do | ev |
+            Evhm.observe(:test_one) do | ev |
             end
         end
         begin
-            Ev2.observe(:test_one) do | ev |
+            Evbt.observe(:test_one) do | ev |
             end
         rescue EventTester::InvalidEvent=>e
             assert_equal 'test_one is not a valid event for PubSubTest::Ev2', e.to_s
         end
     end
 
-    def test_subscription
+    it "events can be subscribed to" do
         EventTester.observe(:save) do | ev |
+
         end
     end
-    def test_firing
+
+    it "can be fired and observed" do
         results=[]
-        Ev1.observe(:test_one) do | ev, one, two |
+        Evbt.observe(:test_one) do | ev, one, two |
             results = [ ev, one, two ]
         end
-        evt=Ev1.new
-        evt.trigger( :test_one, 3, 5 )
+        evt=Evbt.new
+        evt.send(:fire_event, :test_one, 3, 5 )
         assert_equal [ evt, 3, 5 ], results
 
-        evt.trigger( :test_one, 'foo' )
+        evt.send(:fire_event, :test_one, 'foo' )
         assert_equal [ evt, 'foo', nil ], results
     end
 
 
-    def test_firing_with_assertsions
-        assert_event_fires( Ev1, :test_one ) do
-            Ev1.new.trigger( :test_one, 3, 5 )
+    it "can use custom event assertions" do
+        assert_event_fires( Evbt, :test_one ) do
+            Evbt.new.send(:fire_event, :test_one, 3, 5 )
         end
         assert_equal [ 3, 5 ], last_event_results[1..-1]
     end

data/spec/server/spec_helper.rb

@@ -4,6 +4,7 @@ require "active_record_mocks"
 
 require 'lanes/command'
 require 'lanes/workspace/extension'
+require 'mocha/mini_test'
 
 # ext = Extensions.controlling
 # if ext.is_a?(::Lanes::Extensions::Base)