volt 0.8.27.beta3 → 0.8.27.beta4

data/spec/models/validators/phone_number_validator_spec.rb

@@ -1,146 +1,103 @@
 require 'spec_helper'
+require 'models/validators/shared_examples_for_validators'
 
 describe Volt::PhoneNumberValidator do
-  subject { Volt::PhoneNumberValidator.new(*params) }
-  let(:params) { [model, field_name, options] }
+  subject { described_class.new(*init_params) }
+  let(:init_params) { [model, field_name] }
 
   let(:model) { Volt::Model.new phone_number: phone_number }
   let(:field_name) { :phone_number }
   let(:options) { true }
 
+  let(:phone_number) { field_content }
+  let(:field_contet) { valid_us_number }
   let(:valid_us_number) { '(123)-123-1234' }
   let(:valid_intl_number) { '+12 123 123 1234' }
   let(:invalid_number) { '1234-123-123456' }
-  let(:phone_number) { valid_us_number }
-
-  describe '.validate' do
-    let(:result) { described_class.validate(*params.dup.insert(1, nil)) }
-
-    before do
-      allow(described_class).to receive(:new).and_return subject
-      allow(subject).to receive(:errors).and_call_original
 
-      result
-    end
-
-    it 'initializes a phone number validator with the provided arguments' do
-      expect(described_class).to have_received(:new).with(*params)
-    end
+  let(:validate) { described_class.validate(*params) }
+  let(:params) { [model, field_name, options] }
+  let(:message) { 'must be a phone number with area or country code' }
 
-    it 'calls errors on the phone number validator' do
-      expect(subject).to have_received :errors
-    end
+  it_behaves_like 'a format validator'
 
-    it 'returns the result of calling errors on the validator' do
-      expect(subject.errors).to eq result
-    end
+  before do
+    allow(described_class).to receive(:new).and_return subject
   end
 
-  describe '#valid?' do
-    context 'when using the default regex' do
-      let(:options) { true }
-
-      context 'when the phone number is a valid US number' do
-        let(:phone_number) { valid_us_number }
-
-        specify { expect(subject.valid?).to eq true }
-      end
-
-      context 'when the phone number is a valid international number' do
-        let(:phone_number) { valid_intl_number }
-
-        specify { expect(subject.valid?).to eq true }
-      end
-
-      context 'when the phone number uses dashes' do
-        let(:phone_number) { '123-123-1234' }
+  context 'when the phone number is a valid US number' do
+    let(:phone_number) { valid_us_number }
 
-        specify { expect(subject.valid?).to eq true }
-      end
+    specify { expect(validate).to eq({}) }
 
-      context 'when the phone number uses periods' do
-        let(:phone_number) { '123.123.1234' }
+    context 'and when no override criteria is provided' do
+      before { validate }
 
-        specify { expect(subject.valid?).to eq true }
+      it 'should have no errors' do
+        expect(subject.errors).to eq({})
       end
 
-      context 'when the phone number uses spaces' do
-        let(:phone_number) { '123 123 1234' }
+      specify { expect(subject).to be_valid }
+    end
+  end
 
-        specify { expect(subject.valid?).to eq true }
-      end
+  context 'when the model has an invalid phone number' do
+    let(:phone_number) { invalid_number }
 
-      context 'when the phone number uses parentheses and a space' do
-        let(:phone_number) { '(123) 123.1234' }
+    context 'and when no override criteria is provided' do
+      before { validate }
 
-        specify { expect(subject.valid?).to eq true }
+      it 'returns an array of errors for phone number' do
+        expect(subject.errors).to eq field_name => [message]
       end
+    end
+  end
 
-      context 'when an international number uses a plus' do
-        let(:phone_number) { '+12 123 123 1234' }
-
-        specify { expect(subject.valid?).to eq true }
-      end
+  context 'when the phone number is a valid international number' do
+    let(:phone_number) { valid_intl_number }
 
-      context 'when an international number does not use a plus' do
-        let(:phone_number) { '12 123 123 1234' }
+    specify { expect(subject.valid?).to eq true }
+  end
 
-        specify { expect(subject.valid?).to eq true }
-      end
+  context 'when the phone number uses dashes' do
+    let(:phone_number) { '123-123-1234' }
 
-      context 'when an international number is from the UK' do
-        let(:phone_number) { '+12 123 1234 1234' }
+    specify { expect(subject.valid?).to eq true }
+  end
 
-        specify { expect(subject.valid?).to eq true }
-      end
-    end
+  context 'when the phone number uses periods' do
+    let(:phone_number) { '123.123.1234' }
 
-    context 'when using a custom regex' do
-      let(:options) { { with: /\d{10}/ } }
+    specify { expect(subject.valid?).to eq true }
+  end
 
-      context 'and the phone number qualifies' do
-        let(:phone_number) { '1231231234' }
+  context 'when the phone number uses spaces' do
+    let(:phone_number) { '123 123 1234' }
 
-        specify { expect(subject.valid?).to eq true }
-      end
+    specify { expect(subject.valid?).to eq true }
+  end
 
-      context 'and the phone number does not qualify' do
-        let(:phone_number) { '123-123-1234' }
+  context 'when the phone number uses parentheses and a space' do
+    let(:phone_number) { '(123) 123.1234' }
 
-        specify { expect(subject.valid?).to eq false }
-      end
-    end
+    specify { expect(subject.valid?).to eq true }
   end
 
-  describe '#errors' do
-    context 'when the model has a valid phone number' do
-      let(:phone_number) { valid_us_number }
+  context 'when an international number uses a plus' do
+    let(:phone_number) { '+12 123 123 1234' }
 
-      it 'returns an empty error hash' do
-        expect(subject.errors).to eq({})
-      end
-    end
+    specify { expect(subject.valid?).to eq true }
+  end
 
-    context 'when the model has an invalid phone number' do
-      let(:phone_number) { invalid_number }
+  context 'when an international number does not use a plus' do
+    let(:phone_number) { '12 123 123 1234' }
 
-      it 'returns an array of errors for phone number' do
-        expect(subject.errors).to eq(
-          phone_number: ['must be a phone number with area or country code'])
-      end
-    end
-
-    context 'when provided a custom error message' do
-      let(:options) { { message: custom_message } }
-      let(:custom_message) { 'this is a custom message' }
+    specify { expect(subject.valid?).to eq true }
+  end
 
-      context 'and the phone number is invalid' do
-        let(:phone_number) { invalid_number }
+  context 'when an international number is from the UK' do
+    let(:phone_number) { '+12 123 1234 1234' }
 
-        it 'returns errors with the custom message' do
-          expect(subject.errors).to eq(phone_number: [custom_message])
-        end
-      end
-    end
+    specify { expect(subject.valid?).to eq true }
   end
-end
+end

data/spec/models/validators/shared_examples_for_validators.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+shared_examples_for 'a format validator' do
+  let(:regex) { /^valid/ }
+  let(:proc_regex) { /^valid/ }
+  let(:test_proc) { ->(content) { proc_regex.match content } }
+
+  let(:proc_opts) { { with: test_proc, message: proc_message } }
+  let(:regex_opts) { { with: regex, message: regex_message } }
+
+  let(:field_content) { valid_content }
+  let(:invalid_content) { 'invalid_content' }
+  let(:valid_content) { 'valid_content' }
+
+  let(:proc_message) { 'proc is invalid' }
+  let(:regex_message) { 'regex is invalid' }
+
+  before do
+    allow(described_class).to receive(:new).and_return subject
+  end
+
+  context 'when the only override criterion is a regex' do
+    let(:options) { regex_opts }
+
+    before { validate }
+
+    context 'and when the field matches' do
+      let(:field_content) { valid_content }
+
+      it 'should have no errors' do
+        expect(subject.errors).to eq({})
+      end
+
+      specify { expect(subject).to be_valid }
+    end
+
+    context 'and when the field does not match' do
+      let(:field_content) { invalid_content }
+
+      it 'should report the related error message' do
+        expect(subject.errors).to eq field_name => [regex_message]
+      end
+
+      specify { expect(subject).to_not be_valid }
+    end
+  end
+
+  context 'when the only override criterion is a block' do
+    let(:options) { proc_opts }
+
+    before { validate }
+
+    context 'and when the field passes the block' do
+      let(:field_content) { valid_content }
+
+      it 'should have no errors' do
+        expect(subject.errors).to eq({})
+      end
+
+      specify { expect(subject).to be_valid }
+    end
+
+    context 'and when the field fails the block' do
+      let(:field_content) { invalid_content }
+
+      it 'should report the related error message' do
+        expect(subject.errors).to eq field_name => [proc_message]
+      end
+
+      specify { expect(subject).to_not be_valid }
+    end
+  end
+
+  context 'when there is both regex and block criteria' do
+    let(:options) { [ regex_opts, proc_opts ] }
+
+    before { validate }
+
+    context 'and when the field passes all criteria' do
+      let(:field_content) { valid_content }
+
+      it 'should have no errors' do
+        expect(subject.errors).to eq({})
+      end
+
+      specify { expect(subject).to be_valid }
+    end
+
+    context 'and when the field fails the regex' do
+      let(:regex) { /^invalid/ }
+
+      it 'should report the related error message' do
+        expect(subject.errors).to eq field_name => [regex_message]
+      end
+
+      specify { expect(subject).to_not be_valid }
+    end
+
+    context 'and when the field fails the block' do
+      let(:proc_regex) { /^invalid/ }
+
+      it 'should report the related error message' do
+        expect(subject.errors).to eq field_name => [proc_message]
+      end
+
+      specify { expect(subject).to_not be_valid }
+    end
+
+    context 'and when the field fails both the regex and the block' do
+      let(:field_content) { invalid_content }
+
+      it 'should report the regex error message' do
+        expect(subject.errors[field_name]).to include regex_message
+      end
+
+      it 'should report the proc error message' do
+        expect(subject.errors[field_name]).to include proc_message
+      end
+
+      specify { expect(subject).to_not be_valid }
+    end
+  end
+end

data/spec/reactive/class_eventable_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+class TestClassEventable
+  include Volt::ClassEventable
+
+  attr_reader :run_count
+
+  def initialize
+    @run_count = 0
+  end
+
+  on(:works) do
+    ran_works
+  end
+
+  def ran_works
+    @run_count += 1
+  end
+
+  def trigger_works_event!
+    trigger!(:works, 20)
+  end
+end
+
+describe Volt::ClassEventable do
+  it 'does something' do
+    test_ev = TestClassEventable.new
+
+    expect(test_ev.run_count).to eq(0)
+    test_ev.trigger_works_event!
+
+    expect(test_ev.run_count).to eq(1)
+    test_ev.trigger_works_event!
+
+    expect(test_ev.run_count).to eq(2)
+  end
+end

data/spec/reactive/computation_spec.rb

@@ -38,6 +38,57 @@ describe Volt::Computation do
     expect(values).to eq([nil, 'one'])
   end
 
+  it 'should watch_until! a value matches' do
+    a = Volt::ReactiveHash.new
+
+    a[:b] = 5
+
+    count = 0
+    -> do
+      a[:b]
+    end.watch_until!(10) do
+      count += 1
+    end
+
+    expect(count).to eq(0)
+
+    a[:b] = 7
+    Volt::Computation.flush!
+    expect(count).to eq(0)
+
+    a[:b] = 10
+    Volt::Computation.flush!
+    expect(count).to eq(1)
+
+    # Should only trigger once
+    a[:b] = 5
+    Volt::Computation.flush!
+    expect(count).to eq(1)
+
+    a[:b] = 10
+    Volt::Computation.flush!
+    expect(count).to eq(1)
+  end
+
+  it 'should trigger a changed dependency only once on a flush' do
+    a = Volt::Dependency.new
+
+    count = 0
+    -> { count += 1 ; a.depend }.watch!
+
+    expect(count).to eq(1)
+
+    a.changed!
+    a.changed!
+    a.changed!
+
+    expect(count).to eq(1)
+
+    Volt::Computation.flush!
+
+    expect(count).to eq(2)
+  end
+
   it 'should support nested watches' do
     a = Volt::ReactiveHash.new
 
@@ -61,6 +112,20 @@ describe Volt::Computation do
     expect(values).to eq([nil, nil, 'inner', 'outer', 'inner'])
   end
 
+  describe "watch_and_resolve!" do
+    it 'should resolve any returnted promises' do
+      promise = Promise.new.resolve('resolved')
+      count = 0
+
+      -> { promise }.watch_and_resolve! do |result|
+        expect(result).to eq('resolved')
+        count += 1
+      end
+
+      expect(count).to eq(1)
+    end
+  end
+
   # Currently Class#class_variable_set/get isn't in opal
   # https://github.com/opal/opal/issues/677
   unless RUBY_PLATFORM == 'opal'
@@ -72,7 +137,7 @@ describe Volt::Computation do
       Volt::Computation.class_variable_set :@@flush_queue, []
     end
 
-    context 'when stopped' do
+    describe 'when stopped' do
       before(:each) { computation.instance_variable_set :@stopped, true }
 
       it "doesn't add self to flush queue" do
@@ -82,7 +147,7 @@ describe Volt::Computation do
       end
     end
 
-    context 'when computing' do
+    describe 'when computing' do
       before(:each) { computation.instance_variable_set :@computing, true }
 
       it "doesn't add self to flush queue" do
@@ -92,7 +157,7 @@ describe Volt::Computation do
       end
     end
 
-    context 'when not stopped and not computing' do
+    describe 'when not stopped and not computing' do
       before(:each) do
         computation.instance_variable_set :@stopped,   false
         computation.instance_variable_set :@computing, false

data/spec/reactive/dependency_spec.rb

@@ -1,4 +1,75 @@
 require 'spec_helper'
 
 describe Volt::Dependency do
+  it 'should trigger on_dep and on_stop_dep when setup and torn down' do
+    dep_count = 0
+    stop_dep_count = 0
+    dep = Volt::Dependency.new(-> { dep_count += 1 }, -> { stop_dep_count += 1 })
+
+    expect(dep_count).to eq(0)
+    expect(stop_dep_count).to eq(0)
+
+    a = -> { dep.depend }.watch!
+    b = -> { dep.depend }.watch!
+
+    expect(dep_count).to eq(1)
+    expect(stop_dep_count).to eq(0)
+
+    a.stop
+    expect(dep_count).to eq(1)
+    expect(stop_dep_count).to eq(0)
+
+    b.stop
+    expect(dep_count).to eq(1)
+    expect(stop_dep_count).to eq(1)
+
+    # Make sure it triggers if we watch again
+    c = -> { dep.depend }.watch!
+    d = -> { dep.depend }.watch!
+
+    expect(dep_count).to eq(2)
+    expect(stop_dep_count).to eq(1)
+
+    c.stop
+    expect(dep_count).to eq(2)
+    expect(stop_dep_count).to eq(1)
+
+    d.stop
+    expect(dep_count).to eq(2)
+    expect(stop_dep_count).to eq(2)
+  end
+
+  it 'should trigger on_dep and on_stop_dep when changed and setup again' do
+    dep_count = 0
+    stop_dep_count = 0
+    dep = Volt::Dependency.new(-> { dep_count += 1 }, -> { stop_dep_count += 1 })
+
+    expect(dep_count).to eq(0)
+    expect(stop_dep_count).to eq(0)
+
+    a = -> { dep.depend }.watch!
+    b = -> { dep.depend }.watch!
+
+    expect(dep_count).to eq(1)
+    expect(stop_dep_count).to eq(0)
+
+    dep.changed!
+    expect(dep_count).to eq(1)
+    expect(stop_dep_count).to eq(1)
+
+    # Make sure it triggers if we watch again
+    c = -> { dep.depend }.watch!
+    d = -> { dep.depend }.watch!
+
+    expect(dep_count).to eq(2)
+    expect(stop_dep_count).to eq(1)
+
+    c.stop
+    expect(dep_count).to eq(2)
+    expect(stop_dep_count).to eq(1)
+
+    d.stop
+    expect(dep_count).to eq(2)
+    expect(stop_dep_count).to eq(2)
+  end
 end

data/spec/reactive/eventable_spec.rb

@@ -45,4 +45,25 @@ describe Volt::Eventable do
     test_eventable.trigger_works_event!
     expect(count).to eq(2)
   end
+
+  it 'should allow multiple events' do
+    test_eventable = TestEventable.new
+
+    called = false
+    listener = test_eventable.on(:broken, :works) do |arg|
+      expect(arg).to eq(20)
+      called = true
+    end
+
+    test_eventable.trigger_works_event!
+    expect(called).to eq(true)
+
+    # Stop the listener
+    listener.remove
+    called = false
+
+    # Shouldn't run now
+    test_eventable.trigger_works_event!
+    expect(called).to eq(false)
+  end
 end

data/spec/reactive/reactive_hash_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Volt::ReactiveHash do
+  it 'should clear' do
+    a = Volt::ReactiveHash.new
+    a[:name] = 'Bob'
+
+    expect(a[:name]).to eq('Bob')
+    a.clear
+    expect(a[:name]).to eq(nil)
+  end
+end