shattered_support 0.3.2 → 0.3.3

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.rb

@@ -1,64 +1,2 @@
-require 'rubygems'
-
-class Object
-  def method_defined?(method)
-    return self.class.method_defined?(method)
-  end
-  
-  # This is a shorthand to define vector object coordinates.
-  #
-  # Creates a vector object at coordinates x,y,z
-  def v(x, y, z) 
-    Vector.new(x, y, z) 
-  end
-end
-
-class File #:nodoc:
-  # File.each_in_path will recursively look for all files, starting at the given path.
-  # It will yield with each result.
-  def self.each_in_path(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 self.find_by_extensions(paths, *extensions)
-    paths = [paths] if paths.is_a? String
-    extensions.collect! { |ext| ext[0].chr == "." ? ext[1..-1] : ext } # get rid of "." in ".ogg"
-    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
-  # See File#find_by_extensions
-  def self.find_by_extension(paths, extension)
-    find_by_extensions(paths, extension)
-  end
-end
-
-class Dir #:nodoc:
-  # Dir.each_in_path will recursively yield all non-hidden directories from the given path.
-  def self.each_in_path(path, &block)
-    return unless File.directory? path
-    yield path
-    foreach(path) do |directory|
-      next if directory =~ /\..*/
-      each_in_path("#{path}/#{directory}", &block)
-    end
-  end
-end
-
-require File.dirname(__FILE__)+"/base"
-require File.dirname(__FILE__)+"/runner"
+require 'shattered_support/core_ext'
+require 'shattered_support/inflector'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.10
+rubygems_version: 0.8.11
 specification_version: 1
 name: shattered_support
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
-date: 2006-06-04
+  version: 0.3.3
+date: 2006-07-18 00:00:00 -06:00
 summary: "Shattered Support:  Allows a common derivation point for shattered MVC."
 require_paths: 
-  - lib
+- lib
 email: 
 homepage: http://www.hastilymade.com
 rubyforge_project: 
@@ -18,25 +18,47 @@ bindir: bin
 has_rdoc: "true"
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
+signing_key: 
+cert_chain: 
 authors: []
+
 files: 
-  - lib/base.rb
-  - lib/runner.rb
-  - lib/shattered_support.rb
-  - lib/vector.rb
-  - lib/timer/timed_event.rb
-  - lib/timer/timer.rb
+- lib/shattered_support.rb
+- lib/shattered_support/core_ext.rb
+- lib/shattered_support/inflections.rb
+- lib/shattered_support/inflector.rb
+- lib/shattered_support/core_ext/class.rb
+- lib/shattered_support/core_ext/dir.rb
+- lib/shattered_support/core_ext/file.rb
+- lib/shattered_support/core_ext/numeric.rb
+- lib/shattered_support/core_ext/string.rb
+- lib/shattered_support/core_ext/class/attribute_accessors.rb
+- lib/shattered_support/core_ext/class/inheritable_attributes.rb
+- lib/shattered_support/core_ext/class/removal.rb
+- lib/shattered_support/core_ext/dir/search.rb
+- lib/shattered_support/core_ext/file/search.rb
+- lib/shattered_support/core_ext/numeric/time.rb
+- lib/shattered_support/core_ext/string/access.rb
+- lib/shattered_support/core_ext/string/conversions.rb
+- lib/shattered_support/core_ext/string/inflections.rb
+- lib/shattered_support/core_ext/string/iterators.rb
+- lib/shattered_support/core_ext/string/starts_ends_with.rb
 test_files: []
+
 rdoc_options: []
+
 extra_rdoc_files: []
+
 executables: []
+
 extensions: []
+
 requirements: 
-  - Shattered Support is a base for the rest of shattered.
-dependencies: []
+- Shattered Support is a base for the rest of shattered.
+dependencies: []
+

data/lib/base.rb

@@ -1,221 +0,0 @@
-
-$:.unshift(File.dirname(__FILE__)) unless
-$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-  
-require 'active_support'
-require 'timer/timer'
-require 'vector'
-
-module ShatteredSupport #:nodoc:
-  
-  BEFORE_INIT_CALL_VALUES = :before_init_call_values
-  BEFORE_INIT_SET_VALUES = :before_init_set_values
-
-
-  def self.append_features(base)
-    super
-    base.extend(ClassMethods)
-  end
-  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
-  class Base
-    
-    # This is overwritten to allow for a pre_initialize before initialize
-    def self.new(*options) #:nodoc
-      new_base = allocate
-      new_base.pre_initialize
-      new_base.send(:initialize, *options)
-      return new_base
-    end
-    
-    # Retrieve the current state
-    def state 
-      Configuration.environment[:state]
-    end
-    
-    # This function is called after an object is allocated, but before it's initialized.
-    #
-    # See ShatteredSupport::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
-
-    
-    # TODO - is this called anymore?
-    def update_event(time_elapsed) #:nodoc:
-      actors.each do |actor|
-        actor.update_actors(time_elapsed)
-        actor.update(time_elapsed)
-      end
-    end
-    
-    # remove_from_scene? should just be defined in model.
-    # Refactor? TODO
-    def remove_from_scene? #:nodoc:
-      return false
-    end
-    
-    # TODO outdated?
-    def update_actors(time_elapsed) #:nodoc:
-      update_event time_elapsed
-      remove_dead_actors
-    end
-    
-    # TODO outdated?
-    def remove_dead_actors #:nodoc:
-      actors.each do |actor|
-        remove_from_scene actor if actor.remove_from_scene?
-      end
-    end  
-    
-    # TODO outdated?
-    def remove_from_scene(actor)
-      actors.delete actor
-      actor.unload!
-    end
-
-    protected
-    def call_object_function_for_each_key( actor, options )
-      call_object_function(actor, :position=, options.delete(:position)) if options.has_key? :position
-      options.each_pair do |action, params|
-        call_object_function actor, "#{action}=", params
-      end
-    end
-    
-    def call_object_function(actor, action, params)
-      begin
-        if params.is_a? Symbol #|| (params.length == 1 && params[0].is_a?(Symbol)) this will allow substitution in before_init_call. This may not be intended behavior.
-          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
-        sendee = eval(actor.to_s)
-        sendee.send( action.to_sym, *params )
-      rescue NoMethodError, ArgumentError => bang
-        message="Error upon #{actor.to_s}.send(#{action.to_sym.inspect}, #{params.inspect}):\n\r  #{bang.class}: #{bang.message}"
-        bang = ShatteredSupport::RetossError.new(bang,message)
-        raise bang
-      end
-    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 second argument
-    def attr_accessor(*args)
-      name, value = args
-      attr_define(:accessor, name, value)
-    end
-    
-    # Define a block to execute when an object is unloaded.
-    def when_unloaded(&block)
-      @unloaded_events ||= []
-      @unloaded_events << block
-    end
-    
-    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
-
-    private
-    
-    def disabled?
-      @unloaded_events == nil
-    end
-    
-    def unload!
-      return if disabled?
-      @unloaded_events.each do |event|
-        event.call
-      end
-      @unloaded_events = nil
-    end
-    
-  end
-  
-  class Error < StandardError # :nodoc:
-  end
-  
-  class RetossError < StandardError # :nodoc:
-    attr_accessor :message 
-    def initialize(error, message)
-      self.message = message
-      set_backtrace error.backtrace
-    end
-  end
-end
-
-ShatteredSupport::Base.class_eval do
-	include ShatteredSupport::Timer
-end

data/lib/runner.rb

@@ -1,11 +0,0 @@
-module ShatteredSupport
-  class Configuration #:nodoc:
-    def self.environment
-      @@environment={} unless defined? @@environment
-      return @@environment 
-    end
-    def self.environment=(environment)
-      @@environment=environment
-    end
-  end
-end

data/lib/timer/timed_event.rb

@@ -1,77 +0,0 @@
-module ShatteredSupport
-  module Timer #:nodoc:all
-    
-    class Timer
-      attr_reader :events_remaining
-      def initialize
-        @events_remaining = []
-      end
-      def in(seconds, &block)
-        @events_remaining << TimedEvent.new(seconds, &block)
-      end
-      def every(seconds, &block)
-        @events_remaining << ContinuousTimedEvent.new(seconds,&block)
-      end
-      def update(time_elapsed)
-        events_for_update = @events_remaining.dup
-        events_for_update.each do |event|
-          event.update(time_elapsed)
-          @events_remaining.delete(event) if event.processed?
-        end
-      end
-    end
-
-    class TimedEvent
-      attr_accessor :time_remaining
-      def initialize(seconds, &block)
-        @event = block
-        if(seconds != :frame)
-          @time_remaining = seconds
-          @initial_time = @time_remaining
-        else
-          @time_remaining = 0
-          @initial_time = 0
-        end
-      end
-      def update(time_elapsed)
-        return if processed?
-        @time_remaining -= time_elapsed
-        if time_up?
-          process_event
-          @processed=true
-        end
-      end
-      def processed?
-        return @processed == true
-      end
-      def reset
-        @time_remaining = @initial_time
-      end
-      private
-      def process_event
-        @event.call(@initial_time - @time_remaining)
-      end
-      def time_up?
-        return @time_remaining <= 0
-      end
-    end
-
-    class ContinuousTimedEvent < TimedEvent
-      def update(time_elapsed)
-        @time_remaining -= time_elapsed
-        if(time_up?)
-          process_event
-          reset
-        end
-      end
-      def reset
-        @time_remaining += @initial_time
-        @time_remaining = 0 if @time_remaining < 0
-      end
-      def processed?
-        false
-      end
-    end
-
-  end
-end

data/lib/timer/timer.rb

@@ -1,67 +0,0 @@
-require File.dirname(__FILE__)+'/timed_event'
-
-module ShatteredSupport
-  module Timer #:nodoc:
-    def self.append_features(base)
-      super
-      base.extend(ClassMethods)
-      base.send(:include, InstanceMethods)
-    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 ShatteredSupport::Error, 
-            "Timer event must specify an :action => :method" 
-        end
-        if options[:in].nil? && options[:every].nil?
-          throw ShatteredSupport::Error,
-            "Timer event must specify a time.  (timer :in or timer :every)"
-        end
-        time = options[:in] || options[:every]
-        action = options[:action]
-        before_init_call(:timer_in, time, action) unless options[:in].nil?
-        before_init_call(:timer_every, time, action) unless options[:every].nil?
-      end
-    end
-    module InstanceMethods
-      def timer
-        @timer ||= Timer.new
-      end
-      private
-        def timer_in(time, action)
-          timer.in(time) do |time_elapsed| 
-            timer_enactment(action, time_elapsed)
-          end
-        end
-        def timer_every(time, action)
-          timer.every(time) do |time_elapsed|
-            timer_enactment(action, time_elapsed)
-          end
-        end
-        def timer_enactment(action, time_elapsed)
-            begin
-              send(action.to_sym)
-            rescue ArgumentError => argument_error
-              raise argument_error unless argument_error.message.to_sym == :"wrong number of arguments (0 for 1)"
-              send(action.to_sym,time_elapsed)
-            end
-        end
-    end
-  end
-end