glue 0.20.0 → 0.21.0

data/lib/glue/flexob.rb

@@ -5,25 +5,25 @@ require 'ostruct'
 
 class Flexob < OpenStruct
 
-	def update(hash)
-		hash.each do |k, v|
-			send("#{k}=", v)
-		end
-	end
-	alias_method :set, :update
+  def update(hash)
+    hash.each do |k, v|
+      send("#{k}=", v)
+    end
+  end
+  alias_method :set, :update
 
-	def []=(key, val)
-		@table[key.to_sym] = val
-	end	
-	
-	def [](key)
-		@table[key.to_sym]
-	end
+  def []=(key, val)
+    @table[key.to_sym] = val
+  end  
+  
+  def [](key)
+    @table[key.to_sym]
+  end
 
-	def each(&block)
-		@table.each(&block)
-	end		
-	
+  def each(&block)
+    @table.each(&block)
+  end    
+  
 end
 
 # * George Moschovitis <gm@navel.gr>

data/lib/glue/hash.rb

@@ -1,6 +1,6 @@
 # * George Moschovitis  <gm@navel.gr>
 # (c) 2004-2005 Navel, all rights reserved.
-# $Id: hash.rb 1 2005-04-11 11:04:30Z gmosx $
+# $Id: hash.rb 182 2005-07-22 10:07:50Z gmosx $
 
 require 'sync'
 
@@ -13,41 +13,41 @@ module Glue
 # implementations!
 
 class SafeHash < Hash
-	attr :sync
+  attr :sync
 
-	# gmosx: delegator is not used.
-	#
-	def initialize(delegator = nil)
-		@sync = ::Sync.new
-	end
+  # gmosx: delegator is not used.
+  #
+  def initialize(delegator = nil)
+    @sync = ::Sync.new
+  end
 
-	def [](key)
-		@sync.synchronize(::Sync::SH) { super }
-	end
+  def [](key)
+    @sync.synchronize(::Sync::SH) { super }
+  end
 
-	def []=(key, value)
-		@sync.synchronize(::Sync::EX) { super }
-	end
+  def []=(key, value)
+    @sync.synchronize(::Sync::EX) { super }
+  end
 
-	def delete(key)
-		@sync.synchronize(::Sync::EX) { super }
-	end
+  def delete(key)
+    @sync.synchronize(::Sync::EX) { super }
+  end
 
-	def clear
-		@sync.synchronize(::Sync::EX) {	super }
-	end
+  def clear
+    @sync.synchronize(::Sync::EX) {  super }
+  end
 
-	def size
-		@sync.synchronize(::Sync::SH) {	super }
-	end
+  def size
+    @sync.synchronize(::Sync::SH) {  super }
+  end
 
-	def values
-		@sync.synchronize(::Sync::SH) { super }
-	end
+  def values
+    @sync.synchronize(::Sync::SH) { super }
+  end
 
-	def keys
-		@sync.synchronize(::Sync::SH) { super }
-	end
+  def keys
+    @sync.synchronize(::Sync::SH) { super }
+  end
 
 end 
 
@@ -68,54 +68,54 @@ end
 # hash = SafeHashDelegator.new(Hash.new)
 
 class SafeHashDelegator < Hash
-	attr :delegate, :sync
+  attr :delegate, :sync
 
-	def initialize(delegate)
-		@delegate = delegate
-		@sync = ::Sync.new
-	end
+  def initialize(delegate)
+    @delegate = delegate
+    @sync = ::Sync.new
+  end
 
-	def [](key)
-		@sync.synchronize(::Sync::SH) {
-			@delegate[key]
-		}
+  def [](key)
+    @sync.synchronize(::Sync::SH) {
+      @delegate[key]
+    }
   end
 
   def []=(key, value)
-		@sync.synchronize(::Sync::EX) {
-			@delegate[key] = value
-		}
-  end
-
-	def delete(key)
-		@sync.synchronize(::Sync::EX) {
-			@delegate.delete(key)
-		}
-	end
-
-	def clear
-		@sync.synchronize(::Sync::EX) {
-			@delegate.clear
-		}
-	end
-
-	def size
-		@sync.synchronize(::Sync::SH) {
-			@delegate.size()
-		}
-	end
-
-	def values
-		@sync.synchronize(::Sync::SH) {
-			@delegate.values()
-		}
-	end
-
-	def keys
-		@sync.synchronize(::Sync::SH) {
-			@delegate.keys()
-		}
-	end
+    @sync.synchronize(::Sync::EX) {
+      @delegate[key] = value
+    }
+  end
+
+  def delete(key)
+    @sync.synchronize(::Sync::EX) {
+      @delegate.delete(key)
+    }
+  end
+
+  def clear
+    @sync.synchronize(::Sync::EX) {
+      @delegate.clear
+    }
+  end
+
+  def size
+    @sync.synchronize(::Sync::SH) {
+      @delegate.size()
+    }
+  end
+
+  def values
+    @sync.synchronize(::Sync::SH) {
+      @delegate.values()
+    }
+  end
+
+  def keys
+    @sync.synchronize(::Sync::SH) {
+      @delegate.keys()
+    }
+  end
 
 end
 

data/lib/glue/helper.rb

@@ -12,18 +12,18 @@ module Glue
 
 module Helpers
 
-	def self.append_features(base)
-		base.module_eval do
-			def self.helper(*modules)
-				for mod in modules
-					symbols = mod.instance_methods.collect { |m| m.to_sym }
-					self.send(:include, mod)
-					self.send(:private, *symbols)
-				end
-			end
-		end
-	end
-	
+  def self.append_features(base)
+    base.module_eval do
+      def self.helper(*modules)
+        for mod in modules
+          symbols = mod.instance_methods.collect { |m| m.to_sym }
+          self.send(:include, mod)
+          self.send(:private, *symbols)
+        end
+      end
+    end
+  end
+  
 end
 
 end

data/lib/glue/idgen.rb

@@ -0,0 +1,9 @@
+# Abstract base class of all id generators.
+
+class Glue::IdGenerator
+  def next
+    raise "subclass responsibility"
+  end
+end
+
+# * Michael Neumann <mneumann@ntecs.de>

data/lib/glue/idgen/md5.rb

@@ -0,0 +1,24 @@
+# Returned ids might not be unique, but it should be very hard to guess the
+# next id.
+
+require 'glue/idgen'
+require 'digest/md5'
+
+class Glue::Md5IdGenerator < Glue::IdGenerator
+  def initialize(salt='ruby')
+    @salt = salt
+  end
+
+  def next
+    now = Time.now
+    md5 = Digest::MD5.new
+    md5.update(now.to_s)
+    md5.update(now.usec.to_s)
+    md5.update(rand(0).to_s)
+    md5.update($$.to_s)
+    md5.update(@salt.to_s)
+    md5.hexdigest
+  end
+end
+
+# * Michael Neumann <mneumann@ntecs.de>

data/lib/glue/idgen/sequential.rb

@@ -0,0 +1,15 @@
+# Returned ids are guaranteed to be unique, but they are easily guessable.
+
+require 'glue/idgen'
+
+class Glue::SequentialIdGenerator < Glue::IdGenerator
+  def initialize(initial_value=0)
+    @value = initial_value
+  end
+
+  def next
+    @value += 1
+  end
+end
+
+# * Michael Neumann <mneumann@ntecs.de>

data/lib/glue/literal_method.rb

@@ -0,0 +1,44 @@
+module Glue
+
+# A serializable method.
+#
+# For example, you can't marshal:
+#
+#   "ruby".method(:to_s)
+#
+# But you can:
+#
+#   Glue::LiteralMethodCallback.new("ruby", :to_s)
+#
+# or it's equivalent:
+#
+#   "ruby".literal_method(:to_s)
+
+class LiteralMethod
+  attr_reader :obj
+
+  def initialize(obj, method_id=:call, *args)
+    @obj, @method_id = obj, method_id
+    @args = args unless args.empty?
+  end
+
+  def call(*args, &block)
+    if @args
+      @obj.send(@method_id, *(@args+args), &block)
+    else
+       @obj.send(@method_id, *args, &block)
+    end
+  end
+
+  alias [] call
+end
+
+end # module Glue
+
+class Object
+  def literal_method(method_id, *args)
+    Glue::LiteralMethodCallback.new(self, method_id, *args)
+  end
+end
+
+# * Michael Neumann <mneumann@ntecs.de>

data/lib/glue/localization.rb

@@ -0,0 +1,130 @@
+require 'yaml'
+
+require 'glue/aspects'
+
+module Glue
+
+# Represents a locale.
+#--
+# TODO: initialize translation map from a yaml file.
+#++
+
+class Locale
+
+  # The localization map.
+
+  attr_accessor :map
+  
+  def initialize(map)
+    parse_hash(map)
+  end
+
+  # Transalte the given key.
+  #
+  # [+args+]
+  #    An array of arguments. The first argument
+  #    is the translation key. If additional arguments
+  #    are provided they are used for sprintf 
+  #    interpolation.
+  #--
+  # THINK: Possibly avoid the creation of the 
+  #  array by making the api less elegant.
+  #++
+
+  def translate(*args)
+    if xlated = @map[args.shift]
+      if xlated.is_a?(String)
+        args.empty? ? xlated : sprintf(xlated, *args)
+      else
+        xlated.call(*args)
+      end
+    end
+  end
+  alias_method :[], :translate
+
+  private
+
+  def parse_hash(map)
+    @map = map
+  end
+
+  def parse_yaml(yaml)
+    raise 'Not implemented'
+  end
+  
+end
+
+# Localization support.
+#
+# === Example 
+#
+#  locale_en = {
+#    'See you' => 'See you',
+#    :long_paragraph => 'The best new books, up to 30% reduced price',
+#    :price => 'Price: %d %s',
+#    :proc_price => proc { |value, cur| "Price: #{value} #{cur}" }
+#  }
+#
+#  locale_de = {
+#    'See you' => 'Auf wieder sehen',
+#    :long_paragraph => 'Die besten neuer buecher, bis zu 30% reduziert',
+#    ...
+#  }
+#
+#  Localization.add(:en => locale_en, :de => locale_de)
+#
+# lc = Localization.get
+# lc['See you'] -> See you
+# lc[:price, 100, 'euro'] -> Price: 100 euro
+# lc = Localization.get[:de]
+# lc['See you'] -> Auf wiedersehen
+#
+# To make localization even more easier, a LocalizationAspect
+# is provide provided. Additional transformation macros are
+# provided if you require 'nitro/compiler/localization'
+
+class Localization
+
+  class << self
+    
+    # A hash of the available locales.
+
+    attr_accessor :locales
+
+    def add(map = {})
+      for key, locale in map
+        if locale.is_a?(String)
+          # this is the name of the localization file.
+          locale = YAML.load(File.read(locale))
+        end
+        @locales[key.to_s] = Locale.new(locale)
+      end
+    end
+        
+    # Return the localization hash for the given
+    # locale.
+
+    def get(locale = :en)
+      locale ||= 'en'
+      @locales[locale.to_s]
+    end
+    alias_method :locale, :get
+    alias_method :[], :get
+
+  end
+
+  @locales = {}
+
+end
+
+# Localization Aspect for Nitro controllers.
+
+module LocalizationAspect
+  def localize
+    @lc = Localization[@context.session[:LOCALE]]
+  end
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>