volt 0.9.6 → 0.9.7.pre2

data/lib/volt/models/field_helpers.rb

@@ -1,93 +1,133 @@
 # Provides a method to setup a field on a model.
-module FieldHelpers
-  class InvalidFieldClass < RuntimeError; end
+module Volt
+  module FieldHelpers
+    class InvalidFieldClass < RuntimeError; end
 
-  NUMERIC_CAST = lambda do |convert_method, val|
-    begin
-      orig = val
+    NUMERIC_CAST = lambda do |convert_method, val|
+      begin
+        orig = val
 
-      val = send(convert_method, val)
+        val = send(convert_method, val)
 
-      if RUBY_PLATFORM == 'opal'
-        # Opal has a bug in 0.7.2 that gives us back NaN without an
-        # error sometimes.
-        val = orig if val.nan?
+        if RUBY_PLATFORM == 'opal'
+          # Opal has a bug in 0.7.2 that gives us back NaN without an
+          # error sometimes.
+          val = orig if val.nan?
+        end
+      rescue TypeError, ArgumentError => e
+        # ignore, unmatched types will be caught below.
+        val = orig
       end
-    rescue TypeError, ArgumentError => e
-      # ignore, unmatched types will be caught below.
-      val = orig
+
+      return val
     end
 
-    return val
-  end
+    FIELD_CASTS = {
+      String        => :to_s.to_proc,
+      Fixnum        => lambda {|val| NUMERIC_CAST[:Integer, val] },
+      Numeric       => lambda {|val| NUMERIC_CAST[:Float, val] },
+      Float         => lambda {|val| NUMERIC_CAST[:Float, val] },
+      TrueClass     => nil,
+      FalseClass    => nil,
+      NilClass      => nil,
+      Volt::Boolean => nil
+    }
 
-  FIELD_CASTS = {
-    String        => :to_s.to_proc,
-    Fixnum        => lambda {|val| NUMERIC_CAST[:Integer, val] },
-    Numeric       => lambda {|val| NUMERIC_CAST[:Float, val] },
-    Float         => lambda {|val| NUMERIC_CAST[:Float, val] },
-    Time          => nil,
-    TrueClass     => nil,
-    FalseClass    => nil,
-    NilClass      => nil,
-    Volt::Boolean => nil
-  }
-
-
-  module ClassMethods
-    # field lets you declare your fields instead of using the underscore syntax.
-    # An optional class restriction can be passed in.
-    def field(name, klasses = nil, options = {})
-      if klasses
-        klasses = [klasses].flatten
-
-        unless klasses.any? {|kl| FIELD_CASTS.key?(kl) }
-          klass_names = FIELD_CASTS.keys.map(&:to_s).join(', ')
-          msg = "valid field types is currently limited to #{klass_names}, you passed: #{klasses.inspect}"
-          fail FieldHelpers::InvalidFieldClass, msg
-        end
+    # If VoltTime has already been required by the time we load this class, we
+    # add it to the field casts:
+    if defined?(VoltTime)
+      FIELD_CASTS[VoltTime] = nil
+    end
+
+    module ClassMethods
+      # field lets you declare your fields instead of using the underscore syntax.
+      # An optional class restriction can be passed in.
+
+      def field(name, klasses = nil, options = {})
+        name = name.to_sym
+        if klasses
+          klasses = [klasses].flatten
 
-        # Add NilClass as an allowed type unless allow_nil: false was passed.
-        unless options[:allow_nil] == false
-          klasses << NilClass
+          unless klasses.any? {|kl| FIELD_CASTS.key?(kl) }
+            klass_names = FIELD_CASTS.keys.map(&:to_s).join(', ')
+            msg = "valid field types is currently limited to #{klass_names}, you passed: #{klasses.inspect}"
+            fail FieldHelpers::InvalidFieldClass, msg
+          end
+
+          # defined in associations.rb
+          check_name_in_use(name)
+
+          # Add NilClass as an allowed type unless nil: false was passed.
+          unless options[:nil] == false
+            options.delete(:nil)
+            klasses << NilClass
+          end
         end
-      end
 
-      self.fields_data ||= {}
-      self.fields_data[name] = [klasses, options]
+        # Normalize default
+        options.delete(:default) if options[:default] == nil
 
-      if klasses
-        # Add type validation, execpt for String, since anything can be cast to
-        # a string.
-        unless klasses.include?(String)
-          validate name, type: klasses
+        # Store the field defaults
+        if (default_val = options[:default])
+          self.defaults[name] = default_val
         end
-      end
 
-      define_method(name) do
-        get(name)
-      end
+        self.fields[name] = [klasses, options]
 
-      define_method(:"#{name}=") do |val|
-        # Check if the value assigned matches the class restriction
         if klasses
-          # Cast to the right type
-          klasses.each do |kl|
-            if (func = FIELD_CASTS[kl])
-              # Cast on the first available caster
-              val = func[val]
-              break
+          # Add type validation, execpt for String, since anything can be cast to
+          # a string.
+          unless klasses.include?(String)
+            validate name, type: klasses
+          end
+        end
+
+
+        # define the fields getter
+        define_method(name) do
+          get(name)
+        end
+
+        define_method(:"#{name}=") do |val|
+          # Check if the value assigned matches the class restriction
+          if klasses
+            # Cast to the right type
+            klasses.each do |kl|
+              if (func = FIELD_CASTS[kl])
+                # Cast on the first available caster
+                val = func[val]
+                break
+              end
             end
           end
+
+          set(name, val)
         end
+      end
 
-        set(name, val)
+      def index(columns, options={})
+        # Columns is stored in an array
+        columns = [columns].flatten.map {|c| c.to_sym }
+
+        options[:columns] = columns
+
+        # Add in default name
+        name = (options.delete(:name) || "#{collection_name}_#{columns.join('_')}_index").to_sym
+        self.indexes[name] = options
       end
     end
-  end
 
-  def self.included(base)
-    base.class_attribute :fields_data
-    base.send :extend, ClassMethods
+    def self.included(base)
+      base.class_attribute :fields
+      base.fields = {}
+
+      base.class_attribute :indexes
+      base.indexes = {}
+
+      base.class_attribute :defaults
+      base.defaults = {}
+
+      base.send :extend, ClassMethods
+    end
   end
 end

data/lib/volt/models/helpers/array_model.rb

@@ -9,6 +9,10 @@ module Volt
         def loaded?
           loaded_state == :loaded
         end
+
+        def collection_name
+          path.last.gsub('/', '_')
+        end
       end
     end
   end

data/lib/volt/models/helpers/base.rb

@@ -84,7 +84,6 @@ module Volt
               # process_class_name is defined by Model/ArrayModel as
               # singularize/pluralize
               klass_name = process_class_name(klass_name = path[index]).camelize
-
               begin
                 # Lookup the class
                 klass = Object.const_get(klass_name)
@@ -121,6 +120,14 @@ module Volt
 
         def self.included(base)
           base.send :extend, ClassMethods
+          # Used for testing
+          def base.temporary
+            @temporary = true
+          end
+
+          def base.is_temporary
+            @temporary
+          end
         end
 
       end

data/lib/volt/models/helpers/change_helpers.rb

@@ -5,7 +5,9 @@ module Volt
     module Helpers
       module ChangeHelpers
         def self.included(base)
-          base.setup_action_helpers_in_class(:before_save, :before_validate)
+          base.setup_action_helpers_in_class(
+            :before_create, :before_update, :before_save, :before_validate
+          )
         end
 
         # Called when something in the model changes.  Saves
@@ -18,10 +20,23 @@ module Volt
           # 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)
+          if Volt.in_mode?(:no_validate)
+            # Didn't run validations, return the model
+            self.then
+          else
             # Run the validations for all fields
             result = nil
             return validate!.then do
+              # Buffers only persist on .save!
+              if buffer?
+                nil
+              else
+                # valid model.  Save, then return the model
+                persist_changes(attribute_name)
+              end.then { self }
+              # ^ return the model
+            end.fail do |errors|
+              # invalid model
               # Buffers are allowed to be in an invalid state
               unless buffer?
                 # First check that all local validations pass.  Any time any
@@ -29,27 +44,24 @@ module Volt
                 # persist.  However, we want to be able to move the model
                 # towards a valid state one change at a time.
                 if error_in_changed_attributes?
-                  # Some errors are present, revert changes
+                  # Some errors are present in something that we changed.
                   revert_changes!
 
-                  # After we revert, we need to validate again to get the error messages back
+                  # 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)
+                  result = persist_changes(attribute_name).then
                 end
               end
 
-              # Return result inside of the validate! promise
-              result.then { self }
+              result
             end
           end
-
-          # Didn't run validations
-          self.then
         end
 
 
@@ -66,8 +78,15 @@ module Volt
             # 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)
+            unless buffer?
+              Volt::Model.no_validate do
+                if new?
+                  run_callbacks(:before_create)
+                else
+                  run_callbacks(:before_update)
+                end
+                run_callbacks(:before_save)
+              end
             end
 
             # the changed method on a persistor should return a promise that will

data/lib/volt/models/helpers/defaults.rb

@@ -0,0 +1,15 @@
+module Volt
+  module Models
+    module Helpers
+      module Defaults
+        def setup_defaults
+          self.class.defaults.each_pair do |field_name, default_value|
+            unless @attributes.has_key?(field_name)
+              @attributes[field_name] = default_value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/volt/models/location.rb

@@ -1,9 +1,23 @@
-class Location
-  def host
-    `document.location.host`
-  end
+module Volt
+  class Location
+    def host
+      if RUBY_PLATFORM == 'opal'
+        `document.location.host`
+      else
+        Volt.config.domain
+      end
+    end
+
+    def protocol
+      scheme + ':'
+    end
 
-  def protocol
-    `document.location.protocol`
+    def scheme
+      if RUBY_PLATFORM == 'opal'
+        `document.location.protocol`[0..-2]
+      else
+        Volt.config.scheme || 'http'
+      end
+    end
   end
 end

data/lib/volt/models/migrations/migration.rb

@@ -0,0 +1,23 @@
+# This is the base class for migrations.
+require 'volt/reactive/eventable'
+
+module Volt
+  class Migration
+    extend Eventable
+    def self.inherited(klass)
+      trigger!('inherited', klass)
+    end
+
+    def store
+      Volt.current_app.store
+    end
+
+    def up
+      raise "An up migration was not provided"
+    end
+
+    def down
+      raise "A down migration was not provided"
+    end
+  end
+end

data/lib/volt/models/migrations/migration_runner.rb

@@ -0,0 +1,146 @@
+# The migration runner runs the migrations and tracks the versions that have
+# been run.
+require 'volt/models/migrations/migration'
+
+module Volt
+  class DuplicateMigrationTimestamp < RuntimeError ; end
+
+  class MigrationRunner
+    # The args are passed to each Volt::Migration, (typically just the @db)
+    def initialize(*args)
+      @args = args
+      ensure_migration_versions_table
+    end
+
+    # Runs all migrations up
+    def run(direction=:up, util_version=nil)
+      # Get the disk versions
+      disk_version_paths = self.disk_versions
+      disk_versions = disk_version_paths.map {|v| v[0] }
+
+      # Get the db versions
+      ran_versions = self.all_versions
+
+      if direction == :up
+        # Run all that are on disk, but haven't been run (from the db)
+        need_to_run_versions = disk_versions - ran_versions
+
+        if util_version
+          # remove any versions > the util_version, since the user is saying run
+          # "up" migrations until we hit version X
+          need_to_run_versions.reject! {|version| version > util_version }
+        end
+      else
+        # Run down on all versions that are in the db.  If the file doesn't exist
+        need_to_run_versions = ran_versions
+
+        if util_version
+          # remove any versions < the util_version, since the user is saying run
+          # "up" migrations until we hit version X
+          need_to_run_versions.reject! {|version| version < util_version }
+        end
+      end
+
+      need_to_run_versions.each do |version|
+        path = disk_version_paths[version]
+
+        unless path
+          raise "The database has a migration version of #{version}, but no matching migration file could be found for the down migration"
+        end
+
+        run_migration(path, direction)
+      end
+    end
+
+    # Grab the version numbers and files for each migration on disk.  Raises an
+    # exception if two migrations have the same number
+    def disk_versions
+      versions = {}
+      Dir["#{Volt.root}/config/db/migrations/*.rb"].map do |path|
+        version = version_for_path(path)
+
+        if (path2 = versions[version])
+          raise DuplicateMigrationTimestamp, "Two migrations have the same version number: #{path} and #{path2}"
+        end
+
+        versions[version] = path
+      end
+
+      versions
+    end
+
+    def version_for_path(path)
+      File.basename(path)[/^[0-9]+/].to_i
+    end
+
+    # Get the number for all versions that have been run
+    def ran_versions
+      migration_versions.all.sync.map {|v| v.version }
+    end
+
+    def run_migration(path, direction=:up)
+      Volt.logger.info("Run #{direction} migration #{File.basename(path)}")
+      version = version_for_path(path)
+
+      # When we require, we use the inherited callback to figure out what class
+      # was loaded.
+      migration_klass = nil
+      listener = Volt::Migration.on('inherited') do |klass|
+        migration_klass = klass
+      end
+
+      require(path)
+
+      # Remove the inherited listener
+      listener.remove
+
+      unless migration_klass
+        raise "No class inheriting from Volt::Migration was defined in #{path}"
+      end
+
+      unless [:up, :down].include?(direction)
+        raise "Only up and down migrations are supported"
+      end
+
+      # Run the up migration
+      migration_klass.new(*@args).send(direction)
+
+      # Remove the object
+      Object.send(:remove_const, migration_klass.name.to_sym)
+
+      # Remove the require
+      $LOADED_FEATURES.reject! {|p| p == path }
+
+      if direction == :up
+        # Track that it ran
+        add_version(version)
+      else
+        # Remove that it ran
+        remove_version(version)
+      end
+    end
+
+    # Implement the following in your data provider to allow migrations.  We
+    # can't use Volt::Model until after the reconcile step has happened, so
+    # these methods need to work directly with the database.
+    def ensure_migration_versions_table
+      raise "not implemented"
+    end
+
+    def add_version(version)
+      raise "not implemented"
+    end
+
+    def has_version?(version)
+      raise "not implemented"
+    end
+
+    def remove_version(version)
+      raise "not implemented"
+    end
+
+    def all_versions
+      raise "not implemented"
+    end
+  end
+end