jason-rails 0.4.1 → 0.6.2

data/lib/jason/includes_helper.rb

@@ -0,0 +1,108 @@
+# Helper to provide other modules with information about the includes of a subscription
+
+class Jason::IncludesHelper
+  attr_accessor :main_tree
+
+  def initialize(main_tree)
+    raise "Root must be hash" if !main_tree.is_a?(Hash)
+    raise "Only one root key allowed" if main_tree.keys.size != 1
+    @main_tree = main_tree
+  end
+
+  def all_models_recursive(tree)
+    sub_models = if tree.is_a?(Hash)
+      tree.map do |k,v|
+        [k, all_models_recursive(v)]
+      end
+    elsif tree.is_a?(Array)
+      tree.map do |v|
+        all_models_recursive(v)
+      end
+    else
+      tree
+    end
+  end
+
+  def all_models(model_name = nil)
+    model_name = model_name.presence || root_model
+    assoc_name = get_assoc_name(model_name)
+    tree = get_tree_for(assoc_name)
+    [model_name, all_models_recursive(tree)].flatten.uniq.map(&:to_s).map(&:singularize)
+  end
+
+  def root_model
+    main_tree.keys[0]
+  end
+
+  # assoc could be plural or not, so need to scan both.
+  def get_assoc_name(model_name, haystack = main_tree)
+    if haystack.is_a?(Hash)
+      haystack.each do |assoc_name, includes_tree|
+        if model_name.pluralize == assoc_name.to_s.pluralize
+          return assoc_name
+        else
+          found_assoc = get_assoc_name(model_name, includes_tree)
+          return found_assoc if found_assoc
+        end
+      end
+    elsif haystack.is_a?(Array)
+      haystack.each do |element|
+        if element.is_a?(String)
+          if model_name.pluralize == element.pluralize
+            return element
+          end
+        else
+          found_assoc = get_assoc_name(model_name, element)
+          return found_assoc if found_assoc
+        end
+      end
+    else
+      if model_name.pluralize == haystack.to_s.pluralize
+        return haystack
+      end
+    end
+
+    return nil
+  end
+
+  def get_tree_for(needle, assoc_name = nil, haystack = main_tree)
+    return haystack if needle.to_s.pluralize == assoc_name.to_s.pluralize
+
+    if haystack.is_a?(Hash)
+      haystack.each do |assoc_name, includes_tree|
+        found_haystack = get_tree_for(needle, assoc_name, includes_tree)
+        return found_haystack if found_haystack.present?
+      end
+    elsif haystack.is_a?(Array)
+      haystack.each do |includes_tree|
+        found_haystack = get_tree_for(needle, nil, includes_tree)
+        return found_haystack if found_haystack.present?
+      end
+    elsif haystack.is_a?(String)
+      found_haystack = get_tree_for(needle, haystack, nil)
+      return found_haystack if found_haystack.present?
+    end
+
+    return []
+  end
+
+  def in_sub(parent_model, child_model)
+    tree = get_tree_for(parent_model)
+
+    if tree.is_a?(Hash)
+      return tree.keys.map(&:singularize).include?(child_model)
+    elsif tree.is_a?(Array)
+      tree.each do |element|
+        if element.is_a?(String)
+          return true if element.singularize == child_model
+        elsif element.is_a?(Hash)
+          return true if element.keys.map(&:singularize).include?(child_model)
+        end
+      end
+    elsif tree.is_a?(String)
+      return tree.singularize == child_model
+    end
+
+    return false
+  end
+end

data/lib/jason/lua_generator.rb

@@ -0,0 +1,71 @@
+class Jason::LuaGenerator
+  ## TODO load these scripts and evalsha
+  def cache_json(model_name, id, payload)
+    cmd = <<~LUA
+      local gidx = redis.call('INCR', 'jason:gidx')
+      redis.call( 'set', 'jason:cache:' .. ARGV[1] .. ':' .. ARGV[2] .. ':gidx', gidx )
+      redis.call( 'hset', 'jason:cache:' .. ARGV[1], ARGV[2], ARGV[3] )
+      return gidx
+    LUA
+
+    result = $redis_jason.eval cmd, [], [model_name, id, payload.to_json]
+  end
+
+  def get_payload(model_name, sub_id)
+    # If value has changed, return old value and new idx. Otherwise do nothing.
+    cmd = <<~LUA
+      local t = {}
+      local models = {}
+      local ids = redis.call('smembers', 'jason:subscriptions:' .. ARGV[2] .. ':ids:' .. ARGV[1])
+
+      for k,id in pairs(ids) do
+        models[#models+1] = redis.call( 'hget', 'jason:cache:' .. ARGV[1], id)
+      end
+
+      t[#t+1] = models
+      t[#t+1] = redis.call( 'get', 'jason:subscription:' .. ARGV[2] .. ':' .. ARGV[1] .. ':idx' )
+
+      return t
+    LUA
+
+    $redis_jason.eval cmd, [], [model_name, sub_id]
+  end
+
+  def get_subscription(model_name, id, sub_id, gidx)
+    # If value has changed, return old value and new idx. Otherwise do nothing.
+    cmd = <<~LUA
+      local last_gidx = redis.call('get', 'jason:cache:' .. ARGV[1] .. ':' .. ARGV[2] .. ':gidx') or 0
+
+      if (ARGV[4] >= last_gidx) then
+        local sub_idx = redis.call( 'incr', 'jason:subscription:' .. ARGV[3] .. ':' .. ARGV[1] .. ':idx' )
+        return sub_idx
+      else
+        return false
+      end
+    LUA
+
+    $redis_jason.eval cmd, [], [model_name, id, sub_id, gidx]
+  end
+
+  def update_set_with_diff(key, add_members, remove_members)
+    cmd = <<~LUA
+      local old_members = redis.call('smembers', KEYS[1])
+      local add_size = ARGV[1]
+
+      for k, m in pairs({unpack(ARGV, 2, add_size + 1)}) do
+        redis.call('sadd', KEYS[1], m)
+      end
+
+      for k, m in pairs({unpack(ARGV, add_size + 2, #ARGV)}) do
+        redis.call('srem', KEYS[1], m)
+      end
+
+      return old_members
+    LUA
+
+    args = [add_members.size, add_members, remove_members].flatten
+
+    old_members = $redis_jason.eval cmd, [key], args
+    return [old_members, (old_members + add_members - remove_members).uniq]
+  end
+end

data/lib/jason/publisher.rb

@@ -1,76 +1,121 @@
 module Jason::Publisher
   extend ActiveSupport::Concern
 
+  # Warning: Could be expensive. Mainly useful for rebuilding cache after changing Jason config or on deploy
+  def self.cache_all
+    Rails.application.eager_load!
+    ActiveRecord::Base.descendants.each do |klass|
+      klass.cache_all if klass.respond_to?(:cache_all)
+    end
+  end
+
   def cache_json
     as_json_config = api_model.as_json_config
     scope = api_model.scope
 
+    # Exists
     if self.persisted? && (scope.blank? || self.class.unscoped.send(scope).exists?(self.id))
       payload = self.reload.as_json(as_json_config)
-      $redis_jason.hset("jason:#{self.class.name.underscore}:cache", self.id, payload.to_json)
+      gidx = Jason::LuaGenerator.new.cache_json(self.class.name.underscore, self.id, payload)
+      return [payload, gidx]
+    # Has been destroyed
     else
-      $redis_jason.hdel("jason:#{self.class.name.underscore}:cache", self.id)
+      $redis_jason.hdel("jason:cache:#{self.class.name.underscore}", self.id)
+      return []
     end
   end
 
-  def publish_json
-    cache_json
+  def force_publish_json
+    # As-if newly created
+    publish_json(self.attributes.map { |k,v| [k, [nil, v]] }.to_h)
+  end
+
+  def publish_json(previous_changes = {})
+    payload, gidx = cache_json
+
     return if skip_publish_json
-    self.class.jason_subscriptions.each do |id, config_json|
-      config = JSON.parse(config_json)
+    subs = jason_subscriptions # Get this first, because could be changed
+
+    # Situations where IDs may need to change and this can't be immediately determined
+    # - An instance is created where it belongs_to an instance under a subscription
+    # - An instance belongs_to association changes - e.g. comment.post_id changes to/from one with a subscription
+    # - TODO: The value of an instance changes so that it enters/leaves a subscription
+
+    # TODO: Optimize this, by caching associations rather than checking each time instance is saved
+    jason_assocs = self.class.reflect_on_all_associations(:belongs_to).select { |assoc| assoc.klass.respond_to?(:has_jason?) }
+    jason_assocs.each do |assoc|
+      if previous_changes[assoc.foreign_key].present?
+        Jason::Subscription.update_ids(
+          self.class.name.underscore,
+          id,
+          assoc.name.to_s.singularize,
+          previous_changes[assoc.foreign_key][0],
+          previous_changes[assoc.foreign_key][1]
+        )
+      elsif (persisted? && @was_a_new_record && send(assoc.foreign_key).present?)
+        Jason::Subscription.update_ids(
+          self.class.name.underscore,
+          id,
+          assoc.name.to_s.singularize,
+          nil,
+          send(assoc.foreign_key)
+        )
+      end
+    end
+
+    if !persisted? # Deleted
+      Jason::Subscription.remove_ids(
+        self.class.name.underscore,
+        [id]
+       )
+    end
 
-      if (config['conditions'] || {}).all? { |field, value| self.send(field) == value }
-        Jason::Subscription.new(id: id).update(self.class.name.underscore)
+    # - An instance is created where it belongs_to an _all_ subscription
+    if previous_changes['id'].present?
+      Jason::Subscription.add_id(self.class.name.underscore, id)
+    end
+
+    if persisted?
+      jason_subscriptions.each do |sub_id|
+        Jason::Subscription.new(id: sub_id).update(self.class.name.underscore, id, payload, gidx)
       end
     end
   end
 
   def publish_json_if_changed
     subscribed_fields = api_model.subscribed_fields
-    publish_json if (self.previous_changes.keys.map(&:to_sym) & subscribed_fields).present? || !self.persisted?
+    publish_json(self.previous_changes) if (self.previous_changes.keys.map(&:to_sym) & subscribed_fields).present? || !self.persisted?
   end
 
-  class_methods do
-    def subscriptions
-      $redis_jason.hgetall("jason:#{self.name.underscore}:subscriptions")
-    end
+  def jason_subscriptions
+    Jason::Subscription.for_instance(self.class.name.underscore, id)
+  end
 
-    def jason_subscriptions
-      $redis_jason.hgetall("jason:#{self.name.underscore}:subscriptions")
-    end
+  def jason_cached_value
+    JSON.parse($redis_jason.hget("jason:cache:#{self.class.name.underscore}", id) || '{}')
+  end
 
-    def publish_all(instances)
-      instances.each(&:cache_json)
+  class_methods do
+    def cache_all
+      all.each(&:cache_json)
+    end
 
-      subscriptions.each do |id, config_json|
-        Jason::Subscription.new(id: id).update(self.name.underscore)
-      end
+    def has_jason?
+      true
     end
 
     def flush_cache
-      $redis_jason.del("jason:#{self.name.underscore}:cache")
+      $redis_jason.del("jason:cache:#{self.name.underscore}")
     end
 
     def setup_json
+      self.before_save -> {
+        @was_a_new_record = new_record?
+      }
       self.after_initialize -> {
         @api_model = Jason::ApiModel.new(self.class.name.underscore)
       }
       self.after_commit :publish_json_if_changed
-
-      include_models = Jason::ApiModel.new(self.name.underscore).include_models
-
-      include_models.map do |assoc|
-        puts assoc
-        reflection = self.reflect_on_association(assoc.to_sym)
-        reflection.klass.after_commit -> {
-          subscribed_fields = Jason::ApiModel.new(self.class.name.underscore).subscribed_fields
-          puts subscribed_fields.inspect
-
-          if (self.previous_changes.keys.map(&:to_sym) & subscribed_fields).present?
-            self.send(reflection.inverse_of.name)&.publish_json
-          end
-        }
-      end
     end
 
     def find_or_create_by_id(params)

data/lib/jason/publisher_old.rb

@@ -0,0 +1,112 @@
+module Jason::PublisherOld
+  extend ActiveSupport::Concern
+
+  def cache_json
+    as_json_config = api_model.as_json_config
+    scope = api_model.scope
+
+    if self.persisted? && (scope.blank? || self.class.unscoped.send(scope).exists?(self.id))
+      payload = self.reload.as_json(as_json_config)
+      $redis_jason.hset("jason:#{self.class.name.underscore}:cache", self.id, payload.to_json)
+    else
+      $redis_jason.hdel("jason:#{self.class.name.underscore}:cache", self.id)
+    end
+  end
+
+  def publish_json
+    cache_json
+    return if skip_publish_json
+
+    self.class.jason_subscriptions.each do |id, config_json|
+      config = JSON.parse(config_json)
+
+      if (config['conditions'] || {}).all? { |field, value| self.send(field) == value }
+        Jason::Subscription.new(id: id).update(self.class.name.underscore)
+      end
+    end
+  end
+
+  def publish_json_if_changed
+    subscribed_fields = api_model.subscribed_fields
+    publish_json if (self.previous_changes.keys.map(&:to_sym) & subscribed_fields).present? || !self.persisted?
+  end
+
+  class_methods do
+    def subscriptions
+      $redis_jason.hgetall("jason:#{self.name.underscore}:subscriptions")
+    end
+
+    def jason_subscriptions
+      $redis_jason.hgetall("jason:#{self.name.underscore}:subscriptions")
+    end
+
+    def publish_all(instances)
+      instances.each(&:cache_json)
+
+      subscriptions.each do |id, config_json|
+        Jason::Subscription.new(id: id).update(self.name.underscore)
+      end
+    end
+
+    def flush_cache
+      $redis_jason.del("jason:#{self.name.underscore}:cache")
+    end
+
+    def setup_json
+      self.after_initialize -> {
+        @api_model = Jason::ApiModel.new(self.class.name.underscore)
+      }
+      self.after_commit :publish_json_if_changed
+
+      include_models = Jason::ApiModel.new(self.name.underscore).include_models
+
+      include_models.map do |assoc|
+        puts assoc
+        reflection = self.reflect_on_association(assoc.to_sym)
+        reflection.klass.after_commit -> {
+          subscribed_fields = Jason::ApiModel.new(self.class.name.underscore).subscribed_fields
+          puts subscribed_fields.inspect
+
+          if (self.previous_changes.keys.map(&:to_sym) & subscribed_fields).present?
+            self.send(reflection.inverse_of.name)&.publish_json
+          end
+        }
+      end
+    end
+
+    def find_or_create_by_id(params)
+      object = find_by(id: params[:id])
+
+      if object
+        object.update(params)
+      elsif params[:hidden]
+        return false ## If an object is passed with hidden = true but didn't already exist, it's safe to never create it
+      else
+        object = create!(params)
+      end
+
+      object
+    end
+
+    def find_or_create_by_id!(params)
+      object = find_by(id: params[:id])
+
+      if object
+        object.update!(params)
+      elsif params[:hidden]
+        ## TODO: We're diverging from semantics of the Rails bang! methods here, which would normally either raise or return an object. Find a way to make this better.
+        return false ## If an object is passed with hidden = true but didn't already exist, it's safe to never create it
+      else
+        object = create!(params)
+      end
+
+      object
+    end
+  end
+
+  included do
+    attr_accessor :skip_publish_json, :api_model
+
+    setup_json
+  end
+end