glue 0.41.0 → 1.0.0

data/lib/glue/html.rb

@@ -1,12 +0,0 @@
-module Glue
-module Html
-  def self.cleanup(buf)
-    out = buf.dup
-    elements = "input|img|br|hr|link|style|render|include|inject|base|meta"
-    out.gsub! /<textarea ([^>]*)><\/textarea>/, '<textarea \1>#{}</textarea>'
-    out.gsub! /<(#{elements}) ([^>]*)><\/\1>/, '<\1 \2 />'
-    out.gsub! /<(#{elements})><\/\1>/, '<\1 />'
-    out
-  end
-end
-end

data/lib/glue/localization.rb

@@ -1,129 +0,0 @@
-require 'yaml'
-
-require 'facets/more/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
-    alias_method :locales=, :add
-        
-    # 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

data/lib/glue/logger.rb

@@ -1,208 +0,0 @@
-require 'logger'
-
-# A simple extension of the Ruby logger. Mainly for 
-# compatibility purposes.
-#
-# === Convention
-#
-# When using debug level logger messages always append 'if $DBG'
-# at the end. This hack is needed because Ruby does not support
-# lazy evaluation (lisp macros).
-#--
-# THINK: some people think, this extension is dangerous, 
-# investigate.
-#++
-
-class Logger
-  alias_method :devel, :debug
-  alias_method :fine, :debug
-  
-  # Prints a trace message to DEBUGLOG (at debug level).  
-  # Useful for emitting the value of variables, etc.  Use 
-  # like this:
-  #
-  #   x = y = 5
-  #   trace 'x'        # -> 'x = 5'
-  #   trace 'x ** y'   # -> 'x ** y = 3125'
-  #
-  # If you have a more complicated value, like an array of 
-  # hashes, then you'll probably want to use an alternative 
-  # output format.  For instance:
-  #
-  #   trace 'value', :yaml
-  #
-  # Valid output format values (the _style_ parameter) are:
-  #
-  #   :p :inspect
-  #   :pp                     (pretty-print, using 'pp' library)
-  #   :s :to_s
-  #   :y :yaml :to_yaml       (using the 'yaml' library')
-  #
-  # The default is <tt>:p</tt>.
-  #
-  # CREDITS:
-  # 
-  # This code comes straight from the dev-utils Gem.
-  # Author: Gavin Sinclair <gsinclair@soyabean.com.au>
-  
-  def trace(expr, style=:p)
-    unless expr.respond_to? :to_str
-      warn "trace: Can't evaluate the given value: #{caller.first}"
-    else
-      require 'facet/binding/self/of_caller'
-
-      Binding.of_caller do |b|
-        value = b.eval(expr.to_str)
-        formatter = TRACE_STYLES[style] || :inspect
-        case formatter
-        when :pp then require 'pp'
-        when :y, :yaml, :to_yaml then require 'yaml'
-        end
-        value_s = value.send(formatter)
-        message = "#{expr} = #{value_s}"
-        lines = message.split(/\n/)
-        indent = "   "
-        debug(lines.shift)                      
-        lines.each do |line|
-          debug(indent + line)
-        end
-      end
-    end
-  end
-
-  TRACE_STYLES = {}  # :nodoc:
-  TRACE_STYLES.update( 
-    :pp => :pp_s, :s => :to_s, :p => :inspect, 
-    :y => :to_yaml, :yaml => :to_yaml, 
-    :inspect => :inspect, :to_yaml => :to_yaml 
-  )
-
-  # Dictate the way in which this logger should format the 
-  # messages it displays. This method requires a block. The 
-  # block should return formatted strings given severity, 
-  # timestamp, msg, progname.
-  #
-  # === Example
-  #
-  # logger = Logger.new
-  # logger.setup_format do |severity, timestamp, msg, progname|
-  #   "#{progname}@#{timestamp} - #{severity}::#{msg}"
-  # end
-
-  def setup_format(&format_proc)
-    raise 'Formating block needed' unless format_proc
-    @format_proc = format_proc
-  end
-
-private
-  
-  # hackish use of *args, give me some love.
-  
-  alias_method :old_format_message, :format_message # :nodoc:
-  def format_message(*args) # :nodoc:
-    @format_proc ? @format_proc.call(*args) : old_format_message(*args)
-  end
-end
-
-# Global logger interface. This provides an alternative 
-# Singleton interface to the Logger.
-
-class Logger
-
-  SIMPLE_FORMAT = "%5s: %s\n"
-  @@global_logger = Logger.new(STDERR)
-  @@global_logger.setup_format do |severity, timestamp, progname, msg|  
-    SIMPLE_FORMAT % [severity, msg]
-  end
-  
-  # Set the global Logger.
-  
-  def self.set(logger)
-    if logger.is_a?(String) || logger.is_a?(IO)
-      @@global_logger = Logger.new(logger)
-    elsif logger.is_a?(Logger)
-      @@global_logger = logger
-    else
-      raise ArgumentError
-    end
-    
-    @@global_logger.setup_format do |severity, timestamp, progname, msg|  
-      SIMPLE_FORMAT % [severity, msg]
-    end
-  end
-
-  def self.get
-    @@global_logger
-  end
-  
-  def self.warn(str)
-    @@global_logger.warn(str)
-  end
-
-  def self.info(str)
-    @@global_logger.info(str)
-  end
-
-  def self.debug(str)
-    @@global_logger.debug(str)
-  end
-  
-  def self.error(str)
-    @@global_logger.error(str)
-  end
-
-  #--
-  # Saddly have to duplicate the code to make
-  # Binding.of_caller work.
-  #++
-  
-  def self.trace(expr, style=:p)
-    unless expr.respond_to? :to_str
-      warn "trace: Can't evaluate the given value: #{caller.first}"
-    else
-      require 'facet/binding/self/of_caller'
-
-      Binding.of_caller do |b|
-        value = eval(expr.to_str, b)
-        formatter = TRACE_STYLES[style] || :inspect
-        case formatter
-        when :pp then require 'pp'
-        when :y, :yaml, :to_yaml then require 'yaml'
-        end
-        value_s = value.send(formatter)
-        message = "#{expr} = #{value_s}"
-        lines = message.split(/\n/)
-        indent = "   "
-        debug(lines.shift)                      
-        lines.each do |line|
-          debug(indent + line)
-        end
-      end
-    end
-  end
-end
-
-module Glue
-
-# UNDER CONSTRUCTION.
-#
-# Add logging capabilities to the including class.
-#
-# === Examples
-#
-# Og.log_info 'Hello' => '[Og] Hello'
-# Render.log_info ...
-# In Render:
-# log_info '...'
-
-module Logging 
-=begin
-  def self.included base
-    [ :info, :debug ].each do |l|
-    
-    end
-  end
-=end
-end
-
-end

data/lib/glue/mail.rb

@@ -1,160 +0,0 @@
-require 'net/smtp'
-
-module Glue
-
-# Encapsulates an email message.
-
-class Mail
-
-  # The default charset.
-
-  setting :default_charset, :default => 'utf-8', :doc => 'The default character set'
-
-  # Encode the subject?
-
-  setting :encode_subject, :default => false, :doc => 'Encode the subject?' 
-
-  # Sender, can be an array.
-
-  attr_accessor :from
-
-  # The list of the recipients, can be arrays.
-  
-  attr_accessor :to, :cc, :bcc
-
-  # The subject
-
-  attr_accessor :subject
-
-  # The body of the message.
-
-  attr_accessor :body
-
-  # Reply to.
-
-  attr_accessor :reply_to
-
-  # Sent on
-
-  attr_accessor :sent_on
-
-  # Encode the subject?
-
-  attr_accessor :encode_subject
-  
-  # The charset used to encode the message.
-
-  attr_accessor :charset
-
-  # Additional headers
-
-  attr_accessor :headers
-
-  def initialize(from = nil, to = nil, subject = nil, body = nil)
-    @from, @to, @subject, @body = from, to, subject, body
-    @headers = {}
-  end
-
-  def parse_headers
-    @from = @headers['From']
-    @to = @headers['To']
-    @cc = @headers['Cc']
-    @bcc = @headers['Bcc']
-    @subject = @headers['Subject']
-  end
-
-  # Accept string or IO.
-  
-  def self.new_from_encoded(encoded)
-    if encoded.is_a? String
-      require 'stringio'
-      encoded = StringIO.new(encoded)
-    end
-
-    f = encoded
-    
-    # the following code is copied from mailread.rb
-    
-    unless defined? f.gets
-      f = open(f, "r")
-      opened = true
-    end
-
-    _headers = {}
-    _body = []
-    begin
-      while line = f.gets()
-        line.chop!
-        next if /^From /=~line  # skip From-line
-        break if /^$/=~line     # end of header
-
-        if /^(\S+?):\s*(.*)/=~line
-          (attr = $1).capitalize!
-          _headers[attr] = $2
-        elsif attr
-          line.sub!(/^\s*/, '')
-          _headers[attr] += "\n" + line
-        end
-      end
-  
-      return unless line
-
-      while line = f.gets()
-        break if /^From /=~line
-        _body.push(line)
-      end
-    ensure
-      f.close if opened
-    end
-
-    mail = Mail.new
-    mail.headers = _headers
-    mail.body = _body.join("\n")
-    mail.parse_headers
-    
-    return mail
-  end  
-
-  def [](key)
-    @headers[key]
-  end
-
-  def []=(key, value)
-    @headers[key] = value
-  end
-  
-  # Returns the Mail message in encoded format.
-
-  def encoded
-    raise 'No body defined' unless @body
-    raise 'No sender defined' unless @from
-    raise 'No recipients defined' unless @to
-
-    # gmosx: From is typically NOT an array.
-
-    from = @from.is_a?(Array) ? @from.join(', ') : @from
-    buf = "From: #{from}\n"
-    
-    to = @to.is_a?(Array) ? @to.join(', ') : @to
-    buf << "To: #{to}\n"
-    
-    if @cc
-      cc = @cc.is_a?(Array) ? @cc.join(', ') : @cc
-      buf << "Cc: #{cc}\n"
-    end
-    
-    if @bcc
-      bcc = @bcc.is_a?(Array) ? @bcc.join(', ') : @bcc
-      buf << "Bcc: #{bcc}\n"
-    end
-    
-    buf << "Subject: #@subject\n" if @subject
-    
-    buf << "\n"  
-    buf << @body
-
-    return buf
-  end
-end
-
-end