shattered 0.5.0.1 → 0.7.0

data/lib/shattered_model/timer.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__)+'/timed_event'
+
+module Shattered
+  module Timer #:nodoc:
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+      base.send(:include, PreInitialize)
+      base.send(:include, Unload)
+    end
+    module ClassMethods
+      # Timers are controller events that occur after a specified period of time.
+      # The time values are seconds by default.
+      #
+      # timer :in
+      #  If you want an event to occur once after a specified amount of time, use
+      #     timer :in => 3.seconds, :action => :method_to_call
+      #
+      # timer :every
+      #  If you want an event to occur once every specified amount of time, use
+      #     timer :every => 3.seconds, :action => :method_to_call
+      #  If you want to be notified of every frame update, use
+      #     timer :every => :frame, :action => :method_to_call
+      #
+      # Inside the instance, you can still create timer events, using the timer object:
+      #    timer.in( 3.seconds ) { ... }
+      #    timer.every( 3.seconds ) { ... }
+      def timer(options = {})
+        if options[:action].nil?
+          throw Shattered::Error, 
+            "Timer event must specify an :action => :method" 
+        end
+        if options[:in].nil? && options[:every].nil?
+          throw Shattered::Error,
+            "Timer event must specify a time.  (timer :in or timer :every)"
+        end
+        time = options[:in] || options[:every]
+        action = options[:action]
+        before_init_call(:create_timer, :in, time, action, options) unless options[:in].nil?
+        before_init_call(:create_timer, :every, time, action, options) unless options[:every].nil?
+      end
+    end
+    module InstanceMethods
+      def timer
+        unless(@timer)
+          @timer = Timer.new(self)
+          on_unload do
+            @timer.destroy
+          end
+        end
+        @timer
+      end
+      private
+        def create_timer(type, time, action, options)
+          timer.send(type, time, options) do |time_elapsed| 
+            timer_enactment(action, time_elapsed)
+          end
+        end
+        def timer_enactment(action, time_elapsed)
+            begin
+              if(action.is_a? Hash)
+                if(action.values[0].is_a?(Array))
+                  send(action.keys[0], *(action.values[0]))
+                else
+                  send(action.keys[0], action.values[0])
+                end
+              else
+                send(action.to_sym)
+              end
+            rescue ArgumentError => argument_error
+              raise argument_error unless argument_error.message.to_sym == "wrong number of arguments (0 for 1)".to_sym
+              send(action.to_sym,time_elapsed)
+            end
+        end
+    end
+  end
+end

data/lib/shattered_support/core_ext.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/core_ext/*.rb"].each { |file| require(file) }

data/lib/shattered_support/core_ext/class.rb

@@ -0,0 +1,3 @@
+require File.dirname(__FILE__) + '/class/attribute_accessors'
+require File.dirname(__FILE__) + '/class/inheritable_attributes'
+require File.dirname(__FILE__) + '/class/removal'

data/lib/shattered_support/core_ext/class/attribute_accessors.rb

@@ -0,0 +1,44 @@
+# Extends the class object with class and instance accessors for class attributes,
+# just like the native attr* accessors for instance attributes.
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end

data/lib/shattered_support/core_ext/class/inheritable_attributes.rb

@@ -0,0 +1,115 @@
+# Retain for backward compatibility.  Methods are now included in Class.
+module ClassInheritableAttributes # :nodoc:
+end
+
+# Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
+# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+# to, for example, an array without those additions being shared with either their parent, siblings, or
+# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+class Class # :nodoc:
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}
+          read_inheritable_attribute(:#{sym})
+        end
+
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_array_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_hash_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
+  end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
+  end
+
+  def inheritable_attributes
+    @inheritable_attributes ||= {}
+  end
+  
+  def write_inheritable_attribute(key, value)
+    inheritable_attributes[key] = value
+  end
+  
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
+  end
+  
+  def reset_inheritable_attributes
+    inheritable_attributes.clear
+  end
+
+  private 
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+      child.instance_variable_set('@inheritable_attributes', inheritable_attributes.dup)
+    end
+
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end

data/lib/shattered_support/core_ext/class/removal.rb

@@ -0,0 +1,24 @@
+class Class #:nodoc:
+  def remove_subclasses
+    Object.remove_subclasses_of(self)
+  end
+
+  def subclasses
+    Object.subclasses_of(self).map { |o| o.to_s }
+  end
+
+  def remove_class(*klasses)
+    klasses.flatten.each do |klass|
+      # Skip this class if there is nothing bound to this name
+      next unless defined?(klass.name)
+      
+      basename = klass.to_s.split("::").last
+      parent = klass.parent
+      
+      # Skip this class if it does not match the current one bound to this name
+      next unless parent.const_defined?(basename) && klass = parent.const_get(basename)
+      
+      parent.send :remove_const, basename unless parent == klass
+    end
+  end
+end

data/lib/shattered_support/core_ext/dir.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/dir/search'
+
+class Dir
+	include ShatteredSupport::CoreExtensions::Dir::Search
+end

data/lib/shattered_support/core_ext/dir/search.rb

@@ -0,0 +1,25 @@
+module ShatteredSupport #:nodoc:
+	module CoreExtensions #:nodoc:
+		module Dir #:nodoc:
+			module Search #:nodoc:
+        def self.append_features(base) #:nodoc:
+          super
+          base.extend(ClassMethods)
+        end
+        
+				# Dir.each_in_path will recursively yield all non-hidden 
+				# directories from the given path.
+				module ClassMethods
+					def each_in_path(path, &block)
+						raise Errno::ENOENT.new("Path not found: '#{path}'") unless ::File.directory? path
+						yield path
+						foreach(path) do |directory|
+							next if directory =~ /\..*/
+							each_in_path("#{path}/#{directory}", &block) if ::File.directory?("#{path}/#{directory}")
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/shattered_support/core_ext/file.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/file/search'
+
+class File
+	include ShatteredSupport::CoreExtensions::File::Search
+end

data/lib/shattered_support/core_ext/file/search.rb

@@ -0,0 +1,64 @@
+module ShatteredSupport #:nodoc:
+	module CoreExtensions #:nodoc:
+		module File #:nodoc:
+			module Search #:nodoc:
+        def self.append_features(base) #:nodoc:
+          super
+          base.extend(ClassMethods)
+        end
+
+				module ClassMethods
+					# File.each_in_path will recursively look for all files, 
+					# starting at the given path.
+					# It will yield with each result.
+					def each_in_path(path)
+					  raise Errno::ENOENT.new("Path not found: '#{path}'") unless ::File.directory? path
+						
+						::Dir.each_in_path(path) do |directory|
+							::Dir.foreach( directory ) do |filename|
+								resource = directory + "/#{filename}"
+								yield(resource) if ::File.file? resource
+							end
+						end
+					end
+					
+					# This finds all files in paths (an array or string) 
+					# matching the given extensions:
+					#
+					# Usage:
+					#   -File.find_by_extensions(SHATTERED_ROOT,"ogg","mp3","wav")
+					#   -File.find_by_extension(["apps","media","plugins"], "rmaterial")
+					def find_by_extensions(paths, *extensions)
+						paths = [paths] if paths.is_a? ::String
+						# get rid of "." in ".ogg"
+						extensions.collect! { |ext| ext[0].chr == "." ? ext[1..-1] : ext }
+						reg_exp = /\.(#{extensions.join("|")})$/
+						files = []
+						paths.each do |path|
+							each_in_path(path) do |filename|
+								files << filename if filename =~ reg_exp
+							end
+						end
+						return files
+					end
+					
+					# Finds the first file matching 'file' in the given paths.
+					def find(paths, file)
+						paths = [paths] if paths.is_a? ::String
+						paths.each do |path|
+							each_in_path(path) do |resource|
+								return resource if resource.ends_with?(file)
+							end
+						end
+						raise StandardError.new("File not found #{file}")
+					end
+					
+					# See File#find_by_extensions
+					def find_by_extension(paths, extension)
+						find_by_extensions(paths, extension)
+					end
+				end
+			end
+		end
+	end
+end

data/lib/shattered_support/core_ext/numeric.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/numeric/time'
+
+class Numeric #:nodoc:
+  include ShatteredSupport::CoreExtensions::Numeric::Time 
+end

data/lib/shattered_support/core_ext/numeric/time.rb

@@ -0,0 +1,72 @@
+module ShatteredSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Numeric #:nodoc:
+      # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
+      #
+      # If you need precise date calculations that doesn't just treat months as 30 days, then have
+      # a look at Time#advance.
+      # 
+      # Some of these methods are approximations, Ruby's core 
+      # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and 
+      # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
+      # date and time arithmetic
+      module Time
+        def seconds
+          self
+        end
+        alias :second :seconds
+
+        def minutes
+          self * 60
+        end
+        alias :minute :minutes  
+        
+        def hours
+          self * 60.minutes
+        end
+        alias :hour :hours
+        
+        def days
+          self * 24.hours
+        end
+        alias :day :days
+
+        def weeks
+          self * 7.days
+        end
+        alias :week :weeks
+        
+        def fortnights
+          self * 2.weeks
+        end
+        alias :fortnight :fortnights
+        
+        def months
+          self * 30.days
+        end
+        alias :month :months
+
+        def years
+          (self * 365.25.days).to_i
+        end
+        alias :year :years
+
+        # Reads best without arguments:  10.minutes.ago
+        def ago(time = ::Time.now)
+          time - self
+        end
+
+        # Reads best with argument:  10.minutes.until(time)
+        alias :until :ago
+
+        # Reads best with argument:  10.minutes.since(time)
+        def since(time = ::Time.now)
+          time + self
+        end
+
+        # Reads best without arguments:  10.minutes.from_now
+        alias :from_now :since
+      end
+    end
+  end
+end