volt-repo_cache 0.1.4

data/lib/volt/repo_cache/model_array.rb

@@ -0,0 +1,169 @@
+require 'volt/reactive/reactive_array'
+
+module Volt
+  module RepoCache
+    class ModelArray
+      include Volt::RepoCache::Util
+
+      def initialize(observer: nil, contents: nil)
+        @contents = Volt::ReactiveArray.new(contents || [])
+        @id_hash = {}
+        @contents.each do |e|
+          @id_hash[e.id] = e
+        end
+      end
+
+      # subclasses may override if interested.
+      def observe(action, model)
+        # no op
+      end
+
+      def index(*args, &block)
+        @contents.index(*args, &block)
+      end
+
+      def to_a
+        # not sure what reactive array does
+        # so map contents into normal array
+        @contents.map{|e|e}
+      end
+
+      def size
+        @contents.size
+      end
+
+      def empty?
+        @contents.empty?
+      end
+
+      def detect(*args, &block)
+        @contents.detect(*args, &block)
+      end
+
+      def each(&block)
+        @contents.each(&block)
+      end
+
+      def each_with_index(&block)
+        @contents.each_with_index(&block)
+      end
+
+      def first
+        @contents.first
+      end
+
+      def last
+        @contents.last
+      end
+
+      def count(&block)
+        @contents.count(&block)
+      end
+
+      def sort(&block)
+        @contents.sort(&block)
+      end
+
+      def select(&block)
+        @contents.select(&block)
+      end
+
+      def reject(&block)
+        @contents.reject(&block)
+      end
+
+      def collect(&block)
+        @contents.collect(&block)
+      end
+
+      alias_method :map, :collect
+
+      def reduce(seed, &block)
+        @contents.reduce(seed, &block)
+      end
+
+      alias_method :inject, :reduce
+
+      # Query is simple for now:
+      # - a hash of keys and values to match by equality
+      # - or a select block
+      # TODO: would prefer a splat to the hash,
+      # but Opal fails to parse calls with **splats
+      def query(args = nil, &block)
+        if args.nil? || args.empty?
+          if block
+            select &block
+          else
+            raise ArgumentError, 'query requires splat of key-value pairs, or a select block'
+          end
+        elsif args.size == 1
+          k, v = args.first
+          if k == :id
+            [@id_hash[v]]
+          else
+            select {|e| e.send(k) == v}
+          end
+        else
+          query do |e|
+            match = true
+            args.each do |k, v|
+              unless e.send(k) == v
+                match = false
+                break
+              end
+            end
+            match
+          end
+        end
+      end
+
+      alias_method :where, :query
+
+      private
+
+      def __delete_at__(index, notify: true)
+        model = @contents.delete_at(index)
+        if model
+          @id_hash.delete(model.id)
+          observe(:remove, model) if notify
+        end
+        model
+      end
+
+      def __delete__(model, notify: true)
+        i = find_index(model)
+        __delete_at__(i, notify: notify) if i
+      end
+
+      def __clear__
+        @contents.clear
+        @id_hash.clear
+      end
+
+      def __remove_if_present__
+        __remove__(model, error_if_absent: false)
+      end
+
+      def __remove__(model, error_if_absent: true)
+        index = index {|e| e.id == model.id }
+        if index
+          result = __delete_at__(index)
+          # debug __method__, __LINE__, "deleted #{result.class.name} #{result.id}"
+          result
+        elsif error_if_absent
+          msg = "could not find #{model.class.name} with id #{model.id} to delete"
+          # debug __method__, __LINE__, msg
+          raise RuntimeError, msg
+        end
+      end
+
+      def __append__(model, notify: true)
+        @contents.append(model)
+        @id_hash[model.id] = model
+        observe(:add, model) if notify
+        self
+      end
+
+    end
+  end
+end

data/lib/volt/repo_cache/util.rb

@@ -0,0 +1,78 @@
+module Volt
+  module RepoCache
+    module Util
+      module_function
+
+      def setter(getter)
+        :"#{getter}="
+      end
+
+      def creator(getter)
+        prefix_method(getter, 'new')
+      end
+
+      def adder(getter)
+        prefix_method(getter, 'add')
+      end
+
+      def remover(getter)
+        prefix_method(getter, 'remove')
+      end
+
+      def prefix_method(getter, prefix)
+        :"#{prefix}_#{getter.to_s.singularize}"
+      end
+
+      def arrify(object)
+        object.respond_to?(:to_a) ? object.to_a : [object]
+      end
+
+      def unsupported(method)
+        fail "#{method} is an unsupported operation for #{self.class.name}"
+      end
+
+      def not_yet_implemented(method)
+        fail "#{method} is not yet implemented for #{self.class.name}"
+      end
+
+      def subclass_responsibility(method)
+        fail "#{method} is responsibility of #{self.class.name}"
+      end
+
+      def friends_only(__method__, caller)
+        unless friend?(caller)
+          fail "#{self.class.name}##{__method__} for Volt::RepoCache use only, not #{caller.class.name}"
+        end
+      end
+
+      def friend?(object)
+        if object
+          if object.is_a?(Volt::Model)
+            object.respond_to?(:patched_for_cache?)
+          else
+            (object.class.name =~ /^Volt::RepoCache/) == 0
+          end
+        else
+          false
+        end
+      end
+
+      def debug(method, line, msg = nil)
+        s = ">>> #{self.class.name}##{method}[#{line}] : #{msg}"
+        if RUBY_PLATFORM == 'opal'
+          Volt.logger.debug s
+        else
+          puts s
+        end
+      end
+
+      def time(method, line, msg = nil)
+        t1 = Time.now
+        r = yield
+        t2 = Time.now
+        debug(method, line, "#{msg} : took #{t2 - t1} seconds")
+        r
+      end
+    end
+  end
+end

data/lib/volt/repo_cache/version.rb

@@ -0,0 +1,5 @@
+module Volt
+  module RepoCache
+    VERSION = "0.1.4"
+  end
+end

data/spec/dummy/.gitignore

@@ -0,0 +1,9 @@
+.bundle
+.config
+.yardoc
+tmp
+.idea
+.yardoc
+.sass-cache
+.DS_Store
+compiled

data/spec/dummy/README.md

@@ -0,0 +1,4 @@
+# Place your app's docs here.
+
+## New to Volt?
+Be sure to read the volt docs at http://voltframework.com/docs

data/spec/dummy/app/main/assets/css/app.css.scss

@@ -0,0 +1 @@
+// Place your apps css here

data/spec/dummy/app/main/config/dependencies.rb

@@ -0,0 +1,11 @@
+# Specify which components you wish to include when
+# the "home" component loads.
+
+# bootstrap css framework
+component 'bootstrap'
+
+# a default theme for the bootstrap framework
+component 'bootstrap_jumbotron_theme'
+
+# provides templates for login, signup, and logout
+component 'user_templates'

data/spec/dummy/app/main/config/initializers/boot.rb

@@ -0,0 +1,10 @@
+# Place any code you want to run when the component is included on the client
+# or server.
+
+# To include code only on the client use:
+# if RUBY_PLATFORM == 'opal'
+#
+# To include code only on the server, use:
+# unless RUBY_PLATFORM == 'opal'
+# ^^ this will not send compile in code in the conditional to the client.
+# ^^ this include code required in the conditional.

data/spec/dummy/app/main/config/routes.rb

@@ -0,0 +1,14 @@
+# See https://github.com/voltrb/volt#routes for more info on routes
+
+client '/about', action: 'about'
+
+# Routes for login and signup, provided by user_templates component gem
+client '/signup', component: 'user_templates', controller: 'signup'
+client '/login', component: 'user_templates', controller: 'login', action: 'index'
+client '/password_reset', component: 'user_templates', controller: 'password_reset', action: 'index'
+client '/forgot', component: 'user_templates', controller: 'login', action: 'forgot'
+client '/account', component: 'user_templates', controller: 'account', action: 'index'
+
+# The main route, this should be last. It will match any params not
+# previously matched.
+client '/', {}

data/spec/dummy/app/main/controllers/main_controller.rb

@@ -0,0 +1,27 @@
+# By default Volt generates this controller for your Main component
+module Main
+  class MainController < Volt::ModelController
+    def index
+      # Add code for when the index view is loaded
+    end
+
+    def about
+      # Add code for when the about view is loaded
+    end
+
+    private
+
+    # The main template contains a #template binding that shows another
+    # template.  This is the path to that template.  It may change based
+    # on the params._component, params._controller, and params._action values.
+    def main_path
+      "#{params._component || 'main'}/#{params._controller || 'main'}/#{params._action || 'index'}"
+    end
+
+    # Determine if the current nav component is the active one by looking
+    # at the first part of the url against the href attribute.
+    def active_tab?
+      url.path.split('/')[1] == attrs.href.split('/')[1]
+    end
+  end
+end

data/spec/dummy/app/main/models/customer.rb

@@ -0,0 +1,4 @@
+class Customer < Volt::Model
+  field :name
+  has_many :orders
+end

data/spec/dummy/app/main/models/order.rb

@@ -0,0 +1,6 @@
+class Order < Volt::Model
+  field       :date, String #YYYYMMDD
+  field       :quantity, Fixnum
+  belongs_to  :customer
+  belongs_to  :product
+end

data/spec/dummy/app/main/models/product.rb

@@ -0,0 +1,5 @@
+class Product < Volt::Model
+  field :name, String
+  has_many :orders
+end
+

data/spec/dummy/app/main/models/user.rb

@@ -0,0 +1,12 @@
+# By default Volt generates this User model which inherits from Volt::User,
+# you can rename this if you want.
+class User < Volt::User
+  # login_field is set to :email by default and can be changed to :username
+  # in config/app.rb
+  field login_field
+  field :name
+
+  validate login_field, unique: true, length: 8
+  validate :email, email: true
+
+end

data/spec/dummy/app/main/views/main/about.html

@@ -0,0 +1,7 @@
+<:Title>
+  About
+
+<:Body>
+  <h1>About</h1>
+
+  <p>About page...</p>

data/spec/dummy/app/main/views/main/index.html

@@ -0,0 +1,6 @@
+<:Title>
+  Home
+
+<:Body>
+  <h1>Home</h1>
+

data/spec/dummy/app/main/views/main/main.html

@@ -0,0 +1,29 @@
+<:Title>
+  {{ view main_path, "title", {controller_group: 'main'} }}
+
+<:Body>
+  <div class="container">
+    <div class="header">
+      <ul class="nav nav-pills pull-right">
+        <:nav href="/">Home</:nav>
+        <:nav href="/about">About</:nav>
+        <:user_templates:menu />
+      </ul>
+      <h3 class="text-muted">dummy</h3>
+    </div>
+
+    <:volt:notices />
+
+    {{ view main_path, 'body', {controller_group: 'main'} }}
+
+    <div class="footer">
+      <p>&copy; Company {{ Time.now.year }}</p>
+    </div>
+
+  </div>
+
+<:Nav>
+  <li class="{{ if active_tab? }}active{{ end }}">
+    <a href="{{ attrs.href }}">{{ yield }}</a>
+  </li>
+

data/spec/dummy/config.ru

@@ -0,0 +1,4 @@
+# Run via rack server
+require 'bundler/setup'
+require 'volt/server'
+run Volt::Server.new.app

data/spec/dummy/config/app.rb

@@ -0,0 +1,147 @@
+# app.rb is used to configure your app.  This code is only run on the server,
+# then any config options in config.public are passed to the client as well.
+
+Volt.configure do |config|
+  # Setup your global app config here.
+
+  #######################################
+  # Basic App Info (stuff you should set)
+  #######################################
+  config.domain = 'dummy.com'
+  config.app_name = 'Dummy'
+  config.mailer.from = 'Dummy <no-reply@dummy.com>'
+
+  ############
+  # App Secret
+  ############
+  # Your app secret is used for signing things like the user cookie so it can't
+  # be tampered with.  A random value is generated on new projects that will work
+  # without the need to customize.  Make sure this value doesn't leave your server.
+  #
+  # For added security we recommend moving the app secret into an environment.  You can
+  # setup that like so:
+  #
+  # config.app_secret = ENV['APP_SECRET']
+  #
+  config.app_secret = 'BidFdMW1H8fjB7icltOfGImr5G9AHOTCqgnzfZHYnVg5wgPJUS3kdekVRszLYjVmJxw'
+
+  ###############
+  # Log Filtering
+  ###############
+  # Data updates from the client come in via Tasks.  The task dispatcher logs all calls to tasks.
+  # By default hashes in the arguments can be filtered based on keys.  So any hash with a key of
+  # password will be filtered.  You can add more fields to filter below:
+  config.filter_keys = [:password]
+
+  ##########
+  # Database
+  ##########
+  # Database config all start with db_ and can be set either in the config
+  # file or with an environment variable (DB_NAME for example).
+
+  config.db_driver = 'mongo'
+  config.db_name = (config.app_name + '_' + Volt.env.to_s)
+  config.db_host = 'localhost'
+  config.db_port = 27017
+
+  #####################
+  # Compression options
+  #####################
+  # If you are not running behind something like nginx in production, you can
+  # have rack deflate all files.
+  # config.deflate = true
+
+  #########################
+  # Websocket configuration
+  #########################
+  # If you need to use a different domain or path for the websocket connection,
+  # you can set it here.  Volt provides the socket connection url at /socket,
+  # but if for example you are using a proxy server that doesn't support
+  # websockets, you can point the websocket connection at the app server
+  # directly.
+  # config.public.websocket_url = '/socket'
+
+  #######################
+  # Public configurations
+  #######################
+  # Anything under config.public will be sent to the client as well as the server,
+  # so be sure no private data ends up under public
+
+  # Use username instead of email as the login
+  # config.public.auth.use_username = true
+
+  #####################
+  # Compression Options
+  #####################
+  # Disable or enable css/js/image compression.  Default is to only run in production.
+  # if Volt.env.production?
+  #   config.compress_javascript = true
+  #   config.compress_css        = true
+  #   config.compress_images     = true
+  # end
+
+  ################
+  # Mailer options
+  ################
+  # The volt-mailer gem uses pony (https://github.com/benprew/pony) to deliver e-mail.  Any
+  # options you would pass to pony can be setup below.
+  # NOTE: The from address is setup at the top
+
+  # Normally pony uses /usr/sbin/sendmail if one is installed.  You can specify smtp below:
+  # config.mailer.via = :smtp
+  # config.mailer.via_options = {
+  #   :address        => 'smtp.yourserver.com',
+  #   :port           => '25',
+  #   :user_name      => 'user',
+  #   :password       => 'password',
+  #   :authentication => :plain, # :plain, :login, :cram_md5, no auth by default
+  #   :domain         => "localhost.localdomain" # the HELO domain provided by the client to the server
+  # }
+
+  #############
+  # Message Bus
+  #############
+  # Volt provides a "Message Bus" out of the box.  The message bus provides
+  # a pub/sub service between any volt instance (server, client, runner, etc..)
+  # that share the same database.  The message bus can be used by app code.  It
+  # is also used internally to push data to any listening clients.
+  #
+  # The default message bus (called "peer_to_peer") uses the database to sync
+  # socket ip's/ports.
+  # config.message_bus.bus_name = 'peer_to_peer'
+  #
+  # Encrypt message bus - messages on the message bus are encrypted by default
+  # using rbnacl.
+  
+  #
+  # For dummy apps, we disable_encryption, to simplify the gem requirements.
+  config.message_bus.disable_encryption = true
+  
+  #
+  # ## MessageBus Server -- the message bus binds to a port and ip which the
+  # other volt instances need to be able to connect to.  You can customize
+  # the server below:
+  #
+  # Port range - you can specify a range of ports that an instance can bind the
+  # message bus on.  You can specify a range, an array of Integers, or an array
+  # of ranges.
+  # config.message_bus.bind_port_ranges = (58000..61000)
+  #
+  # Bind Ip - specifies the ip address the message bus server should bind on.
+  # config.message_bus.bind_ip = '127.0.0.1'
+
+  #############
+  # Concurrency
+  #############
+  # Volt provides a thread worker pool for incoming task requests (and all
+  # database requests, since those use tasks to do their work.)  The following
+  # lets you control the size of the worker pool.  Threads are only created as
+  # needed, and are removed after a certain amount of inactivity.
+  # config.min_worker_threads = 1
+  # config.max_worker_threads = 10
+  #
+  # You can also specify the amount of time a Task should run for before it
+  # timeout's.  Setting this to short can cause unexpected results, currently
+  # we recomend it be at least 10 seconds.
+  # config.worker_timeout = 60
+end