volt 0.9.4.pre3 → 0.9.4.pre5

data/lib/volt/models/model_helpers/model_change_helpers.rb

@@ -1,87 +0,0 @@
-# ModelChangeHelpers handle validating and persisting the data in a model
-# when it is changed.  #run_changed will be called from the model.
-
-module Volt
-  module ModelChangeHelpers
-    def self.included(base)
-      base.setup_action_helpers_in_class(:before_save, :before_validate)
-    end
-
-    # Called when something in the model changes.  Saves
-    # the model if there is a persistor, and changes the
-    # model to not be new.
-    #
-    # @return [Promise|nil] a promise for when the save is
-    #         complete
-    def run_changed(attribute_name = nil)
-      # no_validate mode should only be used internally.  no_validate mode is a
-      # performance optimization that prevents validation from running after each
-      # change when assigning multile attributes.
-      unless Volt.in_mode?(:no_validate)
-        # Run the validations for all fields
-        result = nil
-        return validate!.then do
-          # Buffers are allowed to be in an invalid state
-          unless buffer?
-            # First check that all local validations pass
-            if error_in_changed_attributes?
-              # Some errors are present, revert changes
-              revert_changes!
-
-              # After we revert, we need to validate again to get the error messages back
-              # TODO: Could probably cache the previous errors.
-              result = validate!.then do
-                # Reject the promise with the errors
-                Promise.new.reject(errs)
-              end
-            else
-              result = persist_changes(attribute_name)
-            end
-          end
-
-          # Return result inside of the validate! promise
-          result.then { self }
-        end
-      end
-
-      # Didn't run validations
-      self.then
-    end
-
-
-    private
-    # Should only be called from run_changed.  Saves the changes back to the persistor
-    # and clears the tracked changes.
-    def persist_changes(attribute_name)
-      # No errors, tell the persistor to handle the change (usually save)
-
-      # Don't save right now if we're in a nosave block
-      unless Volt.in_mode?(:no_save)
-        # Call the before_save callback
-        # skip validations when running before_save, this prevents n+1, and allows
-        # the before_save to put the model into an invalid state, which you want
-        # sometimes.
-        Volt::Model.no_validate do
-          run_callbacks(:before_save)
-        end
-
-        # the changed method on a persistor should return a promise that will
-        # be resolved when the save is complete, or fail with a hash of errors.
-        if @persistor
-          result = @persistor.changed(attribute_name)
-        else
-          result = Promise.new.resolve(nil)
-        end
-
-        # Saved, no longer new
-        @new = false
-
-        # Clear the change tracking
-        clear_tracked_changes!
-      end
-
-      result
-    end
-
-  end
-end

data/lib/volt/models/model_helpers/model_helpers.rb

@@ -1,110 +0,0 @@
-module Volt
-  # A place for things shared between an ArrayModel and a Model
-  module ModelHelpers
-    def deep_unwrap(value)
-      if value.is_a?(Model)
-        value.to_h
-      elsif value.is_a?(ArrayModel)
-        value.to_a
-      else
-        value
-      end
-    end
-
-    # Pass to the persisotr
-    def event_added(event, first, first_for_event)
-      @persistor.event_added(event, first, first_for_event) if @persistor
-    end
-
-    # Pass to the persistor
-    def event_removed(event, last, last_for_event)
-      @persistor.event_removed(event, last, last_for_event) if @persistor
-    end
-
-    ID_CHARS = [('a'..'f'), ('0'..'9')].map(&:to_a).flatten
-
-    # Create a random unique id that can be used as the mongo id as well
-    def generate_id
-      id = []
-      24.times { id << ID_CHARS.sample }
-
-      id.join
-    end
-
-
-    # Return the attributes that are only for this model and any hash sub models
-    # but not any sub-associations.
-    def self_attributes
-      # Don't store any sub-models, those will do their own saving.
-      attributes.reject { |k, v| v.is_a?(ArrayModel) }.map do |k,v|
-        if v.is_a?(Model)
-          v = v.self_attributes
-        end
-
-        [k,v]
-      end.to_h
-    end
-
-
-    # Takes the persistor if there is one and
-    def setup_persistor(persistor)
-      # Use page as the default persistor
-      persistor ||= Persistors::Page
-      if persistor.respond_to?(:new)
-        @persistor = persistor.new(self)
-      else
-        # an already initialized persistor was passed in
-        @persistor = persistor
-      end
-    end
-
-    def store
-      # TODO: Move away from $page
-      $page.store
-    end
-
-    # returns the root model for the collection the model is currently on.  So
-    # if the model is persisted somewhere on store, it will return ```store```
-    def root
-      persistor.try(:root_model)
-    end
-
-
-
-
-    module ClassMethods
-      # Gets the class for a model at the specified path.
-      def class_at_path(path)
-        if path
-          begin
-            # remove the _ and then singularize
-            if path.last == :[]
-              index = -2
-            else
-              index = -1
-            end
-
-            klass_name = path[index].singularize.camelize
-
-            # Lookup the class
-            klass = Object.const_get(klass_name)
-
-            # Use it if it is a model
-            klass = Model unless klass < Model
-          rescue NameError => e
-            # Ignore exception, just means the model isn't defined
-            klass = Model
-          end
-        else
-          klass = Model
-        end
-
-        klass
-      end
-    end
-
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-  end
-end

data/lib/volt/models/state_helpers.rb

@@ -1,11 +0,0 @@
-module Volt
-  module StateHelpers
-    def loaded_state
-      state_for(:loaded_state)
-    end
-
-    def loaded?
-      loaded_state == :loaded
-    end
-  end
-end

data/lib/volt/page/page.rb

@@ -1,190 +0,0 @@
-require 'volt/utils/ejson'
-
-module Volt
-  class Page
-    attr_reader :url, :params, :page, :routes, :events
-
-    def initialize(volt_app)
-      @volt_app = volt_app
-      # Run the code to setup the page
-      @page          = PageRoot.new
-
-      @url         = URL.new
-      @params      = @url.params
-      @url_tracker = UrlTracker.new(self)
-      @templates   = {}
-
-      @events = DocumentEvents.new
-
-      if RUBY_PLATFORM == 'opal'
-        if Volt.in_browser?
-          # Setup escape binding for console
-          `
-            $(document).keyup(function(e) {
-              if (e.keyCode == 27) {
-                Opal.gvars.page.$launch_console();
-              }
-            });
-
-            $(document).on('click', 'a', function(event) {
-              return Opal.gvars.page.$link_clicked($(this).attr('href'), event);
-            });
-          `
-        end
-      end
-
-      # Initialize tasks so we can get the reload message
-      tasks if Volt.env.development?
-
-      if Volt.in_browser?
-        channel.on('reconnected') do
-          @page._reconnected = true
-
-          `setTimeout(function() {`
-          @page._reconnected = false
-          `}, 2000);`
-        end
-      end
-    end
-
-    def flash
-      @flash ||= FlashRoot.new({}, persistor: Persistors::Flash)
-    end
-
-    def store
-      @store ||= StoreRoot.new({}, persistor: Persistors::StoreFactory.new(tasks))
-    end
-
-    def local_store
-      @local_store ||= LocalStoreRoot.new({}, persistor: Persistors::LocalStore)
-    end
-
-    def cookies
-      @cookies ||= CookiesRoot.new({}, persistor: Persistors::Cookies)
-    end
-
-    def tasks
-      @tasks ||= Tasks.new(self)
-    end
-
-    def link_clicked(url = '', event = nil)
-      # Skip when href == ''
-      return false if url.blank?
-
-      # Normalize url
-      if @url.parse(url)
-        if event
-          # Handled new url
-          `event.stopPropagation();`
-        end
-
-        # Clear the flash
-        flash.clear
-
-        # return false to stop the event propigation
-        return false
-      end
-
-      # Not stopping, process link normally
-      true
-    end
-
-    # We provide a binding_name, so we can bind events on the document
-    def binding_name
-      'page'
-    end
-
-    def launch_console
-      puts 'Launch Console'
-    end
-
-    def channel
-      @channel ||= begin
-        if Volt.client?
-          Channel.new
-        else
-          ChannelStub.new
-        end
-      end
-    end
-
-    attr_reader :events
-
-    def add_template(name, template, bindings)
-      # First template gets priority.  The backend will load templates in order so
-      # that local templates come in before gems (so they can be overridden).
-      #
-      # TODO: Currently this means we will send templates to the client that will
-      # not get used because they are being overridden.  Need to detect that and
-      # not send them.
-      unless @templates[name]
-        @templates[name] = { 'html' => template, 'bindings' => bindings }
-      end
-    end
-
-    # On the server, we can delay loading the views until they are actually requeted.  This
-    # sets up an instance variable to call to load.
-    attr_writer :template_loader
-
-    def templates
-      if @template_loader
-        # Load the templates
-        @template_loader.call
-        @template_loader = nil
-      end
-
-      @templates
-    end
-
-    def add_routes(&block)
-      @routes ||= Routes.new
-      @routes.define(&block)
-      @url.router = @routes
-    end
-
-    def start
-      # Setup to render template
-      `$('body').html('<!-- $CONTENT --><!-- $/CONTENT -->');`
-
-      load_stored_page
-
-      # Do the initial url params parse
-      @url_tracker.url_updated(true)
-
-      main_controller = Main::MainController.new(@volt_app)
-
-      # Setup main page template
-      TemplateRenderer.new(@volt_app, DomTarget.new, main_controller, 'CONTENT', 'main/main/main/body')
-
-      # Setup title reactive template
-      @title_template = StringTemplateRenderer.new(@volt_app, main_controller, 'main/main/main/title')
-
-      # Watch for changes to the title template
-      proc do
-        title = @title_template.html.gsub(/\n/, ' ')
-        `document.title = title;`
-      end.watch!
-    end
-
-    # When the page is reloaded from the backend, we store the $page.page, so we
-    # can reload the page in the exact same state.  Speeds up development.
-    def load_stored_page
-      if Volt.client?
-        if `sessionStorage`
-          page_obj_str = nil
-
-          `page_obj_str = sessionStorage.getItem('___page');`
-          `if (page_obj_str) {`
-          `sessionStorage.removeItem('___page');`
-
-          EJSON.parse(page_obj_str).each_pair do |key, value|
-            page.send(:"_#{key}=", value)
-          end
-          `}`
-        end
-      end
-    rescue => e
-      Volt.logger.error("Unable to restore: #{e.inspect}")
-    end
-  end
-end