volt 0.9.6 → 0.9.7.pre2

data/lib/volt/cli/generators.rb

@@ -28,9 +28,9 @@ module Generators
       method_option :bin, type: :boolean, default: false, aliases: '-b', banner: 'Generate a binary for your library.'
       method_option :test, type: :string, lazy_default: 'rspec', aliases: '-t', banner: "Generate a test directory for your library: 'rspec' is the default, but 'minitest' is also supported."
       method_option :edit, type: :string, aliases: '-e',
-                           lazy_default: [ENV['BUNDLER_EDITOR'], ENV['VISUAL'], ENV['EDITOR']].find { |e| !e.nil? && !e.empty? },
-                           required: false, banner: '/path/to/your/editor',
-                           desc: 'Open generated gemspec in the specified editor (defaults to $EDITOR or $BUNDLER_EDITOR)'
+        lazy_default: [ENV['BUNDLER_EDITOR'], ENV['VISUAL'], ENV['EDITOR']].find { |e| !e.nil? && !e.empty? },
+        required: false, banner: '/path/to/your/editor',
+        desc: 'Open generated gemspec in the specified editor (defaults to $EDITOR or $BUNDLER_EDITOR)'
       method_option :coc, type: :boolean, desc: "Generate a code of conduct file. Set a default with `bundle config gem.coc true`."
       method_option :mit, type: :boolean, desc: "Generate an MIT license file"
 
@@ -100,6 +100,17 @@ module Generators
         controller(name, component) unless controller_exists?(name, component)
       end
 
+      desc 'migration NAME', 'creates a migration with the name specified'
+      method_option :name, type: :string, banner: 'The name of the migration file'
+      def migration(name)
+        timestamp = Time.now.to_i
+        file_name = "#{timestamp}_#{name.underscore}"
+        class_name = name.camelize
+        output_file = "#{Dir.pwd}/config/db/migrations/#{file_name}.rb"
+
+        template('migration/migration.rb.tt', output_file, class_name: class_name)
+      end
+
       private
 
       def controller_exists?(name, component = 'main')

data/lib/volt/cli/migrate.rb

@@ -0,0 +1,26 @@
+module Volt
+  module CliSubclasses
+    class Migrate < Thor
+      desc 'migrate up', 'migrate up'
+      method_option :version, type: :string, banner: 'Migrate up to the specified VERSION'
+      def up(version=nil)
+        Volt.boot(Dir.pwd)
+        require 'volt/models/migrations/migration_runner'
+
+        Volt::MigrationRunner.new.run(:up, version)
+      end
+
+      desc 'migrate down', 'migrate down'
+      method_option :version, type: :string, banner: 'Migrate down to the specified VERSION'
+      def down(version=nil)
+        Volt.boot(Dir.pwd)
+        require 'volt/models/migrations/migration_runner'
+
+        Volt::MigrationRunner.new.run(:down, version)
+      end
+
+      default_task :up
+
+    end
+  end
+end

data/lib/volt/config.rb

@@ -48,12 +48,25 @@ else
     class << self
       def defaults
         app_name = File.basename(Dir.pwd)
+
+        db_opts = {
+        }
+
+        # The user can use any DB_KEY to assign a value into the database
+        # config.
+        ENV.keys.grep(/^DB_/).each do |db_key|
+          db_opts[db_key.gsub(/^DB_/, '').downcase] = ENV[db_key]
+        end
+
         opts = {
           app_name:  app_name,
-          db_name:   (ENV['DB_NAME'] || (app_name + '_' + Volt.env.to_s)).gsub('.', '_'),
-          db_host:   ENV['DB_HOST'] || 'localhost',
-          db_port:   (ENV['DB_PORT'] || 27_017).to_i,
-          db_driver: ENV['DB_DRIVER'] || 'mongo',
+          db: db_opts,
+          # db_name:   (ENV['DB_NAME'] || (app_name + '_' + Volt.env.to_s)).gsub('.', '_'),
+          # db_host:   ENV['DB_HOST'] || 'localhost',
+          # db_port:   (ENV['DB_PORT'] || 27_017).to_i,
+          # db_driver: ENV['DB_DRIVER'] || 'postgres',
+          # ## TEMP
+          # db_uri: "postgres://ryanstout:@localhost:5432/#{(ENV['DB_NAME'] || (app_name + '_' + Volt.env.to_s)).gsub('.', '_')}",
 
           # a list of components which should be included in all components
           default_components: ['volt'],

data/lib/volt/controllers/http_controller.rb

@@ -65,6 +65,18 @@ module Volt
       response_body << body
     end
 
+    def send_file(path)
+      if File.exists?(path)
+        head(200, {})
+      else
+        raise "Invalid SendFile: #{path}"
+      end
+
+      # You can pass back a File to rack and it will stream from it and close it
+      # when its done.
+      @response_body = File.open(path, 'rb')
+    end
+
     def respond
       unless @response_status
         # render was not called, show an error

data/lib/volt/data_stores/base_adaptor_client.rb

@@ -24,8 +24,8 @@ module Volt
         Volt::ArrayModel.proxy_to_persistor(*method_names)
 
         method_names.each do |method_name|
-          Volt::Persistors::ArrayStore.send(:define_method, method_name) do |*args|
-            add_query_part(method_name, *args)
+          Volt::Persistors::ArrayStore.send(:define_method, method_name) do |*args, &block|
+            add_query_part(method_name, *args, &block)
           end
         end
       end

data/lib/volt/data_stores/base_adaptor_server.rb

@@ -1,6 +1,8 @@
 module Volt
   class DataStore
     class BaseAdaptorServer
+      def initialize(volt_app)
+      end
     end
   end
 end

data/lib/volt/data_stores/data_store.rb

@@ -1,23 +1,29 @@
 require 'volt/data_stores/base_adaptor_server'
+require 'thread'
 
 module Volt
   class DataStore
-    def self.fetch
-      # Cache the driver
-      return @adaptor if @adaptor
+    @@data_store_mutex = Mutex.new
 
-      database_name = Volt.config.db_driver
-      adaptor_name = database_name.camelize + 'AdaptorServer'
+    # TODO: cache based on volt_app
+    def self.fetch(volt_app)
+      @@data_store_mutex.synchronize do
+        # Cache the driver
+        return @adaptor if @adaptor
 
-      root = Volt::DataStore
-      if root.const_defined?(adaptor_name)
-        adaptor_name = root.const_get(adaptor_name)
-        @adaptor = adaptor_name.new
-      else
-        raise "#{database_name} is not a supported database, you might be missing a volt-#{database_name} gem"
-      end
+        database_name = Volt.config.db_driver
+        adaptor_name = database_name.camelize + 'AdaptorServer'
+
+        root = Volt::DataStore
+        if root.const_defined?(adaptor_name)
+          adaptor_name = root.const_get(adaptor_name)
+          @adaptor = adaptor_name.new(volt_app)
+        else
+          raise "#{database_name} is not a supported database (as configured by Volt.config.db_driver), you might be missing a volt-#{database_name} gem"
+        end
 
-      @adaptor
+        @adaptor
+      end
     end
 
     def self.adaptor_client
@@ -26,7 +32,7 @@ module Volt
         ds_name = Volt.config.public.datastore_name
         unless ds_name
           raise "No data store configured, please include volt-mongo or " +
-                "another similar gem."
+            "another similar gem."
         end
         adaptor_class_name = ds_name.capitalize + "AdaptorClient"
         Volt::DataStore.const_get(adaptor_class_name)

data/lib/volt/extra_core/class.rb

@@ -1,27 +1,41 @@
 class Class
   # Provides a way to make class attributes that inherit.  Pass
-  # in symbols for attribute names
+  # in symbols for attribute names.  When the class attribute is accessed from
+  # a sublcass, it will be duped.  This allows the children to receive the value
+  # from their parent, but then change it only in the child.
+  #
+  # NOTE: This does not do a deep clone, so multi-nested values may be changed.
   def class_attribute(*attrs)
     attrs.each do |name|
-      define_singleton_method(name) { nil }
+      name = name.to_sym
+      ivar = :"@#{name}"
 
-      ivar = "@#{name}"
+      assigner = :"#{name}="
+      define_singleton_method(assigner) do |val|
+        instance_variable_set(ivar, val)
+      end
+
+      define_singleton_method(name) do
+        if instance_variable_defined?(ivar)
+          # Get the value from the instance variable
+          val = instance_variable_get(ivar)
+        else
+          # Fetch from parent and dup
+          if superclass.respond_to?(name)
+            val = superclass.send(name)
+          else
+            val = nil
+          end
+          # We need the numeric check because of: https://github.com/opal/opal/issues/1122
+          unless val.is_a?(Numeric)
+            val = val.dup rescue val
+          end
 
-      define_singleton_method("#{name}=") do |val|
-        singleton_class.class_eval do
-          remove_possible_method(name)
-          define_method(name) { val }
+          instance_variable_set(ivar, val)
         end
 
         val
       end
     end
   end
-
-  # Removes a method if it is defined.
-  def remove_possible_method(method)
-    if method_defined?(method) || private_method_defined?(method)
-      undef_method(method)
-    end
-  end
 end

data/lib/volt/extra_core/hash.rb

@@ -5,4 +5,9 @@ class Hash
       keys.include?(key)
     end
   end
+
+  # multifetch - returns an array of values for the arg keys
+  def mfetch(*args)
+    args.map {|k| self[k] }
+  end
 end

data/lib/volt/extra_core/string.rb

@@ -16,7 +16,9 @@ class String
   # Returns the underscore version of a string.  If it is already underscore, it should
   # return the same string.
   def underscore
-    gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+    gsub('::', '/')
+    .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2')
+    .downcase
   end
 
   def dasherize

data/lib/volt/helpers/time.rb

@@ -1,43 +1,9 @@
-# Much of this class was borrowed from ActiveSupport:
-# https://github.com/rails/rails/blob/ca9736e78ca9348e785a5c78c8cc085c0c2d4731/activesupport/lib/active_support/core_ext/time/calculations.rb
-
-class Time
-  # Returns a new Time where one or more of the elements have been changed according
-  # to the +options+ parameter. The time options (<tt>:hour</tt>, <tt>:min</tt>,
-  # <tt>:sec</tt>, <tt>:usec</tt>) reset cascadingly, so if only the hour is passed,
-  # then minute, sec, and usec is set to 0. If the hour and minute is passed, then
-  # sec and usec is set to 0.  The +options+ parameter takes a hash with any of these
-  # keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>, <tt>:hour</tt>, <tt>:min</tt>,
-  # <tt>:sec</tt>, <tt>:usec</tt>.
-  #
-  #   Time.new(2012, 8, 29, 22, 35, 0).change(day: 1)              # => Time.new(2012, 8, 1, 22, 35, 0)
-  #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => Time.new(1981, 8, 1, 22, 35, 0)
-  #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => Time.new(1981, 8, 29, 0, 0, 0)
-  def change(options)
-    new_year  = options.fetch(:year, year)
-    new_month = options.fetch(:month, month)
-    new_day   = options.fetch(:day, day)
-    new_hour  = options.fetch(:hour, hour)
-    new_min   = options.fetch(:min, options[:hour] ? 0 : min)
-    new_sec   = options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec)
-    # new_usec  = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
-
-    # TODO: Opal doesn't have rational yet, so usec's don't get added in right yet
-    ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, utc_offset)
-  end
-
-  def beginning_of_day
-    #(self - seconds_since_midnight).change(usec: 0)
-    change(hour: 0, min: 0, sec: 0)
-  end
-
-   # Returns a new Time representing the end of the day, 23:59:59.999999 (.999999999 in ruby1.9)
-  def end_of_day
-    change(
-      hour: 23,
-      min: 59,
-      sec: 59,
-      # usec: Rational(999999999, 1000)
-    )
-  end
-end
+require 'time'
+require 'date'
+require 'volt/helpers/time/volt_time'
+require 'volt/helpers/time/local_volt_time' if RUBY_PLATFORM == 'opal'
+require 'volt/helpers/time/calculations'
+require 'volt/helpers/time/local_calculations' if RUBY_PLATFORM == 'opal'
+require 'volt/helpers/time/duration'
+require 'volt/helpers/time/numeric'
+require 'volt/helpers/time/distance'

data/lib/volt/helpers/time/calculations.rb

@@ -0,0 +1,204 @@
+# Much of this class was borrowed from ActiveSupport:
+# https://github.com/rails/rails/blob/ca9736e78ca9348e785a5c78c8cc085c0c2d4731/activesupport/lib/active_support/core_ext/time/calculations.rb
+
+class VoltTime
+  
+  COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+  
+  class << self
+    # Returns the number of days in a month. If no year is provided assumes
+    # the current year
+    def days_in_month(month, year = now.year)
+      if month == 2 && leap?(year)
+        29
+      else
+        COMMON_YEAR_DAYS_IN_MONTH[month]
+      end
+    end
+    
+    # Returns true if the year is a leap year, otherwise false
+    def leap?(year)
+      if year%400 == 0 || (year%4 == 0 && year%100 != 0)
+        true
+      else
+        false
+      end
+    end
+  end
+  
+  # Returns a new Time where one or more of the elements have been changed according
+  # to the +options+ parameter. The time options (<tt>:hour</tt>, <tt>:min</tt>,
+  # <tt>:sec</tt>, <tt>:usec</tt>) reset cascadingly, so if only the hour is passed,
+  # then minute, sec, and usec is set to 0. If the hour and minute is passed, then
+  # sec and usec is set to 0.  The +options+ parameter takes a hash with any of these
+  # keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>, <tt>:hour</tt>, <tt>:min</tt>,
+  # <tt>:sec</tt>
+  #
+  #   Time.new(2012, 8, 29, 22, 35, 0).change(day: 1)              # => Time.new(2012, 8, 1, 22, 35, 0)
+  #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => Time.new(1981, 8, 1, 22, 35, 0)
+  #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => Time.new(1981, 8, 29, 0, 0, 0)
+  def change(options)
+    new_year  = options.fetch(:year, year)
+    new_month = options.fetch(:month, month)
+    new_day   = options.fetch(:day, day)
+    new_hour  = options.fetch(:hour, hour)
+    new_min   = options.fetch(:min, options[:hour] ? 0 : min)
+    new_sec   = options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec)
+    VoltTime.new(:utc, new_year, new_month, new_day, new_hour, new_min, new_sec)
+  end
+
+  # Returns a new time that has been advanced according to the +options+
+  # parameter. The +options+ parameter is a hash with any of these keys:
+  # <tt>:years</tt>, <tt>:months</tt>, <tt>:days</tt>, <tt>:hours</tt>, <tt>:mins</tt>,
+  # <tt>:secs</tt>
+  def advance(options)
+    t = self
+    t = advance_years(options[:years]) if options[:years]
+    t = advance_months(options[:months]) if options[:months]
+    t = advance_days(options[:days]) if options[:days]
+    t = advance_hours(options[:hours]) if options[:hours]
+    t = advance_minutes(options[:mins]) if options[:mins]
+    t = advance_seconds(options[:secs]) if options[:secs]
+    t
+  end
+  
+  # Compares two VoltTime object to the given accuracy
+  # The +accuracy+ parameter can be <tt>:year</tt>, <tt>:month</tt>
+  # <tt>:day</tt>, <tt>:hour</tt>, <tt>:min</tt>, <tt>:sec</tt>
+  # Returns 0 if the two dates are the same to the required accuracy
+  # (e.g. the same year or the same day), 1 if the date called on is later
+  # than the parameter, or -1 if the date called on is earlier than the parameter
+  def compare(other, accuracy)
+    if accuracy == :year
+      year <=> other.year
+    elsif accuracy == :month
+      compare_date_components(other, :month, :year)
+    elsif accuracy == :day
+      compare_date_components(other, :day, :month)
+    elsif [:hour, :min, :sec].include? accuracy
+      change(accuracy => send(accuracy)) <=> other.change(accuracy => other.send(accuracy))  
+    end
+  end
+
+  def compare?(other, accuracy)
+    compare(other, accuracy) == 0 ? true : false
+  end 
+  
+  # Advances time by a number of years
+  def advance_years(years)
+    advance_to_date(to_date >> (years*12))
+  end
+
+  # Advances time by a number of months
+  def advance_months(months)
+    advance_to_date(to_date >> months)
+  end
+  
+  # Advances time by a number of days
+  def advance_days(days)
+    advance_to_date(to_date + days)
+  end
+  
+  # Advances time by a number of seconds
+  def advance_seconds(secs)
+    self + secs
+  end
+  
+  # Advances time by a number of hours
+  def advance_hours(hours)
+    self + (hours * 60 * 60)
+  end
+  
+  # Advances time by a number of minutes
+  def advance_minutes(mins)
+    self + (mins * 60)
+  end
+  
+  # Converts the time to a date
+  def to_date
+    Date.new(year, month, day)
+  end
+  
+  # Advances the time to the given date
+  def advance_to_date(date)
+    VoltTime.new(:utc, date.year, date.month, date.day, hour, min, sec + (usec/1.0e6))
+  end
+  
+  # Adds a duration to the time
+  def plus_with_duration(other)
+    if other.is_a?(Volt::Duration)
+    end
+  end
+  
+  # Returns a new VoltTime representing the beginning of the day, 00:00:00
+  def beginning_of_day
+    change(hour: 0, min: 0, sec: 0)
+  end
+
+  # Returns a new VoltTime representing the end of the day, 23:59:59.999
+  # Only milliseconds are supported in Opal
+  def end_of_day
+    VoltTime.new(:utc, year, month, day, 23, 59, 59.999)
+  end
+  
+  # Returns a new Time for the middle of the day i.e. 12:00:00
+  def middle_of_day
+    change(hour: 12)
+  end
+
+  # Returns the number of seconds since 00:00:00 of the current day
+  def seconds_since_midnight
+    to_f - change(hour: 0).to_f
+  end
+  
+  # Returns the number of seconds to the 23:59:59 of the current day
+  def seconds_until_end_of_day
+    end_of_day.to_f - to_f
+  end
+  
+  # Returns a new VoltTime for the number of seconds ago
+  def ago(seconds)
+    since(-seconds)
+  end
+  
+  # Returns a new VoltTime for the number of seconds since the current time
+  def since(seconds)
+    VoltTime.new.set_time(@time + seconds)
+  end
+  
+  # Returns a new Time for the beginning of the current hour
+  def beginning_of_hour
+    change(min: 0)
+  end
+
+  # Returns a new Time for the end of the current hour
+  # only milliseconds are supported in Opal
+  def end_of_hour
+    change(min: 59, sec: 59.999)
+  end
+  
+  # Returns a new Time for beginning of the current minute
+  def beginning_of_minute
+    change(sec: 0)
+  end
+  
+  # Returns a new Time for the end of the current minute
+  def end_of_minute
+    change(sec: 59.999)
+  end
+  
+  # Returns a Range for the start to end of day
+  def all_day
+    beginning_of_day..end_of_day
+  end
+ 
+  private
+    def compare_date_components(other, component, higher_component) 
+      if compare(other, higher_component) == 0
+        send(component) <=> other.send(component)
+      else
+        compare(other, higher_component)
+      end
+    end 
+  
+end