autodeps 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a82a1eed613fef969c31d65598dfa94f222f79c
-  data.tar.gz: aba6eadbf53b938b03bfc5c1f8bc34f4fc886479
+  metadata.gz: 78d3bef272635791a3db6c22f57a91207ce38736
+  data.tar.gz: a749c7af7789588b1842ae39fccfe1f3de603569
 SHA512:
-  metadata.gz: f488ed931e63f8c34def7194d816f385f050e8405ea618d09ae67706218aa8fbfe7f5daea7bd02527cd7d57a4450b3552e60768c4b4152870bac1fafcdc09980
-  data.tar.gz: 86806e9a550bf0a6dbabc132d24eb84089cb219e9de0bba02d8a1b991ed8736f546f207af83f449bdd459dc33b72fcf81d485aff1f607d4d12188ba0eccc3bfa
+  metadata.gz: fb3fa0654c138919354941a09988bb8c2392f9da56e6fcca577fdb7334cc6a18d61998d18aeb68bc562be0d4bd2e23e7f377657194142226fea22c59231228d8
+  data.tar.gz: 511df559b1d3fefd0667bddcf7983c4859d3f3df55e42d8b21032e4b56e537cdbe7fd21ac60d5ddf8596961dc210103d1fcdc50cac7c30a0cbfd6853129aba12

data/Gemfile

@@ -2,3 +2,4 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in autodeps.gemspec
 gemspec
+

data/README.md

@@ -19,6 +19,90 @@ Or install it yourself as:
 ## Usage
 
 TODO: Write usage instructions here
+two parts
+1.ReactivePersistency
+2.ReactiveData
+
+ReactivePersistency is used in data storage layer, like you have an activerecord/mongomapper persistency layer,
+when some properties you want to copy to other table(denormalization), and want to be automatically synced when
+main table's property changes,
+then just include Autodeps::Persistency and call depend_on  method:
+like you have User table, and Laud table, where you copy user.name to Laud.user_name and Laud.dest_user_name
+```
+class Laud
+
+  include MongoMapper::Document
+  include Autodeps::Persistency #这里添加对Autodeps::Persistency 的依赖
+
+  key :user_id, Integer, :required => true
+  key :user_name, String
+  depend_on "User", :value_mapping => {:name => :user_name} #默认可以省略 :key_mapping=> {:id=>:user_id}
+
+  key :dest_user_id, Integer, :required => true
+  key :dest_user_name, String
+  depend_on "User", :key_mapping => {:id => :dest_user_id}, :value_mapping => {:name => :dest_user_name}
+
+  timestamps!
+
+  ensure_index([[:user_id,1],[:dest_user_id,1]])
+end
+```
+then when you change user's name
+```
+user.name = "some value"
+user.save
+```
+the name change will automatically propagated to Laud table/collection.
+
+because in development environment, when User loads, the Laud class may not been loaded, so you may want to
+do this:
+#user.rb
+class User
+  #some attributes
+end
+Laud #just adds a reference here to cause rails to load Laud
+
+2.ReactiveData
+what ReactiveData means, if you want to say a=b+c
+if b or c is ReactiveData, then when b or c's value changes,
+a's value automatically changes,it's the concept copyed from meteor:)
+
+see autodeps_test.rb
+where a,b is ReactiveData
+
+  def test_reactive_integer
+    a = Autodeps::ReactiveData.new(3)
+    b = nil
+    computation = Autodeps.autorun do |computation| #the block will be rerun if a changes
+      b = a.value
+    end
+    assert_equal b,3
+
+    a.change_to 5
+
+    assert_equal b,5
+  end
+
+  def test_reactive_integer_add
+    a = Autodeps::ReactiveData.new(3)
+    b = Autodeps::ReactiveData.new(5)
+    c = nil
+    computation = Autodeps.autorun do |computation| #the block will be rerun if a or b changes
+      c = a.value + b.value
+    end
+    assert_equal c,8
+
+    a.change_to 5
+
+    assert_equal c,10
+
+    b.change_to 15
+
+    assert_equal c,20
+  end
+
+
+
 
 ## Contributing
 

data/autodeps.gemspec

@@ -20,4 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency "thread_safe"
 end

data/lib/autodeps.rb

@@ -4,6 +4,7 @@ module Autodeps
   # Your code goes here...
 end
 
+require 'thread_safe'
 require "autodeps/autodeps"
 require "autodeps/computation"
 require "autodeps/dependency"

data/lib/autodeps/autodeps.rb

@@ -1,8 +1,13 @@
+require 'logger'
 module Autodeps
-  @pending_computations = []
-  @after_flush_callbacks = []
+  class << self
+    attr_accessor :logger
+  end
+  self.logger = Logger.new(STDOUT)
+  @pending_computations = ThreadSafe::Array.new
+  @after_flush_callbacks = ThreadSafe::Array.new
   @constructingComputation = false
-  @active = false
+
 
   class << self
     attr_accessor :active
@@ -16,9 +21,26 @@ module Autodeps
       @constructingComputation = true
       c = Computation.new(block, Autodeps.current_computation);
 
+
+      if (Autodeps.active)
+        Autodeps.on_invalidate do
+          c.stop();
+        end
+      end
+
       return c
     end
 
+    def nonreactive(&f)
+      previous = self.current_computation;
+      self.current_computation = nil;
+      begin
+        f.call()
+      ensure
+        self.current_computation = previous;
+      end
+    end
+
     def flush
 
       #if (inFlush)
@@ -59,10 +81,125 @@ module Autodeps
 
     end
 
+    def on_invalidate(&f)
+      if (! Autodeps.active)
+        raise "AutoDeps.on_invalidate requires a currentComputation"
+      end
+
+        Autodeps.current_computation.on_invalidate(f);
+    end
+
+    def afterFlush(&f)
+      @after_flush_callbacks.push(f);
+    end
+
+    def isolateValue(equals=nil, &f)
+      raise "must define a block in isolateValue" unless f
+      if (!Autodeps.active)
+        return f.call();
+      end
+
+      result_dep = Autodeps::Dependency.new;
+      orig_result = nil
+      Autodeps.autorun do |c|
+        result = f.call();
+        if (c.first_run)
+          orig_result = result;
+        elsif (!(equals ? equals(result, orig_result) :
+            result == orig_result))
+          result_dep.changed();
+        end
+      end
+      result_dep.depend();
+
+      return orig_result;
+    end
+
+    def embox(equals=nil, &func)
+      raise "must define a block in embox" unless func
+
+
+      curResult = nil;
+      #There's one shared Dependency and Computation for all callers of
+
+      # our box function.  It gets kicked off if necessary, and when
+      # there are no more dependents, it gets stopped to avoid leaking
+      # memory.
+      resultDep = nil;
+      computation = nil;
+
+      return proc do
+        if (!computation)
+          if (!Autodeps.active)
+            # Not in a reactive context.  Just call func, and don't start a
+            # computation if there isn't one running already.
+            break func.call();
+          end
+
+          # No running computation, so kick one off.  Since this computation
+          # will be shared, avoid any association with the current computation
+          # by using `Deps.nonreactive`.
+          resultDep = Autodeps::Dependency.new;
+
+          computation = Autodeps.nonreactive do
+            break Autodeps.autorun do |c|
+              oldResult = curResult;
+              curResult = func.call();
+              if (!c.first_run)
+                if (!(equals ? equals.call(curResult, oldResult) :
+                    curResult == oldResult))
+                  resultDep.changed();
+                end
+              end
+            end
+          end
+        end
+
+        if (Autodeps.active)
+          is_new = resultDep.depend();
+          if (is_new)
+            # For each new dependent, schedule a task for after that dependents
+            # invalidation time and the subsequent flush. The task checks
+            # whether the computation should be torn down.
+            Autodeps.on_invalidate do
+              if (resultDep && !resultDep.hasDependents())
+                Autodeps.afterFlush do
+                  # use a second afterFlush to bump ourselves to the END of the
+                  # flush, after computation re-runs have had a chance to
+                  # re-establish their connections to our computation.
+                  Autodeps.afterFlush do
+                    if (resultDep && !resultDep.hasDependents())
+                      computation.stop();
+                      computation = nil;
+                      resultDep = nil;
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        curResult
+      end
+    end
+
+    def embox_value(value, equals=nil)
+       raise "embox_value on a direct value not implemented"
+    end
+
+    def active
+      Thread.current["Autodeps::active"]
+    end
+
+    def active= (active)
+      Thread.current["Autodeps::active"] = active
+    end
+
     def current_computation
       Thread.current["Autodeps::current_computation"]
     end
-    def current_computation=(computation)
+    def current_computation= (computation)
       Thread.current["Autodeps::current_computation"] = computation
       self.active = !! computation;
     end

data/lib/autodeps/computation.rb

@@ -1,6 +1,6 @@
 module Autodeps
   class Computation
-    attr_accessor :stopped, :invalidated, :first_run, :parent, :block, :recomputing
+    attr_accessor :stopped, :invalidated, :first_run, :parent, :block, :recomputing,:_on_invalidate_callbacks
     def initialize(block, parent=nil)
       self.stopped = false;
           self.invalidated = false;
@@ -9,6 +9,7 @@ module Autodeps
       self.parent = parent;
       self.block = block;
       self.recomputing = false;
+      self._on_invalidate_callbacks = ThreadSafe::Array.new
 
       errored = true;
       begin
@@ -31,6 +32,9 @@ module Autodeps
       in_compute = true;
       begin
         block.call(self)
+      #rescue => e
+      #  Autodeps.logger.error(e.message) if Autodeps.logger
+      #  Autodeps.logger.error(e.backtrace.join("\n")) if Autodeps.logger
       ensure
         Autodeps.current_computation = previous;
         in_compute = false;
@@ -41,7 +45,12 @@ module Autodeps
       self.recomputing = true
 
       while (self.invalidated && !self.stopped)
-          self.compute() rescue nil
+        begin
+          self.compute()
+        rescue => e
+          Autodeps.logger.error(e.message) if Autodeps.logger
+          Autodeps.logger.error(e.backtrace.join("\n")) if Autodeps.logger
+        end
       end
 
       self.recomputing = false;
@@ -58,26 +67,52 @@ module Autodeps
       Autodeps::flush
     end
 
-
     def invalidate
-      #we request an immediate flush because we don't have timeout
+      ##we request an immediate flush because we don't have timeout
 
 
 
       if (! self.invalidated)
-          # if we're currently in _recompute(), don't enqueue
-      # ourselves, since we'll rerun immediately anyway.
-      if (! self.recomputing && ! self.stopped)
+        # if we're currently in _recompute(), don't enqueue
+        # ourselves, since we'll rerun immediately anyway.
+
         self.invalidated = true;
-        Autodeps.add_pending_computation(self);
-        require_flush();
-      end
+        self._on_invalidate_callbacks.each do |f|
+          f.call(); #// already bound with self as argument
+        end
+        self._on_invalidate_callbacks = ThreadSafe::Array.new;
 
+        if (! self.recomputing && ! self.stopped)
+          self.invalidated = true;
 
+          Autodeps.add_pending_computation(self);
+          require_flush();
+        end
 
       # callbacks can't add callbacks, because
       #self.invalidated === true.
+
+
       end
     end
+
+    def on_invalidate(f=nil, &block)
+        if block_given?
+          f = block
+        end
+        raise ("on_invalidate requires a block") unless f;
+
+        g = proc do
+          Autodeps.nonreactive do
+            f.call(self);
+          end
+        end
+
+        if (self.invalidated)
+          g();
+        else
+          self._on_invalidate_callbacks.push(g);
+        end
+    end
   end
 end

data/lib/autodeps/dependency.rb

@@ -2,7 +2,7 @@ module Autodeps
   class Dependency
     attr_accessor :dependents
     def initialize
-      @dependents = []
+      @dependents = ThreadSafe::Array.new
     end
     def depend(computation = Autodeps.current_computation)
 
@@ -12,9 +12,9 @@ module Autodeps
       end
       if !@dependents.include?(computation)
         @dependents << computation
-        #computation.onInvalidate(function () {
-        #  delete self._dependentsById[id];
-        #});
+        computation.on_invalidate do
+          @dependents.delete(computation)
+        end
         return true
       else
         return false;
@@ -27,5 +27,9 @@ module Autodeps
         computation.invalidate
       end
     end
+
+    def hasDependents
+      !@dependents.empty?
+    end
   end
 end

data/lib/autodeps/version.rb

@@ -1,3 +1,3 @@
 module Autodeps
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/autodep_test.rb

@@ -48,4 +48,196 @@ class AutoDepsTest < Test::Unit::TestCase
 
     assert_equal c,20
   end
+
+  def test_exception
+    a = Autodeps::ReactiveData.new(3)
+    b = Autodeps::ReactiveData.new(5)
+    c = nil
+    computation = nil
+    begin
+       Autodeps.autorun do |_computation|
+         computation = _computation
+        c = a.value + b.value
+        dd
+      end
+    rescue
+    end
+    #puts computation
+    #assert_equal c,8
+    #
+    #a.change_to 5
+    #
+    #assert_equal c,10
+    #
+    #b.change_to 15
+    #
+    #assert_equal c,20
+  end
+
+  def test_isolation
+    a = Autodeps::ReactiveData.new(3)
+    b = Autodeps::ReactiveData.new(5)
+    c = nil
+    count = 0
+    computation = nil
+    result = nil
+      Autodeps.autorun do ###1
+        count += 1
+        result = Autodeps.isolateValue do ###2
+          a.value >= 3
+        end
+      end
+    assert_equal true, result
+    assert_equal 1, count #the ###1 blocks gets run first_time
+    a.change_to 5
+    assert_equal true, result
+    assert_equal 1, count #the ###1 blocks doesn't gets run again because ###2's value doesn't change, the isolateValue call isolates it
+    a.change_to 2
+    assert_equal false, result
+    assert_equal 2, count #the ###1 blocks gets run again, because the isolated block's value changes
+
+  end
+
+  def test_embox
+    a = Autodeps::ReactiveData.new(3)
+    b = Autodeps::ReactiveData.new(5)
+    c = nil
+    count = 0
+
+    inner = proc do
+      a.value
+      count += 1
+    end
+
+    outter = Autodeps.embox do
+      inner.call
+    end
+
+    Autodeps.autorun do ###1
+      inner.call
+    end
+    Autodeps.autorun do ###1
+      inner.call
+    end
+    assert_equal 2, count
+
+
+    a.change_to 4
+    assert_equal 4, count
+  end
+
+  def test_embox1
+    a = Autodeps::ReactiveData.new(3)
+    b = Autodeps::ReactiveData.new(5)
+    c = nil
+    count = 0
+
+    inner = proc do
+      a.value
+      count += 1
+    end
+
+    outter = Autodeps.embox do
+      inner.call
+    end
+
+    Autodeps.autorun do ###1
+      outter.call
+    end
+    Autodeps.autorun do ###1
+      outter.call
+    end
+    assert_equal 1, count
+
+
+    a.change_to 4
+    assert_equal 2, count
+  end
+
+  def test_nested_computation
+    a = Autodeps::ReactiveData.new(3)
+    b = Autodeps::ReactiveData.new(5)
+
+    count_1 = 0
+    count_2 = 0
+    compuation1 = nil
+    compuation2 = nil
+
+    compuation1 = Autodeps.autorun do ###1
+      a.value
+      count_1 += 1
+      compuation2 = Autodeps.autorun do ###1
+        b.value
+        count_2 += 1
+        puts "b is " + b.value.to_s + " , count: " + count_2.to_s
+      end
+    end
+    assert_equal 1, count_1
+    assert_equal 1, count_2
+    tmp_compuation1 = compuation1
+    tmp_compuation2 = compuation2
+    b.change_to 2
+
+    assert_equal 1, count_1
+    assert_equal 2, count_2
+    assert_equal tmp_compuation1, compuation1
+    assert_equal tmp_compuation2, compuation2
+
+    a.change_to 15
+    #todo: clear b's deps's 2 sizes array
+    #in which one(the original one) is stopped,
+    #so we need to sometime clear in order not to
+    #let the deps grow larger and larger.
+    assert_equal 2, count_1
+    assert_equal 3, count_2
+    assert_equal tmp_compuation1, compuation1
+    assert_not_equal tmp_compuation2, compuation2
+
+    puts "before"
+    b.change_to 10
+    assert_equal 4, count_2
+    puts "after"
+
+  end
+
+  def test_thread
+    a = Autodeps::ReactiveData.new(3)
+    b = Autodeps::ReactiveData.new(5)
+    c = nil
+    computation = Autodeps.autorun do |computation|
+      c = a.value + b.value
+    end
+    assert_equal c,8
+
+    thread = Thread.new do
+     a.change_to 5
+    end
+    thread.join
+    assert_equal c,10
+
+    thread = Thread.new do
+      b.change_to 15
+    end
+    thread.join
+    assert_equal c,20
+  end
+
+  def test_active
+    a = Autodeps::ReactiveData.new(3)
+    b = Autodeps::ReactiveData.new(5)
+    c = nil
+    computation = Autodeps.autorun do |computation|
+      c = a.value + b.value
+    end
+    assert_equal c,8
+
+
+    thread = Thread.new do
+      assert_equal nil, Autodeps.active
+    end
+    thread.join
+
+  end
+
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: autodeps
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - femto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-12 00:00:00.000000000 Z
+date: 2014-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: thread_safe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: autodeps
 email:
 - femtowin@gmail.com