shattered 0.5.0.1 → 0.7.0

data/lib/shattered_support/core_ext/string.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/string/inflections'
+require File.dirname(__FILE__) + '/string/conversions'
+require File.dirname(__FILE__) + '/string/access'
+require File.dirname(__FILE__) + '/string/starts_ends_with'
+require File.dirname(__FILE__) + '/string/iterators'
+
+class String #:nodoc:
+  include ShatteredSupport::CoreExtensions::String::Access
+  include ShatteredSupport::CoreExtensions::String::Conversions
+  include ShatteredSupport::CoreExtensions::String::Inflections
+  include ShatteredSupport::CoreExtensions::String::StartsEndsWith
+  include ShatteredSupport::CoreExtensions::String::Iterators
+end

data/lib/shattered_support/core_ext/string/access.rb

@@ -0,0 +1,58 @@
+module ShatteredSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Makes it easier to access parts of a string, such as specific characters and substrings.
+      module Access
+        # Returns the character at the +position+ treating the string as an array (where 0 is the first character).
+        #
+        # Examples: 
+        #   "hello".at(0)  # => "h"
+        #   "hello".at(4)  # => "o"
+        #   "hello".at(10) # => nil
+        def at(position)
+          self[position, 1]
+        end
+        
+        # Returns the remaining of the string from the +position+ treating the string as an array (where 0 is the first character).
+        #
+        # Examples: 
+        #   "hello".from(0)  # => "hello"
+        #   "hello".from(2)  # => "llo"
+        #   "hello".from(10) # => nil
+        def from(position)
+          self[position..-1]
+        end
+        
+        # Returns the beginning of the string up to the +position+ treating the string as an array (where 0 is the first character).
+        #
+        # Examples: 
+        #   "hello".to(0)  # => "h"
+        #   "hello".to(2)  # => "hel"
+        #   "hello".to(10) # => "hello"
+        def to(position)
+          self[0..position]
+        end
+
+        # Returns the first character of the string or the first +limit+ characters.
+        #
+        # Examples: 
+        #   "hello".first     # => "h"
+        #   "hello".first(2)  # => "he"
+        #   "hello".first(10) # => "hello"
+        def first(limit = 1)
+          self[0..(limit - 1)]
+        end
+        
+        # Returns the last character of the string or the last +limit+ characters.
+        #
+        # Examples: 
+        #   "hello".last     # => "o"
+        #   "hello".last(2)  # => "lo"
+        #   "hello".last(10) # => "hello"
+        def last(limit = 1)
+          self[(-limit)..-1] || self
+        end
+      end
+    end
+  end
+end

data/lib/shattered_support/core_ext/string/conversions.rb

@@ -0,0 +1,19 @@
+require 'parsedate'
+
+module ShatteredSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Converting strings to other objects
+      module Conversions
+        # Form can be either :utc (default) or :local.
+        def to_time(form = :utc)
+          ::Time.send(form, *ParseDate.parsedate(self))
+        end
+
+        def to_date
+          ::Date.new(*ParseDate.parsedate(self)[0..2])
+        end
+      end
+    end
+  end
+end

data/lib/shattered_support/core_ext/string/inflections.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/../../inflector' unless defined? Inflector
+module ShatteredSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Makes it possible to do "posts".singularize that returns "post" and "MegaCoolClass".underscore that returns "mega_cool_class".
+      module Inflections
+        def pluralize
+          Inflector.pluralize(self)
+        end
+
+        def singularize
+          Inflector.singularize(self)
+        end
+
+        def camelize(first_letter = :upper)
+          case first_letter
+            when :upper then Inflector.camelize(self, true)
+            when :lower then Inflector.camelize(self, false)
+          end
+        end
+        alias_method :camelcase, :camelize
+
+        def titleize
+          Inflector.titleize(self)
+        end
+        alias_method :titlecase, :titleize
+
+        def underscore
+          Inflector.underscore(self)
+        end
+
+        def dasherize
+          Inflector.dasherize(self)
+        end
+
+        def demodulize
+          Inflector.demodulize(self)
+        end
+
+        def tableize
+          Inflector.tableize(self)
+        end
+
+        def classify
+          Inflector.classify(self)
+        end
+        
+        # Capitalizes the first word and turns underscores into spaces and strips _id, so "employee_salary" becomes "Employee salary" 
+        # and "author_id" becomes "Author".
+        def humanize
+          Inflector.humanize(self)
+        end
+
+        def foreign_key(separate_class_name_and_id_with_underscore = true)
+          Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+        end
+
+        def constantize
+          Inflector.constantize(self)
+        end
+      end
+    end
+  end
+end

data/lib/shattered_support/core_ext/string/iterators.rb

@@ -0,0 +1,17 @@
+require 'strscan'
+
+module ShatteredSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Custom string iterators
+      module Iterators
+        # Yields a single-character string for each character in the string.
+        # When $KCODE = 'UTF8', multi-byte characters are yielded appropriately.
+        def each_char
+          scanner, char = StringScanner.new(self), /./mu
+          loop { yield(scanner.scan(char) || break) }
+        end
+      end
+    end
+  end
+end

data/lib/shattered_support/core_ext/string/starts_ends_with.rb

@@ -0,0 +1,20 @@
+module ShatteredSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Additional string tests.
+      module StartsEndsWith
+        # Does the string start with the specified +prefix+?
+        def starts_with?(prefix)
+          prefix = prefix.to_s
+          self[0, prefix.length] == prefix
+        end
+
+        # Does the string end with the specified +suffix+?
+        def ends_with?(suffix)
+          suffix = suffix.to_s
+          self[-suffix.length, suffix.length] == suffix      
+        end
+      end
+    end
+  end
+end

data/lib/shattered_support/error.rb

@@ -0,0 +1,12 @@
+module Shattered
+  class Error < StandardError
+  end
+  
+  class MetaMethodError < StandardError # :nodoc:
+    attr_accessor :message 
+    def initialize(error, message)
+      self.message = message
+      set_backtrace error.backtrace
+    end
+  end
+end

data/lib/shattered_support/inflections.rb

@@ -0,0 +1,53 @@
+Inflector.inflections do |inflect|
+  inflect.plural(/$/, 's')
+  inflect.plural(/s$/i, 's')
+  inflect.plural(/(ax|test)is$/i, '\1es')
+  inflect.plural(/(octop|vir)us$/i, '\1i')
+  inflect.plural(/(alias|status)$/i, '\1es')
+  inflect.plural(/(bu)s$/i, '\1ses')
+  inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+  inflect.plural(/([ti])um$/i, '\1a')
+  inflect.plural(/sis$/i, 'ses')
+  inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+  inflect.plural(/(hive)$/i, '\1s')
+  inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+  inflect.plural(/([^aeiouy]|qu)ies$/i, '\1y')
+  inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+  inflect.plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
+  inflect.plural(/([m|l])ouse$/i, '\1ice')
+  inflect.plural(/^(ox)$/i, '\1en')
+  inflect.plural(/(quiz)$/i, '\1zes')
+
+  inflect.singular(/s$/i, '')
+  inflect.singular(/(n)ews$/i, '\1ews')
+  inflect.singular(/([ti])a$/i, '\1um')
+  inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
+  inflect.singular(/(^analy)ses$/i, '\1sis')
+  inflect.singular(/([^f])ves$/i, '\1fe')
+  inflect.singular(/(hive)s$/i, '\1')
+  inflect.singular(/(tive)s$/i, '\1')
+  inflect.singular(/([lr])ves$/i, '\1f')
+  inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+  inflect.singular(/(s)eries$/i, '\1eries')
+  inflect.singular(/(m)ovies$/i, '\1ovie')
+  inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+  inflect.singular(/([m|l])ice$/i, '\1ouse')
+  inflect.singular(/(bus)es$/i, '\1')
+  inflect.singular(/(o)es$/i, '\1')
+  inflect.singular(/(shoe)s$/i, '\1')
+  inflect.singular(/(cris|ax|test)es$/i, '\1is')
+  inflect.singular(/([octop|vir])i$/i, '\1us')
+  inflect.singular(/(alias|status)es$/i, '\1')
+  inflect.singular(/^(ox)en/i, '\1')
+  inflect.singular(/(vert|ind)ices$/i, '\1ex')
+  inflect.singular(/(matr)ices$/i, '\1ix')
+  inflect.singular(/(quiz)zes$/i, '\1')
+
+  inflect.irregular('person', 'people')
+  inflect.irregular('man', 'men')
+  inflect.irregular('child', 'children')
+  inflect.irregular('sex', 'sexes')
+  inflect.irregular('move', 'moves')
+
+  inflect.uncountable(%w(equipment information rice money species series fish sheep))
+end

data/lib/shattered_support/inflector.rb

@@ -0,0 +1,178 @@
+require 'singleton' 
+
+# The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without,
+# and class names to foreign keys. The default inflections for pluralization, singularization, and uncountable words are kept
+# in inflections.rb.
+module Inflector 
+  # A singleton instance of this class is yielded by Inflector.inflections, which can then be used to specify additional
+  # inflection rules. Examples:
+  #
+  #   Inflector.inflections do |inflect|
+  #     inflect.plural /^(ox)$/i, '\1\2en'
+  #     inflect.singular /^(ox)en/i, '\1'
+  #
+  #     inflect.irregular 'octopus', 'octopi'
+  #
+  #     inflect.uncountable "equipment"
+  #   end
+  #
+  # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+  # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+  # already have been loaded.
+  class Inflections
+    include Singleton
+    
+    attr_reader :plurals, :singulars, :uncountables
+    
+    def initialize
+      @plurals, @singulars, @uncountables = [], [], []
+    end
+    
+    # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression. 
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    def plural(rule, replacement)
+      @plurals.insert(0, [rule, replacement])
+    end
+    
+    # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression. 
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    def singular(rule, replacement)
+      @singulars.insert(0, [rule, replacement])
+    end
+
+    # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+    # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+    # 
+    # Examples:
+    #   irregular 'octopus', 'octopi'
+    #   irregular 'person', 'people'
+    def irregular(singular, plural)
+      plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+      singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+    end
+    
+    # Add uncountable words that shouldn't be attempted inflected.
+    # 
+    # Examples:
+    #   uncountable "money"
+    #   uncountable "money", "information"
+    #   uncountable %w( money information rice )
+    def uncountable(*words)
+      (@uncountables << words).flatten!
+    end
+    
+    # Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type,
+    # the options are: :plurals, :singulars, :uncountables
+    #
+    # Examples:
+    #   clear :all
+    #   clear :plurals
+    def clear(scope = :all)
+      case scope
+        when :all
+          @plurals, @singulars, @uncountables = [], [], []
+        else
+          instance_variable_set "@#{scope}", []
+      end
+    end
+  end
+
+  extend self
+
+  def inflections
+    if block_given?
+      yield Inflections.instance
+    else
+      Inflections.instance
+    end
+  end
+
+  def pluralize(word)
+    result = word.to_s.dup
+
+    if inflections.uncountables.include?(result.downcase)
+      result
+    else
+      inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+      result
+    end
+  end
+
+  def singularize(word)
+    result = word.to_s.dup
+
+    if inflections.uncountables.include?(result.downcase)
+      result
+    else
+      inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+      result
+    end
+  end
+
+  def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    else
+      lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
+    end
+  end
+
+  def titleize(word)
+    humanize(underscore(word)).gsub(/\b([a-z])/) { $1.capitalize }
+  end
+  
+  def underscore(camel_cased_word)
+    camel_cased_word.to_s.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+  
+  def dasherize(underscored_word)
+    underscored_word.gsub(/_/, '-')
+  end
+
+  def humanize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+  end
+
+  def demodulize(class_name_in_module)
+    class_name_in_module.to_s.gsub(/^.*::/, '')
+  end
+
+  def tableize(class_name)
+    pluralize(underscore(class_name))
+  end
+  
+  def classify(table_name)
+    camelize(singularize(table_name))
+  end
+
+  def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
+    underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
+  end
+
+  def constantize(camel_cased_word)
+    raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!" unless
+      /^(::)?([A-Z]\w*)(::[A-Z]\w*)*$/ =~ camel_cased_word
+    
+    camel_cased_word = "::#{camel_cased_word}" unless $1
+    Object.module_eval(camel_cased_word, __FILE__, __LINE__)
+  end
+
+  def ordinalize(number)
+    if (11..13).include?(number.to_i % 100)
+      "#{number}th"
+    else
+      case number.to_i % 10
+        when 1: "#{number}st"
+        when 2: "#{number}nd"
+        when 3: "#{number}rd"
+        else    "#{number}th"
+      end
+    end
+  end
+end
+
+require File.dirname(__FILE__) + '/inflections'

data/lib/shattered_support/pre_initialize.rb

@@ -0,0 +1,153 @@
+module PreInitialize #:nodoc:all
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+  
+  def self.included(mod)
+    return if mod == Object # This is to allow include Shattered::Timer at the top of files
+    class << mod
+      # This is overwritten to allow for a pre_initialize before initialize
+      def new(*options) #:nodoc
+        new_base = allocate
+        new_base.pre_initialize
+        new_base.send(:initialize, *options)
+        return new_base
+      end            
+    end
+  end
+  
+  BEFORE_INIT_CALL_VALUES = :before_init_call_values
+  BEFORE_INIT_SET_VALUES = :before_init_set_values
+  
+  module ClassMethods 
+
+    
+    # In the pre_initialization phase (see #before_init_call), send an object a bunch of sets.
+    #
+    # This is used in actor, camera, mesh, and virtually everywhere to support the format of:
+    #   mesh "ruby", :position => v(1,0,0)
+    #
+    # becomes 
+    #   before_init_set( :ruby, {:position => v(1,0,0) } )
+    # becomes
+    #   ruby.position=v(1,0,0)
+    # when the obect is initialized.
+    def before_init_set(variable, options={})
+      self.write_inheritable_array(BEFORE_INIT_SET_VALUES, [[ variable, options ]] )
+    end
+
+    # All shattered objects have a pre_initialization phase.  Use this to specify that
+    # a function should be called when the object is created.
+    #
+    # _Example_:
+    #   class BulletModel < ShatteredModel::Base
+    #     before_init_call(:calculate_trajectory, v(0,0,0), v(0,0,1))
+    #     def calculate_trajectory
+    #       #called before initialize is
+    #     end
+    #   end
+    #
+    def before_init_call(function, *arguments)
+      self.write_inheritable_array(BEFORE_INIT_CALL_VALUES, [[function, [*arguments]]])
+    end
+  end
+  module InstanceMethods
+  
+    protected
+    
+    def attr_define(accessor_level, name, value)
+      self.class.send("attr_#{accessor_level}".to_sym, "#{name}".to_sym)
+      instance_variable_set("@#{name}".to_sym, value) if !value.nil?
+    end
+
+    public
+    
+    # attr helpers.  These are instance level attr_* functions.
+    def attr_reader(*args)
+      name, value = args
+      attr_define(:reader, name, value)
+    end
+
+    # attr helpers.  These are instance level attr_* functions.    
+    # attr_writer accepts a value as the second argument
+    def attr_writer(*args)
+      name, value = args
+      attr_define(:writer, name, value)
+    end
+    
+    # attr helpers.  These are instance level attr_* functions.    
+    # attr_accessor accepts a value as the se      puts modcond argument
+    def attr_accessor(*args)
+      name, value = args
+      attr_define(:accessor, name, value)
+    end
+    
+   # This function is called after an object is allocated, but before it's initialized.
+    #
+    # See Shattered::ClassMethods#before_init_call for usage.
+    def pre_initialize #:nodoc:
+      pre_initialize_set
+      pre_initialize_call
+    end 
+
+    # Used in pre_initialize
+    def each_init_value(name) #:nodoc:
+      startup_attributes = self.class.read_inheritable_attribute( name ) || []
+      startup_attributes.each do |actor, options|
+        next if options.nil?
+        yield actor, options
+      end
+    end
+
+    # Used in pre_initialize for before_init_set
+    def pre_initialize_set #:nodoc:
+      each_init_value(BEFORE_INIT_SET_VALUES) do |variable, options|
+        call_object_function_for_each_key( variable, options )  
+      end
+    end
+
+    # Used in pre_initialize for before_init_call
+    def pre_initialize_call #:nodoc:
+        each_init_value(BEFORE_INIT_CALL_VALUES) do |function, args|
+          call_object_function( :self, function, args )  
+        end
+    end
+
+    def call_object_function_for_each_key( actor, options, evaluate_symbols=true )
+      options.each_pair do |action, params|
+        call_object_function actor, "#{action}=", params, evaluate_symbols
+      end
+    end
+
+		# TODO:  This is bad - this method needs to be refactored and/or nuked.
+    def call_object_function(actor, action, params, evaluate_symbols=true)
+      begin
+        if params.is_a?(Symbol) && evaluate_symbols 
+          params = eval(params.to_s) 
+        end
+      rescue NameError
+        puts "It is not advisable to pass #{params.inspect} to #{action.inspect} for #{actor.inspect}."
+        puts "  It will try to be evaluated.  Use a string instead."
+      end
+      begin
+      	if(actor.is_a?(String) || actor.is_a?(Symbol))
+        	sendee = eval(actor.to_s)
+      	else
+      		sendee = actor
+    		end
+        if(params.is_a? Array)
+          sendee.send( action.to_sym, *params )
+        else
+          sendee.send( action.to_sym, params )
+        end
+      rescue NoMethodError, ArgumentError => bang
+        message="Error upon #{actor.to_s}.send(#{action.to_sym.inspect}, #{params.inspect}):\n\r  #{bang.class}: \n\r\t #{bang.message}\n\r #{bang.backtrace[0]}\n\r"
+        bang = Shattered::MetaMethodError.new(bang,message)
+        raise bang
+      end
+    end
+  end
+end
+