i18n_scopes 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem "i18n", "~> 0.6.0"
+gem "activesupport", "~> 3.2.6"
+
+group :test do
+  gem "rspec", "~> 2.11.0"
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+# I18nScopes
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+  gem 'i18n_scopes'
+
+And then execute:
+
+  $ bundle
+
+Or install it yourself as:
+
+  $ gem install i18n_scopes
+
+## Usage
+
+### Configuration
+
+    I18nScopes.configure do |config|
+      config.plural_classes = false
+      config.strip_controller_suffix = true
+      config.attach_to ActionController::Base
+    end
+
+
+
+
+### 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
+
+      def index
+        @post = Post.new
+        self.examples
+      end
+
+      def examples
+        # the scoped_t method will inherit the path from the i18n_scope method
+        scoped_t :name # => [:example, :translation, :index, :name]
+
+        # the path can be overwritten with an option
+        scoped_t :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]
+
+        # 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]
+
+        # 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]
+      end
+
+      def modules_with_extension(modules)
+        "#{modules}_modules"
+      end
+
+    end
+

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/i18n_scopes.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/i18n_scopes/version', __FILE__)
+
+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.homepage      = "http://github.com/menostos/i18n_scopes"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "i18n_scopes"
+  gem.require_paths = ["lib"]
+  gem.version       = I18nScopes::VERSION
+  gem.add_development_dependency 'rspec'
+end

data/lib/i18n_scopes.rb

@@ -0,0 +1,9 @@
+
+require 'i18n_scopes/scope'
+require 'i18n_scopes/configuration'
+require 'i18n_scopes/translation_methods'
+require 'i18n_scopes/translation_helper'
+require 'active_support/concern'
+require 'active_support/core_ext/string/inflections'
+
+Object.send :include, I18nScopes::Scope

data/lib/i18n_scopes/configuration.rb

@@ -0,0 +1,59 @@
+# extend the I18nScopes module to support configuration
+# 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
+
+end

data/lib/i18n_scopes/scope.rb

@@ -0,0 +1,43 @@
+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
+
+  		extend ActiveSupport::Concern
+
+  		module ClassMethods
+
+    		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
+  
+end

data/lib/i18n_scopes/translation_helper.rb

@@ -0,0 +1,147 @@
+module I18nScopes
+
+	# this class provides helper methods to determine the actual scope in your class
+	class TranslationHelper
+
+		CONTROLLER_SUFFIX = "_controller"
+
+		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:
+		# * +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
+
+		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 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 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
+
+		# 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
+
+	end
+
+end

data/lib/i18n_scopes/translation_methods.rb

@@ -0,0 +1,44 @@
+module I18nScopes
+
+	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
+
+			parameter_matchings = {
+				:klass => self.class,
+				:object => self,
+				:options => options,
+			}.merge(additional_parameters)
+
+			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
+
+	end
+
+end

data/lib/i18n_scopes/version.rb

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

data/spec/configuration_spec.rb

@@ -0,0 +1,21 @@
+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
+
+	let(:configuration) { I18nScopes.configuration }
+	subject { configuration }
+
+	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
+
+end

data/spec/example_classes/respondable.rb

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

data/spec/example_classes/scope_t_with_path.rb

@@ -0,0 +1,36 @@
+class ScopeTWithPath
+
+	i18n_scope ["static_prefix", :class_prefix, :with_a_parameter, :class_name]
+
+	def translate
+		scoped_t(:name)
+	end
+
+  def translate_local
+    scoped_t(:name, :path => [:overwritten, :locally])
+  end
+
+  def translate_path_extension
+    scoped_t(:name, :path_extension => ["extension"])
+  end
+
+  def translate_with_respondable
+    scoped_t(:name, :path_extension => [:type], :respondable => [Respondable.new])
+  end
+
+ 	protected
+	def class_prefix
+		:some_prefix_from_local_class
+	end
+
+  def with_a_parameter(the_parameter)
+    :"with_#{the_parameter}"
+  end
+
+  def i18n_parameter_matchings
+    {
+      :the_parameter => :custom_value
+    }
+  end
+
+end

data/spec/example_classes/scope_t_with_path_in_module.rb

@@ -0,0 +1,24 @@
+module SomeModule
+	class ScopeTWithPathInModule
+
+    i18n_scope [:modules, :local, :class_name]
+
+    def translate
+      scoped_t(:name)
+    end
+
+    protected
+    def local(overwriteable)
+      :"prefix_#{overwriteable}"
+    end
+
+    def overwriteable
+      :suffix
+    end
+
+    def module_with_ext(modules)
+      "moddd_#{modules}"
+    end
+
+	end
+end

data/spec/example_classes/should_define_scope.rb

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

data/spec/example_classes/should_have_attached_scoped_t.rb

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

data/spec/include_scope_spec.rb

@@ -0,0 +1,19 @@
+
+require 'spec_helper'
+require 'example_classes/should_have_attached_scoped_t'
+
+# Testing I18nScopes::Scope
+describe ShouldHaveAttachedScopedT do
+
+	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' do 
+		subject.should respond_to(:i18n_scope)
+	end
+
+end

data/spec/locales/en.yml

@@ -0,0 +1,18 @@
+en:
+  static_prefix:
+    some_prefix_from_local_class:
+      with_custom_value:
+        scope_t_with_path:
+          name: ScopeTWithPathTranslationFromFile
+          extension:
+            name: ScopeTWithPathPathExtension
+          normal:
+            name: ScopeTWithPathAndRespondable
+
+  some_module:
+      prefix_suffix:
+        scope_t_with_path_in_module:
+          name: ScopeTWithPathTranslationAndModule
+  overwritten:
+    locally:
+      name: ScopeTWithPathLocallyOverwritten

data/spec/scope_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+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
+
+	[:scoped_t, :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_in_module_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'example_classes/scope_t_with_path_in_module'
+
+describe SomeModule::ScopeTWithPathInModule do
+
+  its(:translate)   { should == "ScopeTWithPathTranslationAndModule" }
+
+end

data/spec/should_define_scope_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'example_classes/scope_t_with_path'
+require 'example_classes/respondable'
+
+describe ScopeTWithPath do
+
+	
+  its(:translate)       { should == "ScopeTWithPathTranslationFromFile"}
+
+  its(:translate_local) { should == "ScopeTWithPathLocallyOverwritten"}
+
+  its(:translate_path_extension) 		{ should == "ScopeTWithPathPathExtension" }
+
+  its(:translate_with_respondable)	{ should == "ScopeTWithPathAndRespondable" }
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'i18n'
+
+require 'active_support/concern'
+require 'active_support/core_ext/string/inflections'
+
+require 'i18n_scopes'
+
+I18n.load_path << File.join(File.dirname(__FILE__), "locales", "en.yml")
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: i18n_scopes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- menostos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A gem for adding dynamic scopes to classes
+email:
+- menostos@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- i18n_scopes.gemspec
+- lib/i18n_scopes.rb
+- lib/i18n_scopes/configuration.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/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/locales/en.yml
+- spec/scope_spec.rb
+- spec/should_define_scope_in_module_spec.rb
+- spec/should_define_scope_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/menostos/i18n_scopes
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+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
+  in your class or globally.
+test_files:
+- spec/configuration_spec.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/locales/en.yml
+- spec/scope_spec.rb
+- spec/should_define_scope_in_module_spec.rb
+- spec/should_define_scope_spec.rb
+- spec/spec_helper.rb