humanized 0.0.1.alpha → 0.0.1

data/lib/humanized.rb

@@ -14,7 +14,7 @@
 #
 #    (c) 2011 by Hannes Georg
 #
-
+require 'logger'
 require "facets/module/home.rb"
 require "facets/module/basename.rb"
 require "facets/module/anonymous.rb"
@@ -24,6 +24,27 @@ require "facets/module/alias_method_chain.rb"
 # readable output.
 module Humanized
   
+  class FailedInterpolation < String
+    
+    ERROR_STRING = '[error]'.freeze
+    
+    attr_reader :exception, :string, :variables
+    
+    def initialize(exception, string, variables)
+      @exception = exception
+      @string = string
+      @variables = variables
+      super(ERROR_STRING)
+    end
+    
+  end
+  
+  class << self
+    attr_accessor :logger
+  end
+  
+  self.logger = Logger.new(STDERR)
+  
   module HasNaturalGenus
     
     def self.included(base)
@@ -44,9 +65,8 @@ module Humanized
   end
   
 end
-require "humanized/ref"
 require "humanized/humanizer"
-require "humanized/scope"
+require "humanized/query"
 Dir[File.expand_path('humanized/core_ext/*.rb', File.dirname(__FILE__))].each do |file|
   require file
 end

data/lib/humanized/compiler.rb

@@ -16,28 +16,30 @@
 #
 
 module Humanized
-class Compiler
-  
-  class Compiled < Proc
-  
-    attr_accessor :str
-  
-    def initialize(str)
-      @str = str
-      super()
-      return self
-    end
+
+class Compiled < Proc
   
-    def to_s
-      @str
-    end
-    
+  attr_accessor :str
+
+  def initialize(str)
+    @str = str
+    super()
+    return self
+  end
+
+  def to_s
+    @str
   end
+  
+end
 
+class CompilerBase
+  
   def initialize
     @compiled = Hash.new{|hsh,x| hsh[x] = compile!(x)}
   end
 
+
 # Compiles a String into a Proc
 # @param [String] str A formated String
 # @return [Compiled] A Proc, which will handle interpolation.
@@ -45,6 +47,16 @@ class Compiler
   def compile(str)
     @compiled[str]
   end
+
+protected
+  def compile!(str)
+    raise NoMethodError, "Please implement a compile!-method."
+  end
+  
+end
+  
+class Compiler < CompilerBase
+  
 protected
   
   VAR_REGEXP = /^%([a-z_]+)/
@@ -53,18 +65,23 @@ protected
   
   TRANSFORMER = lambda{|token|
     if token.kind_of? Array
-      "[#{token.map(&TRANSFORMER).join(',')}].join()"
+      "[#{token.map(&TRANSFORMER).join(',')}].map(&:to_s).join()"
     elsif token.kind_of? String
       token.inspect
     elsif token.kind_of? Symbol
       "variables[#{token.inspect}]"
     elsif token.kind_of? Hash
-      "interpolater.#{token[:method]}(humanizer,#{token[:args].map(&TRANSFORMER).join(',')})"
+      if token[:args].any?
+        "o.#{token[:method]}(humanizer,#{token[:args].map(&TRANSFORMER).join(',')})"
+      else
+        "o.#{token[:method]}(humanizer)"
+      end
     end
   }
   
   def compile!(str)
-    return eval('Compiled.new(str){|humanizer,interpolater,variables| ' + TRANSFORMER.call(read(str)) +' }')  
+    str = str.dup.freeze
+    return eval('Compiled.new(str) do |humanizer,variables| o = humanizer.interpolater.object ;' + TRANSFORMER.call(read(str)) +' end')
   end
   
   def read(str)
@@ -124,4 +141,4 @@ protected
 
 end
   
-end
+end

data/lib/humanized/core_ext/array.rb

@@ -19,7 +19,7 @@ class Array
     if self.any?
       return self[0]._(*self[1..-1])._(*args,&block)
     else
-      Humanized::Scope::None
+      Humanized::Query::None
     end
   end
 end

data/lib/humanized/core_ext/hash.rb

@@ -16,10 +16,14 @@
 #
 class Hash
   def _(*args,&block)
-    if self.class == Hash
-      Humanized::Scope::None._(*args,&block).with_variables(self)
+    if humanized_variables?
+      Humanized::Query::Root._(*args,&block).with_variables(self)
     else
       super
     end
   end
+  
+  def humanized_variables?
+    self.class == Hash
+  end
 end

data/lib/humanized/core_ext/module.rb

@@ -16,7 +16,7 @@
 #
 class Module
   
-  # Generates a {Humanized::Scope scope} for a Module or Class. This will be used by default by
+  # Generates a {Humanized::Query query} for a Module or Class. This will be used by default by
   # this Module and by all Objects of this Class.
   def humanization_key!
     if self.anonymous?
@@ -26,7 +26,7 @@ class Module
     if h != Object and h.respond_to? :humanization_key
       result = h.humanization_key + self.basename.downcase.to_sym
     else
-      result = Humanized::Scope::Root.+(*self.name.split('::').map{|s| s.downcase.to_sym })
+      result = Humanized::Query::Root.+(*self.name.split('::').map{|s| s.downcase.to_sym })
     end
     thiz = self
     if defined? thiz.superclass and self.superclass != Object

data/lib/humanized/core_ext/nilclass.rb

@@ -16,6 +16,6 @@
 #
 class NilClass
   def _(*args,&block)
-    Humanized::Scope::None._(*args,&block)
+    Humanized::Query::None._(*args,&block)
   end
 end

data/lib/humanized/core_ext/object.rb

@@ -14,9 +14,15 @@
 #
 #    (c) 2011 by Hannes Georg
 #
+require 'facets/object/dup'
 class Object
   def humanization_key
-    self.class.humanization_key
+    if self.frozen? or !self.dup?
+      i = self
+    else
+      i = self.dup.freeze
+    end
+    self.class.humanization_key.optionally(:instance).with_variables({:self => i })
   end
   def _(*args,&block)
     self.humanization_key._(*args,&block)

data/lib/humanized/core_ext/string.rb

@@ -16,6 +16,6 @@
 #
 class String
   def _(*args,&block)
-    Humanized::Scope::None._(*args,&block).with_default(self)
+    Humanized::Query::Root._(*args,&block).with_default(self.dup)
   end
 end

data/lib/humanized/core_ext/symbol.rb

@@ -16,6 +16,6 @@
 #
 class Symbol
   def _(*args,&block)
-    Humanized::Scope.new([[self]])._(*args,&block)
+    Humanized::Query.new([[self]])._(*args,&block)
   end
 end

data/lib/humanized/humanizer.rb

@@ -17,9 +17,11 @@
 require 'facets/array/extract_options.rb'
 require 'facets/hash/deep_merge.rb'
 require 'sync'
+require 'logger'
 require 'set'
 require 'humanized/compiler.rb'
 require 'humanized/source.rb'
+require 'humanized/interpolater.rb'
 module Humanized
 # A Humanizer has one simple task: <b>create strings in its language/dialect/locale/whatever!</b>
 #
@@ -31,63 +33,211 @@ module Humanized
 # The most important method you may use is {#[]}.
 class Humanizer
   
-  # This is a simple object without public methods. You can use this as a collection for interpolation methods.
-  class PrivatObject
-    public_instance_methods.each do |meth|
-      private meth
+  IS_STRING = lambda{|x| x.kind_of? String }
+  
+  class << self
+    
+  private
+  
+    # Defines a component on this class and all subclasses.
+    def component( name, options = {}, &initializer )
+      @components ||= {}
+      options = options.dup
+      if !block_given?
+        initializer = lambda{|value, old| value}
+      end
+      options[:initializer] = initializer
+      options.freeze
+      @components[name.to_sym] = options
+      attr_accessor name
+      public name.to_sym
+      protected "#{name.to_s}=".to_sym
+      if options[:delegate]
+        if options[:delegate].kind_of? Hash
+          options[:delegate].each do | from, to |
+            module_eval <<RB
+  def #{from.to_s}(*args, &block)
+    #{name.to_s}.#{to.to_s}(*args,&block)
+  end
+RB
+          end
+        elsif options[:delegate].respond_to? :each
+          options[:delegate].each do | from |
+            module_eval <<RB
+  def #{from.to_s}(*args, &block)
+    #{name.to_s}.#{from.to_s}(*args,&block)
+  end
+RB
+          end
+        end
+        
+      end
+      # TODO: iterater superclass combinations
+      if @component_combinations
+        cc = @component_combinations
+        @component_combinations = []
+        cc.each do | rest, block |
+          when_combining_components(rest, block)
+        end
+      end
     end
     
-    public :extend
+    def when_combining_components(*args,&block)
+      rest = args.map( &:to_sym ).uniq - self.components.to_a
+      if rest.none?
+        block.call( self )
+      else
+        @component_combinations = [] unless @component_combinations
+        @component_combinations << [ rest, block ]
+      end
+    end
+    
+  public
+    def each_component
+      klass = self
+      components = Set.new
+      while( klass )
+        a = klass.instance_variable_get("@components")
+        if a
+          a.each do |name, options|
+            unless components.include?(name)
+              yield(name, options) if block_given?
+              components << name
+            end
+          end
+        end
+        klass = klass.superclass
+      end
+      return components
+    end
     
+    alias_method :components, :each_component
+    
+  end
+  
+  component :interpolater do |value, old|
+    value || Interpolater.new
+  end
+  
+  component :source, :delegate =>[:package, :load , :<<, :get ] do |value, old|
+    if value.kind_of? Source
+      value
+    elsif value.kind_of? Hash
+      Source.new(value)
+    elsif value.nil?
+      Source.new
+    else
+      raise ArgumentError, "Expected :source to be a kind of Humanized::Source, Hash or nil."
+    end
+  end
+  
+  component :compiler do |value, old|
+    value || Compiler.new
   end
   
-  attr_reader :interpolater, :source, :compiler
+  component :logger do |value, old|
+    if value.kind_of? Logger
+      value
+    elsif value.respond_to? :write and value.respond_to? :close
+      Logger.new(value)
+    elsif value.nil?
+      Humanized.logger
+    elsif value.kind_of? FalseClass
+      value
+    else
+      raise ArgumentError, "Expected :logger to be a kind of Logger, IO, nil or false."
+    end
+  end
   
 # Creates a new Humanizer
 #
 # @option components [Object] :interpolater This object which has all interpolation methods defined as public methods.
 # @option components [Compiler] :compiler A compiler which can compile strings into procs. (see Compiler)
 # @option components [Source] :source A source which stores translated strings. (see Source)
-  def initialize(components = {})
-    @interpolater = (components[:interpolater] || PrivatObject.new)
-    @compiler = (components[:compiler] || Compiler.new)
-    @source = (components[:source] || Source.new)
+# @option components [Logger, IO, false] :logger A logger for this Humanizer or false to disable logging.
+  def initialize(*args)
+    
+    components = args.last.kind_of?(Hash) ? args.pop : {}
+    
+    used_keys = Set.new
+    
+    args.each do | mod |
+      if mod.kind_of? Module
+        extend mod
+      end
+    end
+    
+    if args.first.kind_of? Humanized::Humanizer
+      
+      humanizer = args.first
+      
+      modules = (class << humanizer; included_modules ; end ) - self.class.included_modules
+      
+      modules.each do | mod |
+        
+        extend mod
+        
+      end
+      
+      (class << self ; self ; end).each_component do |name, options|
+        if humanizer.respond_to? name
+          if components.key? name
+            self.send("#{name}=".to_sym, options[:initializer].call(components[name],humanizer.respond_to?(name) ? humanizer.send(name) : nil ))
+          else
+            self.send("#{name}=".to_sym, humanizer.send(name))
+          end
+        else
+          self.send("#{name}=".to_sym, options[:initializer].call(components[name],nil))
+        end
+        used_keys << name
+      end
+    else
+      
+      (class << self ; self ; end).each_component do |name, options|
+        self.send("#{name}=".to_sym, options[:initializer].call(components[name], nil))
+        used_keys << name
+      end
+    
+    end
+    
+    components.each do | k, v |
+      warn "Unused key #{k.inspect} with value #{v.inspect} in Humanizer.initialize" unless used_keys.include? k
+    end
+    
+    
   end
   
+  
 # Creates a new Humanizer which uses the interpolater, compiler and source of this Humanizer unless other values for them were specified.
 # @see #initialize
-  def renew(components)
-    self.class.new({:interpolater=>@interpolater,:compiler=>@compiler,:source=>@source}.update(components))
+  def new(components)
+    self.class.new(self, components)
   end
   
 # Creates a String from the input. This will be the most used method in application code.
-# It expects a {Scope} as argument. Anything that is not a {Scope} will be converted into a {Scope} using the "_"-method.
+# It expects a {Query} as argument. Anything that is not a {Query} will be converted into a {Query} using the "_"-method.
 # This enables you to pass any object to this method. The result is mainly determined by result of the "_"-method.
 # For 
 #
-# @param [Scope, #_, Object] *args
+# @param [Query, #_, Object] *args
 # @return [String]
   def [](*args)
     it = args._
     
     vars = it.variables
     default = it.default
-    result = @source.get(it, default)
+    result = @source.get(it, :default=>default, :accepts=>IS_STRING)
     result = default unless result.kind_of? String
     if result.kind_of? String
       return interpolate(result,vars)
-    elsif default.__id__ != result.__id__
-      warn "[] should be only used for strings. For anything else use get."
+    else
+      if logger
+        logger.error do
+          "Expected to retrieve a String, but got: #{result.inspect}\n\tQuery: #{it.inspect}"
+        end
+      end
+      return ""
     end
-    return result
-  end
-
-# This is a wrapper for @source.get.
-# The only thing it does additionally is converting all params into a Scope.
-# @see Source#get
-  def get(base,*rest)
-    it = base._(*rest)
-    return @source.get(it, it.default)
   end
 
 # Stores a translation
@@ -96,26 +246,20 @@ class Humanizer
     @source.store(it._(*rest).first,last)
   end
   
-# This is an alias for @source.package
-# @see Source#package
-  def package(*args,&block)
-    @source.package(*args,&block)
-  end
-  
-# This is an alias for @source.load
-# @see Source#load
-  def load(*args,&block)
-    @source.load(*args,&block)
-  end
-  
-# This is an alias for @source.<<
-# @see Source#<<
-  def <<(x)
-    @source << x
+  def interpolate(str,vars={})
+    return @compiler.compile(str).call(self,vars)
+  rescue Exception => e
+    return handle_interpolation_exception(e, str, vars)
   end
   
-  def interpolate(str,vars={})
-    @compiler.compile(str).call(self,@interpolater,vars)
+protected
+  def handle_interpolation_exception(e, str, vars)
+    if logger
+      logger.error do
+        "Failed interpolating \"#{str}\"\n\tVariables: #{vars.inspect}\n\tMessage: #{e.message}\n\tTrace:\t" + e.backtrace.join("\n\t\t")
+      end
+    end
+    return FailedInterpolation.new(e, str, vars)
   end
   
 end