push_routes 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e2fc62c4419b2bdc9565ce9bf8927b4b7a2471a1
+  data.tar.gz: 7633da272cc55d16f82565d28673408ad284a448
+SHA512:
+  metadata.gz: 246d3adb2af66d5526abbbeedd1afea48fd06f12a80c2686d7d6d44fc45204499e83e5e173a1296c6314c5942bb74a5937098ab730a23dc25ce74ae4fc1603f8
+  data.tar.gz: ee1563ed13fc69a321cfb766256eb1bbb599dd4b72d524a6b573ad22e11fe34096c771f7b4d12ee83fd8c7092141103540f4917dd1e89bf0e40a707c2f0c988b

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'PushRoutes'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/helpers/push_routes/application_helper.rb

@@ -0,0 +1,4 @@
+module PushRoutes
+  module ApplicationHelper
+  end
+end

data/config/routes.rb

@@ -0,0 +1,5 @@
+Rails.application.routes.draw do
+	PushRoutes.newGetRoutes.each do |route,controller|
+		get route, :to => controller
+	end
+end

data/lib/push_routes/engine.rb

@@ -0,0 +1,42 @@
+module PushRoutes
+  class Engine < Rails::Engine
+    def self.load_controllers
+      if(PushRoutes.redis)
+        begin
+          PushRoutes.redis.set("PUSH_ROUTES_ACTIVE_ROUTES",PushRoutes.active_routes.to_json)
+        rescue
+          warn "Redis connection failed"
+        end
+      else
+        warn "Redis server not configured properly"
+      end
+    end
+
+    initializer "push_routes.view_helpers" do
+      ActionView::Base.send :include, Helpers
+    end
+
+    initializer 'push_routes.precompile_hook', :group => :all do |app|
+      app.config.assets.precompile += ['socket.io.js']
+      app.config.assets.precompile += ['push_routes_socket_io.js']
+    end
+
+    config.after_initialize do
+      if(ENV["REDIS_URL"])
+        PushRoutes.REDIS_URL=ENV["REDIS_URL"]
+      end
+
+      if(ENV["NODE_URL"])
+        PushRoutes.NODE_URL=ENV["NODE_URL"]
+      end
+
+      Rails.application.reload_routes!
+      PushRoutes::Engine.load_controllers
+      ActionDispatch::Reloader.to_prepare do
+        #Note: may need to reload routes too? only if the routes changed
+        # should never happen in production
+        PushRoutes::Engine.load_controllers
+      end
+    end
+  end
+end

data/lib/push_routes/helpers.rb

@@ -0,0 +1,13 @@
+module PushRoutes
+  module Helpers
+    def push_routes_init debug_string = ""
+      out = ""
+      out += javascript_include_tag 'socket.io'
+      out += javascript_include_tag 'push_routes_socket_io'
+      out += javascript_tag "PushRoutes.connect({server: \"#{PushRoutes.NODE_URL}\", id: #{current_user.id}, authentication_token: \"#{current_user.authentication_token}\"}, function() {
+      							PushRoutes.set_debug_string(\"#{debug_string}\");
+      							});"
+      return out.html_safe
+    end
+  end
+end

data/lib/push_routes/push_route.rb

@@ -0,0 +1,195 @@
+#TODO: Cacheing can work because controllers return the renderd values, just need to wrap/alias the controller actions
+module PushRoute
+  extend ActiveSupport::Concern
+
+  #Computes the file path of inherited classes for use when auto-generating routes
+  included do
+    #class_attribute :controller_path
+    class_attribute :push_routes
+    class_attribute :trigger_symbols
+    self.trigger_symbols = []
+    self.push_routes = {}
+
+    #Computed this way when mixed in to the controller base class
+    def self.inherited(subclass)
+      subclass.push_routes = {}
+      subclass.trigger_symbols = []
+      #  controller_matches = caller[0].match(/^.*?\/app\/controllers\/(.*?)_controller.rb:/)
+      #  if controller_matches
+      # #   subclass.controller_path = controller_matches[1]
+      #  else
+      #    # Happens with rspec test cases
+      #    # this might not be the best thing to do with this case
+      #    puts "Warning: No standard controller path found for #{subclass.inspect}"
+      #  end
+      super
+    end
+
+    #Do it this way when used as a mixin for controllers
+    #Seems like the controller file is the third method in the call stack. May change in later rails versions
+    #self.controller_path = caller[2].match(/^.*?\/app\/controllers\/(.*?)_controller.rb:/)[1]
+  end
+
+  module ClassMethods
+
+    #TODO: if not route already make, make it; set association between route(s) and action
+    # test method aliasing, perhaps can still do caching explicitly, or maybe just
+    # expiring caches properly; ignore caches for now
+    #
+    # maybe just internal whisper pub sub with a routing adapter
+    # also pull out seperate class for each push route to store routes and triggers
+    # Maybe rails magic on for trigger function names
+    def enable_push_route(action, route = nil)
+      matched_url = nil
+      Rails.application.routes.routes.each do |e|
+        if e.defaults[:controller] == self.controller_path && e.defaults[:action] == action.to_s
+          unless matched_url
+            matched_url = PushRoutes::PushRouteUrl.new(e)
+          else
+            raise ArgumentError.new("Duplicate route for push route controller")
+          end
+        end
+      end
+
+      #If a route exists and one is provided, make sure they are compatable
+      if matched_url and route
+        raise ArgumentError.new("Provided route does not match pre-existing route") unless (matched_url.matches(route))
+        url = matched_url
+      elsif route and !matched_url
+        #There was no pre-existing route found and a route was specified
+        # Add this route to the list of live routes
+        url = PushRoutes::PushRouteUrl.new(route)
+      elsif !route and matched_url
+        #Matched one route only, we're good
+        url = matched_url
+      else
+        #No route and no match
+        raise ArgumentError.new("No route found and no route provided")
+      end
+
+      if push_routes[action]
+        raise ArgumentError.new("Push Route enabled twice")
+      else
+        push_routes[action] = url
+      end
+    end
+
+
+    # If it's defined as an instance method and not a static method we'll define a static method which wraps the functinality
+    # While this seems crazy, ActionMailer does this so there's precident
+    def method_missing(method_sym, *arguments, &block)
+      if instance_trigger?(method_sym)
+        new.send(method_sym, *arguments, &block)
+      else
+        super
+      end
+    end
+
+    #Overriding respond_to_missing to allow our method_missing override to behave properly
+    def respond_to_missing?(method_sym, include_private = false)
+      instance_trigger?(method_sym) || super
+    end
+
+    def instance_trigger?(method_sym)
+      trigger_symbols.include?(method_sym) && instance_methods.include?(method_sym)
+    end
+
+    #
+    # Sets a trigger for pushing updates
+    # @param [symbol] the action in this controller for the listener to trigger
+    # @param model [ModelType] The type of model to listen to e.g. User, LabOrder
+    # @param type [Symbol] Listener type, e.g. :after_update, see below for list
+    # @param trigger_function [function] Function to determine if an update should be triggered, either proc or reference
+    # function should return true to trigger update of the route; if the route requires params to resolve (i.e /users/:id/files)
+    # the params should be returned as a hash. Return false or nil to not trigger an update
+    #
+    def add_trigger(action, model, type, trigger_function = nil)
+      enable_push_route action unless push_routes[action]
+
+      # Get get the callback passed in
+      if (!trigger_function and block_given?)
+        # Block only
+        # Note Proc.new gets the passed in block without instantiating an extra proc
+        # See http://mudge.name/2011/01/26/passing-blocks-in-ruby-without-block.html
+        callback = Proc.new
+      elsif trigger_function && trigger_function.is_a?(Proc)
+        # Proc passed
+        callback = trigger_function
+      elsif trigger_function #&& !trigger_function.is_a?(Proc) implied here
+        # Symbol passed
+        trigger_symbols << trigger_function
+        callback = lambda { |e| self.send(trigger_function, e) }
+      else
+        #default value
+        callback = Proc.new { true }
+      end
+
+      if [:after_commit, :after_save, :after_update, :after_create, :after_destroy].include? type
+        this = self
+        func = lambda do |e|
+          result = callback.call(e)
+          if (result)
+            result = [result] unless result.kind_of?(Array)
+            result.each do |params|
+              update_path = this.push_routes[action].notification_string(params)
+              msg = {channel: update_path, type: "", data: "placeholder"}
+              begin
+                #TODO: Abstract away redis server as a transport
+                #This try catch repetition is bad
+                PushRoutes.redis.publish 'rt-change', msg.to_json
+              rescue Redis::CannotConnectError => e
+                warn "PushRoutes cannot reach the redis server"
+              end
+            end
+          end
+        end
+        model.send(type, func)
+      else
+        raise ArgumentError.new("Invalid trigger type")
+      end
+    end
+
+    #TODO: check for full class depth or shallow depth i.e. Api2::VitalsController
+    def model
+      #Note: const_defined is unrelialbe due to rails auto_loading, model might not be loaded
+      begin
+        Object.const_get(controller_path.classify)
+      rescue
+        nil
+      end
+    end
+
+    def add_id_trigger(action, model, id_name, type = :after_save)
+      add_trigger(action, model, type) { |object| {id: object.send(id_name)} }
+    end
+
+    #If you have a route like /room/:id/messages where Message belongs_to room
+    #you can use add_belongs_to_trigger :index, Message
+    #It will look at the url and try to add a trigger
+    #on Message save triggering the id as Message.room.id
+    def add_belongs_to_trigger(action, model, type = :after_save)
+      enable_push_route action unless push_routes[action]
+      url = push_routes[action]
+      warn "Push Routes WARNING: Url #{url.inspect} contains too many params" if url.param_associations.count > 1
+      warn "Push Routes WARNING: Url #{url.inspect} contains not enough notated params" if url.param_associations.count > 1
+      sym = url.param_associations.first[1].singularize.to_sym
+      if model.table_exists?
+        if model&.send(:new)&.respond_to?(sym)
+          add_trigger(action, model, type) { |object| {id: object.send(sym)&.id} }
+        else
+          warn "Push Routes WARNING: #{model} does not respond to #{sym} in belongs_to trigger"
+        end
+      else
+        warn("Push Routes WARNING: no table exists for #{model}")
+      end
+    end
+
+    def add_show_trigger(action)
+      if self.model
+        add_id_trigger(action, self.model, :id)
+      else
+        warn "Push Routes WARNING: No model found for #{controller_path}"
+      end
+    end
+  end
+end

data/lib/push_routes/push_route_url.rb

@@ -0,0 +1,76 @@
+module PushRoutes
+  class PushRouteUrl
+    attr_accessor :source
+    #
+    # if this push_route_url is a new route that needs to be registered
+    # can be determined by if the input passed in was a string or not
+    #
+    attr_accessor :isNew
+
+    def initialize(input)
+      if (input.is_a?(ActionDispatch::Journey::Route))
+        #Remove traiing format string
+        @source = input.path.spec.to_s.gsub(/\(\.\:format\)\Z/, "")
+        @isNew = false
+      elsif input.is_a? String
+        @source = input
+        @isNew = true
+      else
+        raise ArgumentError.new("Unexpected input: #{input}")
+      end
+      #Parses out the required parameters for the route as a list of symbols
+      @url_args = @source.scan(/\/\:([^\/]+)/).flatten.map { |e| e.to_sym }
+    end
+
+
+    #
+    # Returns a true url from the original route with parameters filled in
+    # If the route has no parameters this function simply returns the route, ignoring input
+    # If the parameters are insufficient an ArgumentError is raised
+    #
+    # @param params [Hash] params
+    #
+    # @return [String] completed url
+    def notification_string(params)
+      if @url_args.count == 0
+        @source
+      else
+        unless (params.is_a?(Hash))
+          raise ArgumentError.new("Params for #{@source} must be a hash with: #{@url_args}")
+        end
+        built_string = @source
+        @url_args.each do |e|
+          if (params.include?(e))
+            built_string = built_string.gsub(Regexp.new("\\:#{e}"), params[e].to_s)
+          else
+            raise ArgumentError.new("Missing param #{e}")
+          end
+        end
+        built_string
+      end
+    end
+
+    def to_s
+      @source
+    end
+
+    #
+    # returns true of url is a valid expression of the route represented
+    # @param url [string] url to check
+    #
+    # @return [bool] true if url matches this route
+    # TODO: testing on this function
+    def matches(url)
+      str = @source.gsub(/(?!\/)\:.*?(?=\/|$)/, "([^\/]+?)")
+      str = "^" + str + "$"
+      Regexp.new(str).match(url)
+    end
+
+    # Gets the parameter associations from a url if they are well formed, meaning, each
+    # parameter is preceded by another token
+    # @return [Hash] parameter_symbol => preceding symbol
+    def param_associations
+      @source.scan(/\/([^\/]*?)\/\:([^\/]+)/).map {|k,v| [v.to_sym,k]}.to_h
+    end
+  end
+end

data/lib/push_routes/version.rb

@@ -0,0 +1,3 @@
+module PushRoutes
+  VERSION = "0.0.6"
+end

data/lib/push_routes.rb

@@ -0,0 +1,84 @@
+require 'push_routes/engine'
+require 'push_routes/push_route_url'
+require 'push_routes/push_route'
+require 'push_routes/helpers'
+require 'redis'
+
+#Note: Could consider switching listeners to the 'whisper' pub-sub gem later, instead of attaching directly
+# After looking at the gem it would be essentially the same for this project in it's current state
+# however if we ever need to have another layer of listener events or have callbacks happen
+# asynchronously, it's something we could try
+
+#TODO: setup the add_trigger method to take a block and do the rails magic which will take functions defined with regular names and attach them
+# That rails magic might not be possible...
+module PushRoutes
+  class << self
+    attr_accessor :NODE_URL
+  end
+  @@redis = nil
+  @@controllers = Set.new
+
+  def self.newGetRoutes
+    hash = {}
+    PushRoutes.controllers.each do |c|
+      c.push_routes.each do |k,v|
+        hash[v.source] = c.controller_path+"#"+k.to_s if v.isNew
+      end
+    end
+    return hash
+  end
+
+  def self.REDIS_URL
+    @@redis.client.options[:url] if @@redis
+  end
+
+  def self.REDIS_URL= (x)
+    begin
+      @@redis = Redis.new(:url => x);
+    rescue
+      warn "Failed to connect to redis server. Push Routes will not work"
+    end
+  end
+
+  def self.redis
+    @@redis
+  end
+
+  def self.class_prefixes(string)
+    res = []
+    pos = 0
+    while(string.index("::",pos))
+      pos = string.index("::",pos)
+      res << string[0..pos-1]
+      pos += 2
+    end
+    res << string[0..-1]
+  end
+
+  def self.controllers
+    Dir[Rails.root.join('app','controllers','**','*.rb')].map do |file|
+      #Note: This may break if the directory structure has /app/controllers multiple times.
+      #We want to match everything after the first app/controllers after the project root
+      Object.const_get(/^.*?\/app\/controllers\/(.*?).rb$/.match(file)[1].camelize)
+    end
+    # Dir[Rails.root.join('app','controllers','**','*.rb')].each do |file|
+    #   #Note: This may break if the directory structure has /app/controllers multiple times.
+    #   #We want to match everything after the first app/controllers after the project root
+
+    #   controller_name = /^.*?\/app\/controllers\/(.*?).rb$/.match(file)[1].camelize
+    #   class_prefixes(controller_name)[0..-2].each do |name|
+    #     Object.const_get(name)
+    #   end
+    # end
+  end
+
+
+
+  def self.active_routes
+    PushRoutes.controllers.flat_map {|c| c.push_routes.map {|k,v| v.source}}
+  end
+
+  class ActionController::Base
+    include PushRoute
+  end
+end

data/lib/tasks/push_routes_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :push_routes do
+#   # Task goes here
+# end

data/test/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/test/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/test/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/test/dummy/app/controllers/clubs_controller.rb

@@ -0,0 +1,16 @@
+class ClubsController < ApplicationController
+  def list
+    render json: Club.find(params[:id]).people , status: 200
+  end
+  add_id_trigger :list, Person, :club_id
+
+  def people
+    render json: Club.find(params[:id]).people , status: 200
+  end
+  add_belongs_to_trigger :people, Person
+
+  def show
+    render json: Club.find(params[:id]) , status: 200
+  end
+  add_show_trigger :show
+end

data/test/dummy/app/controllers/people_controller.rb

@@ -0,0 +1,40 @@
+class PeopleController < ApplicationController
+  enable_push_route :index
+  def index
+    render json: Person.all, status: 200
+  end
+  add_trigger :index, Person, :after_save
+
+  enable_push_route :old, "/old_people"
+  def old
+    render json: Person.where("age > 50"), status: 200
+  end
+  add_trigger(:old, Person, :after_update) do |person|
+    (person.age_was <= 50 and person.age > 50) or (person.age_was > 50 and person.age <= 50)
+  end
+
+  enable_push_route :old_function, "/old_function"
+  def old_function
+    render json: Person.where("age > 80"), status: 200
+  end
+
+  add_trigger :old_function, Person, :after_update, :old_function_trigger
+  def old_function_trigger(person)
+    (person.age_was <= 80 and person.age > 80) or (person.age_was > 80 and person.age <= 80)
+  end
+
+  enable_push_route :with_age
+  def with_age
+    render json: Person.where(age: params[:age]), status: 200
+  end
+  add_trigger(:with_age, Person, :after_create) do |person|
+    {age: person.age}
+  end
+  add_trigger(:with_age, Person, :after_update) do |person|
+    if(person.age_was != person.age)
+      [{age: person.age_was}, {age: person.age}]
+    else
+      false
+    end
+  end
+end

data/test/dummy/app/controllers/push_routes/clubs_controller.rb

@@ -0,0 +1,6 @@
+class PushRoutes::ClubsController < ApplicationController
+  def show
+    render json: Club.find(params[:id]) , status: 200
+  end
+  add_show_trigger :show
+end

data/test/dummy/app/controllers/push_routes/nested_controller.rb

@@ -0,0 +1,15 @@
+class PushRoutes::NestedController < ApplicationController
+	enable_push_route :nested_function
+	def nested_function
+		render json: Person.find(params[:id]), status: 200
+	end
+	add_trigger :nested_function, Person, :after_save, :nested_function_trigger
+	def nested_function_trigger(person)
+		return {:id => person.id}
+	end
+
+	enable_push_route :added_function, "/new_route"
+	def added_function
+		render json: Person.find(params[:id]), status: 200
+	end
+end

data/test/dummy/app/controllers/reload_test_models_controller.rb

@@ -0,0 +1,7 @@
+class ReloadTestModelsController < ApplicationController
+  enable_push_route :index, "/reloadTestModel"
+  def index
+    render json: [], status: 200
+  end
+  add_trigger :index, ReloadTestModel, :after_save
+end

data/test/dummy/app/controllers/sockets_controller.rb

@@ -0,0 +1,5 @@
+class SocketsController < ApplicationController
+  def test
+  end
+  add_trigger :test, Person, :after_save
+end

data/test/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/test/dummy/app/models/club.rb

@@ -0,0 +1,3 @@
+class Club < ActiveRecord::Base
+  has_many :people
+end

data/test/dummy/app/models/person.rb

@@ -0,0 +1,3 @@
+class Person < ActiveRecord::Base
+  belongs_to :club
+end

data/test/dummy/app/models/reload_test_model.rb

@@ -0,0 +1,2 @@
+class ReloadTestModel < ActiveRecord::Base
+end