i18n_scopes 0.0.1 → 0.2.0

data/README.md

@@ -30,28 +30,33 @@ Or install it yourself as:
 ### In your class (for example Controller)
     
     class Local::ExampleController < ActionController::Base
-      i18n_scope [:class_name, :translation, :action_name], :strip_controller_suffix => true, :plural_class => false
+      i18n_default_scope :class_name, :translation, :action_name, :strip_controller_suffix => true, :plural_class => false
+      i18n_scope :flash, :class_name, :action_name, :flashes
 
       def index
         @post = Post.new
         self.examples
       end
 
+      protected
       def examples
-        # the scoped_t method will inherit the path from the i18n_scope method
-        scoped_t :name # => [:example, :translation, :index, :name]
+        # the t_scoped method will inherit the path from the i18n_scope method
+        t_scoped :name # => [:example, :translation, :index, :name]
 
         # the path can be overwritten with an option
-        scoped_t :name, :path => [:elsewhere] # => [:elsewhere, :name]
+        t_scoped :name, :path => :elsewhere # => [:elsewhere, :name]
 
         # the path can be extended through the :path_extension options, it'll be attached to the end of path
-        scoped_t :name, :path_extension => [:flash], # => [:example, :translation, :index, :flash, :name]
+        t_scoped :name, :path_extension => :flash, # => [:example, :translation, :index, :flash, :name]
 
         # it's also possible to use local methods as path, in this example :modules_with_extension will be called, note that 
-        scoped_t :name, :path_extension => [:modules_with_extension] # => [:example, :translation, :index, :local_modules, :name]
+        t_scoped :name, :path_extension => :modules_with_extension # => [:example, :translation, :index, :local_modules, :name]
 
         # in this example, the post object will be given as argument, @post will respond to :post_scope and returns :normal
-        scope_t :name, :path_extension => [:post_scope], :respondable => [@post] # => [:example, :translation, :index, :normal, :name]
+        t_scoped :name, :path_extension => :post_scope, :respondable => @post # => [:example, :translation, :index, :normal, :name]
+
+        # this will call the named scope +t_flash+ and extend it with a path_extension
+        t_flash :name, :path_extension => :success # => [:example, :index, :flashes, :sucess, :name]
       end
 
       def modules_with_extension(modules)

data/i18n_scopes.gemspec

@@ -5,7 +5,7 @@ Gem::Specification.new do |gem|
   gem.authors       = ["menostos"]
   gem.email         = ["menostos@gmail.com"]
   gem.description   = %q{A gem for adding dynamic scopes to classes}
-  gem.summary       = %q{This gem will attach a scoped_t method to your class. The scope will be configureable in your class or globally.}
+  gem.summary       = %q{This gem will attach a t_scoped method to your class. The scope will be configureable in your class or globally.}
   gem.homepage      = "http://github.com/menostos/i18n_scopes"
 
   gem.files         = `git ls-files`.split($\)

data/lib/i18n_scopes.rb

@@ -1,5 +1,6 @@
 
 require 'i18n_scopes/scope'
+require 'i18n_scopes/option_accessor'
 require 'i18n_scopes/configuration'
 require 'i18n_scopes/translation_methods'
 require 'i18n_scopes/translation_helper'

data/lib/i18n_scopes/configuration.rb

@@ -2,58 +2,47 @@
 # see I18nScopes::Configuration
 module I18nScopes
 
-	# use this method to configure I18nScopes
-	#
-	#   I18nScopes.configure do |config|
-	#     config.plural_classes = false
-	#     config.strip_controller_suffix = true
-	#     config.attach_to ActionController::Base, YourCustomClass, EtcClass
-	#   end
-	def self.configure # :yield: config
-		yield self.configuration
-	end
-
-	# returns the Configuration
-	def self.configuration
-		@configuration ||= Configuration.new
-	end
-
-	# this class is used to hold the global configuration made for I18nScopes
-	class Configuration
-
-		attr_accessor :plural_classes
-		attr_accessor :strip_controller_suffix
-
-		# Attach the I18nScope methods to the given class or classes
-		#
-		# === Params:
-		# * +klasses+:: +Class+ one or more Class the include the I18nScopes methods
-		#
-		#   I18nScopes.configuration.attach_to ActionController::Base, YourCustomClass, EtcClass
-		def attach_to(*klasses)
-			klasses.each do |klass|
-				klass.send :include, I18nScopes::Scope
-			end
-		end
-
-		# accessor for plural_classes options
-		def plural_classes
-			@plural_classes ||= false
-		end
-
-		# accessor for strip_controller_suffix options
-		def strip_controller_suffix
-			@strip_controller_suffix ||= true
-		end
-
-		# returns the Configuration as option Hash
-		def as_options
-			{
-				:plural_classes 					=> self.plural_classes,
-				:strip_controller_suffix 	=> self.strip_controller_suffix
-			}
-		end
-
-	end
+  # use this method to configure I18nScopes
+  #
+  #   I18nScopes.configure do |config|
+  #     config.plural_classes = false
+  #     config.strip_controller_suffix = true
+  #     config.attach_to ActionController::Base, YourCustomClass, EtcClass
+  #   end
+  def self.configure # :yield: config
+    yield self.configuration
+  end
+
+  # returns the Configuration
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # this class is used to hold the global configuration made for I18nScopes
+  class Configuration
+
+    include I18nScopes::OptionAccessor
+
+    option_accessor :plural_classes,          false
+    option_accessor :strip_controller_suffix, true
+
+    # Attach the I18nScope methods to the given class or classes
+    #
+    # === Params:
+    # * +klasses+:: +Class+ one or more Class the include the I18nScopes methods
+    #
+    #   I18nScopes.configuration.attach_to ActionController::Base, YourCustomClass, EtcClass
+    def attach_to(*klasses)
+      klasses.each do |klass|
+        klass.send :include, I18nScopes::Scope
+      end
+    end
+
+    # returns the Configuration as option Hash
+    def as_options
+      return self.options
+    end
+
+  end
 
 end

data/lib/i18n_scopes/option_accessor.rb

@@ -0,0 +1,48 @@
+module I18nScopes
+  
+  # creates an option_accessor class method, to help create an options hash
+  module OptionAccessor
+
+    extend ActiveSupport::Concern
+
+    # accessor for all options
+    def options
+      @options ||= self.create_options
+    end
+
+    protected
+    # create options with all default options in it
+    def create_options
+      options = Hash.new
+      self.class.default_options.each do |option, value|
+        options[option] = value
+      end
+      return options
+    end
+
+    module ClassMethods
+
+      # creates accessor for options
+      # === Params:
+      # * +option+: the option key
+      # * +default+: the default option
+      def option_accessor(option, default = nil)
+        self.default_options[option] = default
+        define_method(option) do
+          self.options[option.to_sym] ||= default
+        end
+        define_method(:"#{option}=") do |value|
+          self.options[option.to_sym] = value
+        end
+      end
+
+      # default options
+      def default_options
+        @default_options ||= {}
+      end
+
+    end
+
+  end
+
+end

data/lib/i18n_scopes/scope.rb

@@ -1,43 +1,70 @@
 module I18nScopes
 
-    # This module can be included to get the i18n_scope method on every class
-    # 
-    # this can also be achieved using the Configuration#attach_to method from the Configuration
-    #
-    # === Usage:
-    #
-    #  class Example
-    #    include I18nScopes::Scope
-    #  end
-  	module Scope
+  # This module can be included to get the i18n_scope method on every class
+  # 
+  # this can also be achieved using the Configuration#attach_to method from the Configuration
+  #
+  # === Usage:
+  #
+  #  class Example
+  #    include I18nScopes::Scope
+  #  end
+  module Scope
 
-  		extend ActiveSupport::Concern
+    extend ActiveSupport::Concern
 
-  		module ClassMethods
+    module ClassMethods
 
-    		attr_accessor :i18n_scope_helper
+      attr_accessor :i18n_scope_helper
 
-  			# Use this method to configure how the scope will be built when using translations
-        # === Params:
-        # * +path+: Either a single String or Symbol, or an Array of Symbols and Strings
-        # * +options+: options to be used within this class, they will overwrite the configuration made in Configuration
-        #   * :plural_class: if the class name should be pluralized or singularized
-        #   * :strip_controller_suffix: if the _controller suffix of classes should be stripped or not
-  			# 
-  			# == Usage:
-        #   i18n_scope [:modules, :class_name, :action_name, :custom_value, "static_prefix"], :plural_class => true, :strip_controller_suffix => true
-        #
-        # with a Tweets::PostsController, the action index and a custom_value method that returns a_value this will led to the following scope:
-        #
-        #   [:tweets, :posts, :index, :a_value, "static_prefix"]
-  			def i18n_scope(path, options = {})
-  				path = [path] unless path.is_a?(Array)
-  				self.i18n_scope_helper = I18nScopes::TranslationHelper.new(path, options)
-  				self.send :include, I18nScopes::TranslationMethods          
-  			end
-			
-		end
-		
-	end
+      # Use this method to configure how the scope will be built when using translations
+      # === Params:
+      # * +path+: Either a single String or Symbol, or an Array of Symbols and Strings
+      # * +options+: options to be used within this class, they will overwrite the configuration made in Configuration
+      #   * :plural_class: if the class name should be pluralized or singularized
+      #   * :strip_controller_suffix: if the _controller suffix of classes should be stripped or not
+      # 
+      # == Usage:
+      #   i18n_scope :flash, :modules, :class_name, :action_name, :custom_value, "static_prefix", :plural_class => true, :strip_controller_suffix => true
+      #
+      # this will create a +t_flash+ method
+      #
+      # with a Tweets::PostsController, the action index and a custom_value method that returns a_value this will led to the following scope:
+      #
+      #   [:tweets, :posts, :index, :a_value, "static_prefix"]
+      def i18n_scope(name, *path)
+        @i18n_scope_initialized ||= begin
+          self.send :include, I18nScopes::TranslationMethods
+          self.i18n_scope_helper ||= {}
+          true
+        end
+        options = path.extract_options!
+        as = options.delete(:as) || :"t_#{name}"
+        self.i18n_scope_helper[name] = I18nScopes::TranslationHelper.new(path.flatten, options)
+
+        define_method(as) do |*args|
+          i18n_scope_helper = self.class.i18n_scope_helper[name]
+          klass = self.class
+          while(!i18n_scope_helper && klass.superclass != Object)
+            klass = klass.superclass
+            i18n_scope_helper = klass.i18n_scope_helper[name]
+          end
+          scoped_translation(i18n_scope_helper, *args)
+        end
+      end
+
+      # this method creates a default scope
+      # this is equivalent to calling
+      #   i18n_scope :default, :as => :t_scoped
+      def i18n_default_scope(*path)
+        options = path.extract_options!
+        options[:as] ||= :t_scoped
+        path << options
+        i18n_scope(:default, *path)
+      end
+    
+  end
+    
+  end
   
 end

data/lib/i18n_scopes/translation_helper.rb

@@ -1,147 +1,151 @@
 module I18nScopes
 
-	# this class provides helper methods to determine the actual scope in your class
-	class TranslationHelper
+  # this class provides helper methods to determine the actual scope in your class
+  class TranslationHelper
 
-		CONTROLLER_SUFFIX = "_controller"
+    CONTROLLER_SUFFIX = "_controller"
 
-		attr_accessor :path
-		attr_accessor :options
+    attr_accessor :path
+    attr_accessor :options
 
-		# === Params:
-		# * +path+: the path from i18n_scope
-		# * +options+ the options from i18n_scope
-		def initialize(path, options = {})
-			self.path 		= path
-			self.options 	= I18nScopes.configuration.as_options.merge(options)
-		end
+    # === Params:
+    # * +path+: the path from i18n_scope
+    # * +options+ the options from i18n_scope
+    def initialize(path, options = {})
+      self.path     = path
+      self.options  = I18nScopes.configuration.as_options.merge(options)
+    end
 
-		# === Params:
-		# * +object+: the object which is doing a translation
-		# * +options+: additional options for this translation
-		# * +parameter_matchings+: a Hash providing arguments to custom methods
-		def scope_from_path(object, options, parameter_matchings)
-			scope = []
-			custom_path  = options.delete(:path) 				|| self.path
-			custom_path += options.delete(:path_extension)		|| []
-			respondables = [object]
-			respondables += options.delete(:respondable)		if options.include?(:respondable)
-			respondables << self # add self at last
-			custom_path.each do |path_name|
-				if path_name.is_a?(Symbol)
-					respondable = respondables.find{ |respondable| respondable.respond_to?(path_name) } # find a respondable which responds_to path_name
-					if respondable
-						result = value_from_method_call(respondable, respondables, path_name, parameter_matchings) # call the path_name method on the respondable
-						if result.is_a?(Array)
-							scope += result # add all entries of an array
-						else
-							scope << result
-						end
-					else
-						scope << path_name # no object is respondable for this path_name, so just add the symbol to the scope
-					end
-				elsif path_name.is_a?(String)
-					scope << path_name
-				end
-			end
-			return scope
-		end
+    # === Params:
+    # * +object+: the object which is doing a translation
+    # * +options+: additional options for this translation
+    # * +parameter_matchings+: a Hash providing arguments to custom methods
+    def scope_from_path(object, options, parameter_matchings)
+      scope = []
+      custom_path  = if options.include?(:path)
+        [*options.delete(:path)]
+      else
+        self.path
+      end
+      custom_path += [*options.delete(:path_extension)]     if options.include?(:path_extension)
+      respondables = [object]
+      respondables += [*options.delete(:respondable)]       if options.include?(:respondable)
+      respondables << self # add self at last
+      custom_path.each do |path_name|
+        if path_name.is_a?(Symbol)
+          # find a respondable which responds_to path_name
+          respondable = respondables.find{ |respondable| respondable.respond_to?(path_name) }
+          if respondable
+            # call the path_name method on the respondable
+            result = value_from_method_call(respondable, respondables, path_name, parameter_matchings)
+            if result.is_a?(Array)
+              # add all entries of an array
+              scope += result
+            else
+              scope << result
+            end
+          else
+            # no object is respondable for this path_name, so just add the symbol to the scope
+            scope << path_name
+          end
+        elsif path_name.is_a?(String)
+          scope << path_name
+        end
+      end
+      return scope
+    end
 
-		protected
-		# returns the value from method path ond object using parameter_matchings as arguments
-		#
-		# === Params:
-		# * +object+: the object to call the method on
-		# * +respondables+: the objects on which arguments will be searched on
-		# * +method_name+: the method name to call
-		# * +parameter_matchings+: additional parameter_matchings as a Hash
-		def value_from_method_call(object, respondables, method_name, parameter_matchings)
-			method = object.class.instance_method(method_name)
-			if method.arity == 0
-				return object.send(method_name)
-			else
-				return object.send(method_name, *self.compute_arguments_for(respondables, method, parameter_matchings))
-			end
-		end
+    protected
+    # returns the value from method path ond object using parameter_matchings as arguments
+    #
+    # === Params:
+    # * +object+: the object to call the method on
+    # * +respondables+: the objects on which arguments will be searched on
+    # * +method_name+: the method name to call
+    # * +parameter_matchings+: additional parameter_matchings as a Hash
+    def value_from_method_call(object, respondables, method_name, parameter_matchings)
+      method = object.class.instance_method(method_name)
+      if method.arity == 0
+        return object.send(method_name)
+      else
+        return object.send(method_name, *self.compute_arguments_for(respondables, method, parameter_matchings))
+      end
+    end
 
-		# this method will compute all required (and optional) arguments for method on object
-		# 
-		# === Params:
-		# * +objects+: the objects on which the arguments should be collected
-		# * +method+: the method on which the arguments should be determined
-		# * +parameter_matchings+: additional paramteters_matchings as a Hash
-		def compute_arguments_for(objects, method, parameter_matchings)
-			args = []
-			parameters = method.parameters
-			parameters.each do |type, name|
-				if parameter_matchings.include?(name)
-					args << parameter_matchings[name]
-				elsif object = objects.find{|o| o.respond_to?(name) }
-					if object.class.instance_method(name).arity == 0
-						args << object.send(name)
-					else
-						method = object.class.instance_method(name)
-						args << object.send(name, *self.compute_arguments_for(objects, method, parameter_matchings))
-					end
-				elsif type == :req
-					raise "Could not find parameter #{name} for method #{method.name}"
-				else
-					break # break if type is :opt and we couldn't find a value
-				end
-			end
-			return args
-		end
+    # this method will compute all required (and optional) arguments for method on object
+    # 
+    # === Params:
+    # * +objects+: the objects on which the arguments should be collected
+    # * +method+: the method on which the arguments should be determined
+    # * +parameter_matchings+: additional paramteters_matchings as a Hash
+    def compute_arguments_for(objects, method, parameter_matchings)
+      args = []
+      parameters = method.parameters
+      parameters.each do |type, name|
+        if parameter_matchings.include?(name)
+          args << parameter_matchings[name]
+        elsif object = objects.find{|o| o.respond_to?(name) }
+          if object.class.instance_method(name).arity == 0
+            args << object.send(name)
+          else
+            method = object.class.instance_method(name)
+            args << object.send(name, *self.compute_arguments_for(objects, method, parameter_matchings))
+          end
+        elsif type == :req
+          raise "Could not find parameter #{name} for method #{method.name}"
+        else
+          break # break if type is :opt and we couldn't find a value
+        end
+      end
+      return args
+    end
 
-		# this method will return all modules in a array, each module will be underscored
-		#
-		# === Params:
-		# * +klass+: the klass of which the modules should be used
-		def modules(klass)
-			@modules ||= begin
-				modules = ActiveSupport::Inflector.deconstantize(klass.name)
-				modules = ActiveSupport::Inflector.underscore(modules)
-				modules.split("::")
-			end
-		end
+    # this method will return all modules in a array, each module will be underscored
+    #
+    # === Params:
+    # * +klass+: the klass of which the modules should be used
+    def modules(klass)
+      modules = ActiveSupport::Inflector.deconstantize(klass.name)
+      modules = ActiveSupport::Inflector.underscore(modules)
+      modules.split("::")
+    end
 
-		# this method will return a underscored class_name
-		#
-		# Note: plural_class and strip_controller_suffix will be used here
-		#
-		# === Params:
-		# * +klass+: the class on which the name should be get
-		# * +options+: options like plural_class and strip_controller_suffix
-		def class_name(klass, options = {})
-			@class_name ||= begin
-				class_name_options = self.options.merge(options)
-				class_name = ActiveSupport::Inflector.demodulize(klass.name) 
-				class_name = ActiveSupport::Inflector.underscore(class_name)
-				class_name = class_name[0, class_name.length - CONTROLLER_SUFFIX.length] if class_name_options[:strip_controller_suffix] && class_name.end_with?(CONTROLLER_SUFFIX)
-				if class_name_options[:plural_class]
-					ActiveSupport::Inflector.pluralize(class_name)
-				else
-					ActiveSupport::Inflector.singularize(class_name)
-				end
-			end
-		end
+    # this method will return a underscored class_name
+    #
+    # Note: plural_class and strip_controller_suffix will be used here
+    #
+    # === Params:
+    # * +klass+: the class on which the name should be get
+    # * +options+: options like plural_class and strip_controller_suffix
+    def class_name(klass, options = {})
+      class_name_options = self.options.merge(options)
+      class_name = ActiveSupport::Inflector.demodulize(klass.name) 
+      class_name = ActiveSupport::Inflector.underscore(class_name)
+      class_name = class_name[0, class_name.length - CONTROLLER_SUFFIX.length] if class_name_options[:strip_controller_suffix] && class_name.end_with?(CONTROLLER_SUFFIX)
+      if class_name_options[:plural_class]
+        ActiveSupport::Inflector.pluralize(class_name)
+      else
+        ActiveSupport::Inflector.singularize(class_name)
+      end
+    end
 
-		# returns the method name of the original caller
-		def method_name
-			found_scoped_t_at = nil
-			caller.each_with_index do |call, index|
-				if call.include?("scoped_t")
-					found_scoped_t_at = index
-					break
-				end
-			end
-			if found_scoped_t_at && call = caller[found_scoped_t_at + 1]
-				if /^(.+?):(\d+)(?::in `(.*)')?/ =~ call
-					return Regexp.last_match[3]
-				end
-			end
-	    raise "Failed to get method_name"
-		end
+    # returns the method name of the original caller
+    def method_name
+      found_scoped_t_at = nil
+      caller.each_with_index do |call, index|
+        if call.include?("scoped_translation")
+          found_scoped_t_at = index
+          break
+        end
+      end
+      if found_scoped_t_at && call = caller[found_scoped_t_at + 1]
+        if /^(.+?):(\d+)(?::in `(.*)')?/ =~ call
+          return Regexp.last_match[3]
+        end
+      end
+      raise "Failed to get method_name"
+    end
 
-	end
+  end
 
 end

data/lib/i18n_scopes/translation_methods.rb

@@ -1,44 +1,45 @@
 module I18nScopes
 
-	module TranslationMethods
-		extend ActiveSupport::Concern
+  module TranslationMethods
+    extend ActiveSupport::Concern
 
-		protected
-		# translates the given key under the configured scope
-		# 
-		# === Params:
-		# * +key+: the translation key to lookup
-		# * +options+:
-		#   * +path+: +Array+ the path to be overwritten
-		#   * +path_extension+: +Array+ an additional path to the one configued using Scope::ClassMethods#i18n_scope (will be attached to the end)
-		#   * +respondable+: an array of objects on which the methods should be looked up
-		#   * +parameter_matchings+: a hash containing arguments for the dynamic method calls
-		def scoped_t(*args)
-			options = args.extract_options!
-			
-			additional_parameters = if self.respond_to?(:i18n_parameter_matchings)
-				self.i18n_parameter_matchings
-			else
-				options.delete(:parameter_matchings) || {}
-			end
+    protected
+    # translates the given key under the configured scope
+    # 
+    # === Params:
+    # * +key+: the translation key to lookup
+    # * +options+:
+    #   * +path+: +Array+ the path to be overwritten
+    #   * +path_extension+: +Array+ an additional path to the one configued using Scope::ClassMethods#i18n_scope (will be attached to the end)
+    #   * +respondable+: an array of objects on which the methods should be looked up
+    #   * +parameter_matchings+: a hash containing arguments for the dynamic method calls
+    def scoped_translation(scope_helper, *args)
+      options = args.extract_options!
+      
+      additional_parameters = if self.respond_to?(:i18n_parameter_matchings)
+        self.i18n_parameter_matchings
+      else
+        {}
+      end
+      additional_parameters.merge!(options.delete(:parameter_matchings)) if options.include?(:parameter_matchings)
 
-			parameter_matchings = {
-				:klass => self.class,
-				:object => self,
-				:options => options,
-			}.merge(additional_parameters)
+      parameter_matchings = {
+        klass:   self.class,
+        object:  self,
+        options: options,
+      }.merge(additional_parameters)
+      
+      scope = scope_helper.scope_from_path(self, options, parameter_matchings)
+      
+      scope += options[:scope] if options.include?(:scope)
+      return I18n.translate *args, options.merge(scope: scope)
+    end
 
-			scope = self.i18n_scope_helper.scope_from_path(self, options, parameter_matchings)
-			
-			scope += options[:scope] if options.include?(:scope)
-			return I18n.translate *args, options.merge(:scope => scope)
-		end
+    # retusn the i18n_scope_helper instance of TranslationHelper
+    def i18n_scope_helper
+      return self.class.i18n_scope_helper
+    end
 
-		# retusn the i18n_scope_helper instance of TranslationHelper
-		def i18n_scope_helper
-			return self.class.i18n_scope_helper
-		end
-
-	end
+  end
 
 end

data/lib/i18n_scopes/version.rb

@@ -1,3 +1,3 @@
 module I18nScopes
-  VERSION = "0.0.1"
+  VERSION = "0.2.0"
 end

data/spec/configuration_spec.rb

@@ -2,20 +2,20 @@ require 'spec_helper'
 require 'example_classes/should_have_attached_scoped_t'
 
 describe I18nScopes::Configuration do
-	I18nScopes.configure do |config|
-		config.plural_classes 			= true
-		config.strip_controller_suffix 	= true
-		config.attach_to				ShouldHaveAttachedScopedT
-	end
+  I18nScopes.configure do |config|
+    config.plural_classes           = true
+    config.strip_controller_suffix  = true
+    config.attach_to        ShouldHaveAttachedScopedT
+  end
 
-	let(:configuration) { I18nScopes.configuration }
-	subject { configuration }
+  let(:configuration) { I18nScopes.configuration }
+  subject { configuration }
 
-	its(:plural_classes) 						{ should be_true }
-	its(:strip_controller_suffix) 	{ should be_true }
+  its(:plural_classes)            { should be_true }
+  its(:strip_controller_suffix)   { should be_true }
 
-	it 'should attach i18n_scope to ShouldHaveAttachedScopedT' do
-		ShouldHaveAttachedScopedT.should respond_to(:i18n_scope)
-	end
+  it 'should attach i18n_scope to ShouldHaveAttachedScopedT' do
+    ShouldHaveAttachedScopedT.should respond_to(:i18n_scope)
+  end
 
 end

data/spec/example_classes/inherited.rb

@@ -0,0 +1,13 @@
+class Inherited < ScopeTWithPath
+  
+  i18n_scope :flash, :inheritance_overwritten, :flashes
+
+  def translate
+    t_scoped(:name)
+  end
+
+  def translate_flash
+    t_flash(:message)
+  end
+
+end

data/spec/example_classes/respondable.rb

@@ -1,7 +1,7 @@
 class Respondable
-	
-	def type
-		:normal
-	end
+  
+  def type
+    :normal
+  end
 
 end

data/spec/example_classes/scope_t_with_path.rb

@@ -1,27 +1,32 @@
 class ScopeTWithPath
 
-	i18n_scope ["static_prefix", :class_prefix, :with_a_parameter, :class_name]
+  i18n_default_scope "static_prefix", :class_prefix, :with_a_parameter, :class_name
+  i18n_scope :flash, :class_name, :flashes
 
-	def translate
-		scoped_t(:name)
-	end
+  def translate
+    t_scoped(:name)
+  end
 
   def translate_local
-    scoped_t(:name, :path => [:overwritten, :locally])
+    t_scoped(:name, :path => [:overwritten, :locally])
   end
 
   def translate_path_extension
-    scoped_t(:name, :path_extension => ["extension"])
+    t_scoped(:name, :path_extension => "extension")
   end
 
   def translate_with_respondable
-    scoped_t(:name, :path_extension => [:type], :respondable => [Respondable.new])
+    t_scoped(:name, :path_extension => [:type], :respondable => Respondable.new)
+  end
+
+  def translate_flash
+    t_flash(:message)
   end
 
- 	protected
-	def class_prefix
-		:some_prefix_from_local_class
-	end
+  protected
+  def class_prefix
+    :some_prefix_from_local_class
+  end
 
   def with_a_parameter(the_parameter)
     :"with_#{the_parameter}"

data/spec/example_classes/scope_t_with_path_in_module.rb

@@ -1,10 +1,10 @@
 module SomeModule
-	class ScopeTWithPathInModule
+  class ScopeTWithPathInModule
 
-    i18n_scope [:modules, :local, :class_name]
+    i18n_default_scope :modules, :local, :class_name
 
     def translate
-      scoped_t(:name)
+      t_scoped(:name)
     end
 
     protected
@@ -20,5 +20,5 @@ module SomeModule
       "moddd_#{modules}"
     end
 
-	end
+  end
 end

data/spec/example_classes/should_define_scope.rb

@@ -1,5 +1,5 @@
 class ShouldDefineScope
 
-	i18n_scope "prefix"
+  i18n_default_scope "prefix"
 
 end

data/spec/example_classes/should_have_attached_scoped_t.rb

@@ -1,3 +1,3 @@
 class ShouldHaveAttachedScopedT
-	
+  
 end

data/spec/include_scope_spec.rb

@@ -5,15 +5,15 @@ require 'example_classes/should_have_attached_scoped_t'
 # Testing I18nScopes::Scope
 describe ShouldHaveAttachedScopedT do
 
-	I18nScopes.configuration.attach_to(ShouldHaveAttachedScopedT)
-	subject { ShouldHaveAttachedScopedT }
+  I18nScopes.configuration.attach_to(ShouldHaveAttachedScopedT)
+  subject { ShouldHaveAttachedScopedT }
 
-	it 'should respond to i18n_scope_helper' do 
-		subject.should respond_to(:i18n_scope_helper)
-	end
+  it 'should respond to i18n_scope_helper' do 
+    subject.should respond_to(:i18n_scope_helper)
+  end
 
-	it 'should respond to i18n_scope' do 
-		subject.should respond_to(:i18n_scope)
-	end
+  it 'should respond to i18n_scope' do 
+    subject.should respond_to(:i18n_scope)
+  end
 
 end

data/spec/inherited_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'example_classes/scope_t_with_path'
+require 'example_classes/inherited'
+
+describe Inherited do
+
+  its(:translate)       { should == "InheritedScope" }
+
+  its(:translate_flash) { should == "InheritedScopeOverwritten" }
+
+end

data/spec/locales/en.yml

@@ -8,6 +8,8 @@ en:
             name: ScopeTWithPathPathExtension
           normal:
             name: ScopeTWithPathAndRespondable
+        inherited:
+          name: InheritedScope
 
   some_module:
       prefix_suffix:
@@ -15,4 +17,10 @@ en:
           name: ScopeTWithPathTranslationAndModule
   overwritten:
     locally:
-      name: ScopeTWithPathLocallyOverwritten
+      name: ScopeTWithPathLocallyOverwritten
+  scope_t_with_path:
+    flashes:
+      message: ScopeTWithPathFromScope
+  inheritance_overwritten:
+    flashes: 
+      message: InheritedScopeOverwritten

data/spec/scope_spec.rb

@@ -3,18 +3,19 @@ require 'example_classes/should_define_scope'
 
 # Testing I18nScopes::Scope
 describe ShouldDefineScope do
-	I18nScopes.configuration.attach_to(ShouldDefineScope)
-	let(:should_define_scope) { ShouldDefineScope.new }
-	subject { should_define_scope }
 
-	it 'should return I18nScopes::TranslationHelper for i18n_scope_helper' do
-		ShouldDefineScope.i18n_scope_helper.should be_instance_of(I18nScopes::TranslationHelper)
-	end
+  I18nScopes.configuration.attach_to(ShouldDefineScope)
+  let(:should_define_scope) { ShouldDefineScope.new }
+  subject { should_define_scope }
 
-	[:scoped_t, :i18n_scope_helper,].each do |method|
-		it "should respond to #{method}" do
-			should_define_scope.should respond_to(method)
-		end
-	end
+  it 'should return I18nScopes::TranslationHelper for i18n_scope_helper' do
+    ShouldDefineScope.i18n_scope_helper[:default].should be_instance_of(I18nScopes::TranslationHelper)
+  end
+
+  [:scoped_translation, :i18n_scope_helper,].each do |method|
+    it "should respond to #{method}" do
+      should_define_scope.should respond_to(method)
+    end
+  end
 
 end

data/spec/should_define_scope_spec.rb

@@ -4,13 +4,15 @@ require 'example_classes/respondable'
 
 describe ScopeTWithPath do
 
-	
+  
   its(:translate)       { should == "ScopeTWithPathTranslationFromFile"}
 
   its(:translate_local) { should == "ScopeTWithPathLocallyOverwritten"}
 
-  its(:translate_path_extension) 		{ should == "ScopeTWithPathPathExtension" }
+  its(:translate_path_extension)    { should == "ScopeTWithPathPathExtension" }
 
-  its(:translate_with_respondable)	{ should == "ScopeTWithPathAndRespondable" }
+  its(:translate_with_respondable)  { should == "ScopeTWithPathAndRespondable" }
+
+  its(:translate_flash)             { should == "ScopeTWithPathFromScope" }
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: i18n_scopes
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-14 00:00:00.000000000 Z
+date: 2012-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -43,17 +43,20 @@ files:
 - i18n_scopes.gemspec
 - lib/i18n_scopes.rb
 - lib/i18n_scopes/configuration.rb
+- lib/i18n_scopes/option_accessor.rb
 - lib/i18n_scopes/scope.rb
 - lib/i18n_scopes/translation_helper.rb
 - lib/i18n_scopes/translation_methods.rb
 - lib/i18n_scopes/version.rb
 - spec/configuration_spec.rb
+- spec/example_classes/inherited.rb
 - spec/example_classes/respondable.rb
 - spec/example_classes/scope_t_with_path.rb
 - spec/example_classes/scope_t_with_path_in_module.rb
 - spec/example_classes/should_define_scope.rb
 - spec/example_classes/should_have_attached_scoped_t.rb
 - spec/include_scope_spec.rb
+- spec/inherited_spec.rb
 - spec/locales/en.yml
 - spec/scope_spec.rb
 - spec/should_define_scope_in_module_spec.rb
@@ -82,16 +85,18 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: This gem will attach a scoped_t method to your class. The scope will be configureable
+summary: This gem will attach a t_scoped method to your class. The scope will be configureable
   in your class or globally.
 test_files:
 - spec/configuration_spec.rb
+- spec/example_classes/inherited.rb
 - spec/example_classes/respondable.rb
 - spec/example_classes/scope_t_with_path.rb
 - spec/example_classes/scope_t_with_path_in_module.rb
 - spec/example_classes/should_define_scope.rb
 - spec/example_classes/should_have_attached_scoped_t.rb
 - spec/include_scope_spec.rb
+- spec/inherited_spec.rb
 - spec/locales/en.yml
 - spec/scope_spec.rb
 - spec/should_define_scope_in_module_spec.rb