humanized 0.0.1.alpha → 0.0.1

data/lib/humanized/interpolater.rb

@@ -0,0 +1,71 @@
+# -*- encoding : utf-8 -*-
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the Affero GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#    (c) 2011 by Hannes Georg
+#
+module Humanized
+  class Interpolater
+
+    UNCHANGED_METHODS = Set.new([:__send__,:object_id])
+    PRIVATE_METHODS = Set.new([:extend,:send,:eval,:instance_exec,:instance_eval, :respond_to? ,:__id__,:method])
+
+    class LockedDown
+      public_instance_methods.each do |meth|
+        if UNCHANGED_METHODS.include? meth.to_sym
+          next
+        elsif PRIVATE_METHODS.include? meth.to_sym
+          private meth
+        else
+          undef_method meth
+        end
+      end
+
+      def lock!
+        m = method(:send)
+        class << self
+          undef :lock!
+        end
+        return m
+      end
+    end
+
+    PRIVATE_METHODS.each do |meth|
+      class_eval(<<RB)
+alias_method :real_#{meth}, #{meth.inspect}
+
+def #{meth.to_s}(*args,&block)
+  @masterkey.send(#{meth.inspect},*args,&block)
+end
+RB
+    end
+
+    def initialize
+      @object = LockedDown.new
+      @masterkey = @object.lock!
+    end
+
+    def <<(mod)
+      @masterkey.call(:extend, mod)
+      return self
+    end
+
+    def object; @object ; end
+    
+    def inspect
+      "#<#{self.class.name}:#{self.object_id.to_s}>"
+    end
+    
+  end
+
+end

data/lib/humanized/interpolation/conjunctions.rb

@@ -21,12 +21,18 @@ module Conjunctions
   def and(humanizer, *args)
     args = args.flatten
     last = args.pop
+    if args.size == 0
+      return last.to_s
+    end
     return [args.join(', '), last].join(' '+humanizer[:and]+' ')
   end
   
   def or(humanizer, *args)
     args = args.flatten
     last = args.pop
+    if args.size == 0
+      return last.to_s
+    end
     return [args.join(', '), last].join(' '+humanizer[:or]+' ')
   end
   

data/lib/humanized/interpolation/date.rb

@@ -19,18 +19,26 @@ module Humanized
 module Date
   
   def date(humanizer, date, format = 'default')
-    if format == 'default'
+    if format == 'default' or format.nil?
       it = date._(:format,:default)
     else
+      format = format.to_sym
       it = date._.format( format._ | :default._ )
     end
     f = humanizer.get(it)
+    if humanizer.respond_to? :calendar
+      
+      return humanizer.calendar.format( f )
+      
+    end
     if f.kind_of? String
       return date.strftime( f )
     end
-    warn 'Unable to find Date format: #{it.inspect}.'
+    if humanizer.logger
+      humanizer.logger.error "Unable to find Date format: #{it.inspect}."
+    end
     return ''
   end
   
 end
-end
+end

data/lib/humanized/{ref.rb → interpolation/default.rb}

@@ -14,16 +14,16 @@
 #
 #    (c) 2011 by Hannes Georg
 #
-
+require 'humanized/wrapper'
 module Humanized
+module Default
   
-  # A Reference can be used to redirect lookups for certain paths.
-  class Ref < Array
-    
-    def inspect
-      '!ref'+super
-    end
-    
+def capitalize(humanizer, *str)
+  return Humanized::Wrapper.wrap(*str) do |s|
+    s[0...1].upcase + s[1..-1]
   end
-  
+end
+
+
+end
 end

data/lib/humanized/interpolation/german.rb

@@ -14,35 +14,37 @@
 #
 #    (c) 2011 by Hannes Georg
 #
+require 'humanized'
+require 'humanized/query'
 require 'humanized/interpolation/kng.rb'
 module Humanized
 module German
   
   module Articles
     
-    ArticleScope = Scope::Meta.articles
+    ArticleQuery = Query::Meta.articles
     
     def a(humanizer, *args)
       Wrapper.wrap(args) do |t|
-        humanizer[ArticleScope.indefinite.optionally(x_to_genus(humanizer, t))._(x_to_numerus(humanizer, t), x_to_kasus(humanizer, t))] + ' ' + t.to_s
+        humanizer[ArticleQuery.indefinite.optionally(x_to_genus(humanizer, t))._(x_to_numerus(humanizer, t), x_to_kasus(humanizer, t))] + ' ' + t.to_s
       end
     end
     
     def the(humanizer, *args)
       Wrapper.wrap(args) do |t|
-        humanizer[ArticleScope.definite.optionally(x_to_genus(humanizer, t))._(x_to_numerus(humanizer, t), x_to_kasus(humanizer, t))] + ' ' + t.to_s
+        humanizer[ArticleQuery.definite.optionally(x_to_genus(humanizer, t))._(x_to_numerus(humanizer, t), x_to_kasus(humanizer, t))] + ' ' + t.to_s
       end
     end
     
     def some(humanizer, *args)
       Wrapper.wrap(args) do |t|
-        humanizer[ArticleScope.partitive.optionally(x_to_genus(humanizer, t))._(x_to_numerus(humanizer, t), x_to_kasus(humanizer, t))] + ' ' + t.to_s
+        humanizer[ArticleQuery.partitive.optionally(x_to_genus(humanizer, t))._(x_to_numerus(humanizer, t), x_to_kasus(humanizer, t))] + ' ' + t.to_s
       end
     end
     
     def none(humanizer, *args)
       Wrapper.wrap(args) do |t|
-        humanizer[ArticleScope.negative.optionally(x_to_genus(humanizer, t))._(x_to_numerus(humanizer, t), x_to_kasus(humanizer, t))] + ' ' + t.to_s
+        humanizer[ArticleQuery.negative.optionally(x_to_genus(humanizer, t))._(x_to_numerus(humanizer, t), x_to_kasus(humanizer, t))] + ' ' + t.to_s
       end
     end
     
@@ -71,4 +73,4 @@ module German
   ].freeze
   
 end
-end
+end

data/lib/humanized/interpolation/kng.rb

@@ -43,11 +43,17 @@ module KNG
     end
     
     def to_s
+      return @kng_humanizer.get(__getobj__._(__generate_paths__))
+    end
+    
+  protected
+    
+    def __generate_paths__
+      a = Query::Root
       if @kng_genus
-        return @kng_humanizer[__getobj__._.optionally(@kng_genus)._(@kng_numerus, @kng_kasus)]
-      else
-        return @kng_humanizer[__getobj__._(@kng_numerus, @kng_kasus)]
+        a = a.optionally(@kng_genus)
       end
+      return a.optionally(@kng_numerus).optionally(@kng_kasus)
     end
     
   end
@@ -170,9 +176,11 @@ protected
       return x.kng_kasus
     end
     i = x.to_i
-    c = meta_class.const_get :KASUS
-    if i > 0 and i <= c.size
-      return c[i-1].to_sym
+    if x.kind_of? Numeric
+      c = meta_class.const_get :KASUS
+      if i > 0 and i <= c.size
+        return c[i-1].to_sym
+      end
     end
     return abbrev_kasus[x]
   end
@@ -214,4 +222,4 @@ protected
   
 end
   
-end
+end

data/lib/humanized/interpolation/number.rb

@@ -15,22 +15,83 @@
 #    (c) 2011 by Hannes Georg
 #
 
+require 'facets/numeric/round.rb'
+
 module Humanized
 module Number
   
-  def number(humanizer, number, format = 'default')
-    if format == 'default'
+  class PartitionEnumerator
+    
+    include Enumerable
+    
+    def initialize(range, size)
+      @range = range
+      @size = size
+    end
+    def each
+      i = @range.first
+      size = @range.last - @range.first
+      e = @range.end
+      if @range.exclude_end?
+          e = e - 1
+      else
+          size = size + 1
+      end
+      m = size.modulo(@size)
+      if m != 0
+        yield(i...(i+m))
+        i = i+m
+      end
+      while( i <= e )
+        yield(i...(i+@size))
+        i = i+@size
+      end
+    end
+  end
+  
+  
+  def number(humanizer, number, format = 'default', precision='')
+    
+    if format == 'default' or format.nil?
       it = number._(:format,:default)
     else
+      format = format.to_sym
       it = number._.format( format._ | :default._ )
     end
-    f = humanizer.get(it)
-    if f.kind_of? String
-      return sprintf(f,number)
+    
+    if precision.kind_of? String and precision.length > 0
+      precision = x_to_i(precision)
+    end
+    
+    unless precision.kind_of? Integer
+      precision = humanizer.get( it.precision , :default=>0 )
+    end
+    
+    num = number.round_at(precision).to_s
+    full, frac = num.split('.', 2)
+    
+    if( full.length > 3 )
+      separator = humanizer.get( it.separator , :default=>'' )
+      if separator.length > 0
+        full = PartitionEnumerator.new(0...full.length, 3).map{|rng|
+          full[rng]
+        }.join(separator)
+      end
     end
-    warn "Unable to find Number format: #{it.inspect}."
-    return ''
+    
+    if( precision > 0 )
+      delimiter = humanizer.get( it.delimiter , :default=>'.' )
+      if frac.length > precision
+        frac = frac[0...precision]
+      else
+        frac = frac.ljust(precision, '0')
+      end
+      return [full, frac].join(delimiter)
+    end
+    
+    return full
+    
   end
   
 end
-end
+end

data/lib/humanized/{scope.rb → query.rb}

@@ -15,28 +15,30 @@
 #    (c) 2011 by Hannes Georg
 #
 
+require 'facets/hash/graph.rb'
+
 module Humanized
-# A {Scope} is _the_ way to tell a {Humanizer} what you want from it.
+# A {Query} is _the_ way to tell a {Humanizer} what you want from it.
 # It contains of three parts:
 # * {#path a list of paths}, which will be looked up in a {Source source}
 # * {#default a default}, which will be used if nothing was found
 # * {#variables variables}, which will be used to interpolate a found string
 # That's all you need!
-# The good thing: you'll unlikly create a scope by hand, that's done automatically with "_"!
+# The good thing: you'll unlikly create a query by hand, that's done automatically with "_"!
 #
 # == Examples
 #
 # The basic steps:
-#  # Creates a scope which looks up ":a" with no default and no variables:
+#  # Creates a query which looks up ":a" with no default and no variables:
 #  :a._
-#  # Creates a scope which looks up nothing, has a default of "String" but no variables:
+#  # Creates a query which looks up nothing, has a default of "String" but no variables:
 #  "String"._
-#  # Creates a scope which looks up nothing, has no default but the variable :foo = "bar"
+#  # Creates a query which looks up nothing, has no default but the variable :foo = "bar"
 #  {:foo => 'bar'}._
 #
 # Combining these steps brings the power:
 #
-#  # Creates a scope which looks up ":a", has a default of "String" and the variable :foo = "bar"
+#  # Creates a query which looks up ":a", has a default of "String" and the variable :foo = "bar"
 #  :a._ + "String"._ + {:foo => 'bar'}._
 #  # Shorthand for this:
 #  :a._("String", :foo => 'bar')
@@ -49,7 +51,7 @@ module Humanized
 #    class Admin < User
 #    end
 #  end
-#  # Creates a scope matching ":site, :admin" or ":site, :user":
+#  # Creates a query matching ":site, :admin" or ":site, :user":
 #  Site::Admin._
 #  # This creates the same:
 #  Site::Admin.new._
@@ -58,32 +60,32 @@ module Humanized
 #  # This matches ":a, :b, :c":
 #  [:a, :b, :c]._
 #
-# Finally for Scopes itself:
-#  # Given scope is a Scope this is always true:
-#  scope._._ == scope._
+# Finally for Querys itself:
+#  # Given query is a Query this is always true:
+#  query._._ == query._
 #
 # I could continue the whole day ...
 #
 # == Tricks
-# A Scope responds to any method giving a new Scope suffixed by the method name
+# A Query responds to any method giving a new Query suffixed by the method name
 #  # Looks up ":a, :b, :c"
 #  :a._.b.c
-# "_" can also take a block which is instance evaled on the scope:
+# "_" can also take a block which is instance evaled on the query:
 #  # Looks up ":a, :b, :c"
 #  :a._{ b.c }
 #  # Looks up ":a, :x" or ":a, :y"
 #  :a._{ x | y }
-# There are two special scopes:
+# There are two special querys:
 #  # Looks up "", which will we be the whole source
-#  Humanized::Scope::Root
+#  Humanized::Query::Root
 #  # Looks up nothing
-#  Humanized::Scope::None
+#  Humanized::Query::None
 #
-  class Scope
+  class Query
     
     include Enumerable
 # @private
-    UNMAGIC_METHODS = [:to_ary]
+    UNMAGIC_METHODS = [:to_ary, :to_s, :to_sym, :freeze]
 # @private
     NAME_REGEX = /[a-z_]+/.freeze
 # @private
@@ -92,25 +94,28 @@ module Humanized
     attr_reader :path, :depth, :variables, :default
   
     def self.from_str(str)
-      Scope.new([ str.explode('.').map(&:to_sym) ])
+      Query.new([ str.explode('.').map(&:to_sym) ])
     end
   
-    def initialize(path = [[]], depth = 1, variables = {}, default = nil)
+    def initialize(path = [[]], depth = nil, variables = {}, default = nil)
       @path = path.uniq
-      @path.each do |path|
-        path.freeze
+      @path.each do |p|
+        p.freeze
       end
       @path.freeze
-      @depth = depth
-      @variables = variables
+      if !depth.nil? and path.size != @path.size
+        depth -= ( path.size - @path.size )
+      end
+      @depth = (depth || @path.size)
+      @variables = variables.graph do |k,v| [k.to_sym, v] end
       @default = default
     end
 
 # This method is a here to enable awesome DSL.
 #== Example
-#  s = Scope.new
-#  s.defining.a.scope.using_methods # gives: (defining.a.scope.using_methods)
-#  s.defining(:a,:scope,:using_methods) # gives: (defining.a.scope.using_methods)
+#  s = Query.new
+#  s.defining.a.query.using_methods # gives: (defining.a.query.using_methods)
+#  s.defining(:a,:query,:using_methods) # gives: (defining.a.query.using_methods)
 #  s.this{ is.awesome | is.awful } # gives: (this.is.awesome , this.is.awful)
 # 
     def method_missing(name, *args, &block)
@@ -126,17 +131,21 @@ module Humanized
     end
     
     def ==(other)
-      return false unless other.kind_of? Scope
-      return @path == other.path
+      return false unless other.kind_of? Query
+      if @path == other.path and @variables == other.variables and @default == other.default and @depth == other.depth
+        return true
+      else
+        return false
+      end
     end
     
-# Creates a {Scope scope} which matches either self or the other scope.
+# Creates a {Query query} which matches either self or the other query.
 # @example
 #  # this will match ":to_be" and ":not_to_be":
 #  ( :to_be._ | :not_to_be._ )
 #
-# @param [Scope] other another scope
-# @return [Scope] a new scope
+# @param [Query] other another query
+# @return [Query] a new query
     def |(other)
       return other if @path.none?
       return self.dup if other.none?
@@ -153,19 +162,38 @@ module Humanized
         i = i + sd
         j = j + od
       end
-      return Scope.new( result, sd + od , self.variables.merge(other.variables), other.default)
+      return Query.new( result, sd + od , self.variables.merge(other.variables), other.default)
     end
     
-# Creates a new scope which will optionally match this scope suffixed with the key.
+# Creates a new query which will optionally match this query suffixed with the key.
+#
+# @example
+#  # this will match ":borat_is_stupid, :not" and ":borat_is_stupid":
+#  :borat_is_stupid._.optionally(:not)
 #
 # @example
 #  # this will match ":borat_is_stupid, :not" and ":borat_is_stupid":
 #  :borat_is_stupid._.optionally(:not)
 #
 # @param key 
-# @return [Scope] a new scope
-    def optionally(key)
-      return self._(key) | self
+# @return [Query] a new query
+    def optionally(*keys)
+      
+      return self if keys.none?
+      
+      q = self._(*keys)
+      
+      begin
+      
+        keys.pop
+        
+        q |= q._(*keys)
+      
+      end while keys.any?
+    
+      q |= self
+    
+      return q
     end
     
     def [](*args)
@@ -179,21 +207,21 @@ module Humanized
           result << path + [arg]
         end
       end
-      return Scope.new( result, args.size )
+      return Query.new( result, args.size )
     end
     
-# Chain scopes together
+# Chain querys together
 # @example
 #  # this will match ":a,:b,:c"
 #  :a._ + :b._ + :c._
 #
-# @param *args an array of scopes for chaining
-# @return [Scope]
+# @param *args an array of querys for chaining
+# @return [Query]
     def +(*args)
       return self if args.none?
-      if( args.first.kind_of? Scope )
+      if( args.first.kind_of? Query )
         s = args.first
-        return Scope.new(@path, @depth, variables.merge(s.variables), self.default || s.default ) if @path.none? or s.path.none?
+        return Query.new(@path, @depth, variables.merge(s.variables), self.default || s.default ) if @path.none? or s.path.none?
         # TODO: maybe modify depth too?
         new_path = []
         @path.each do |x|
@@ -201,12 +229,12 @@ module Humanized
             new_path << x + path
           end
         end
-        return Scope.new(new_path, s.depth, variables.merge(s.variables), self.default || s.default )
+        return Query.new(new_path, s.depth, variables.merge(s.variables), self.default || s.default )
       end
       if @path.none?
         return self
       end
-      return Scope.new( @path.map{|x| x + args} , @depth , @variables, @default)
+      return Query.new( @path.map{|x| x + args} , @depth , @variables, @default)
     end
     
     def _(*args,&block)
@@ -215,9 +243,9 @@ module Humanized
       loop do
         break if args.none?
         arg = args.shift
-        if arg.kind_of? Symbol or arg.kind_of? Scope
+        if arg.kind_of? Symbol or arg.kind_of? Query
           thiz += arg
-        elsif arg.class == Hash
+        elsif arg.respond_to? :humanized_variables? and arg.humanized_variables?
           vars = arg
         else
           thiz += arg._
@@ -234,11 +262,11 @@ module Humanized
     end
   
     def with_variables(vars)
-      Scope.new(@path, @depth, variables.merge(vars), @default)
+      Query.new(@path, @depth, variables.merge(vars), @default)
     end
     
     def with_default(default)
-      Scope.new(@path, @depth, @variables, default)
+      Query.new(@path, @depth, @variables, default)
     end
   
     def inspect
@@ -261,4 +289,4 @@ module Humanized
     
     
   end
-end
+end