glue 0.41.0 → 1.0.0

data/lib/glue/cache/memory.rb

@@ -1,79 +0,0 @@
-require 'facet/synchash'
-
-require 'glue/cache'
-
-module Glue
-
-# A cache backed in memory. 
-#--
-# This implementation is also the base for the Drb Cache.
-#++
-
-class MemoryCache < Cache
-  attr :hash
-
-  def initialize(options = {})
-    if options[:sync]
-      @hash = SyncHash
-    else
-      @hash = {}
-    end
-  end
-
-  # Get an object from the cache.
-  
-  def get(key, options = nil)
-    @hash[key]
-  end
-  alias_method :read, :get
-  alias_method :[], :get
-
-  # Put an object in the cache.
-  
-  def set(key, value = nil, options = nil)
-    @hash[key] = value
-  end
-  alias_method :put, :set
-  alias_method :write, :set
-  alias_method :[]=, :set
-  
-  # Delete an object from the cache.
-  
-  def delete(key, options = nil) 
-    @hash.delete(key)
-  end
-  alias_method :remove, :delete
-
-  def delete_if(&block)
-    @hash.delete_if(&block)
-  end
-
-  # Perform session garbage collection. Typically this method
-  # is called from a cron like mechanism.
-  
-  def gc!
-    delete_if { |key, s| s.expired? }
-  end
-
-  # Return the mapping.
-  
-  def mapping
-    @hash
-  end
-
-  # Return all keys in the cache.
-  
-  def keys
-    @hash.keys
-  end
-
-  # Return all objects in the cache.
-  
-  def all
-    @hash.values
-  end
-  alias_method :values, :all
-  
-end
-  
-end

data/lib/glue/cache/og.rb

@@ -1,61 +0,0 @@
-require 'og'
-require 'base64'
-
-module Glue
-
-  class OgCached
-    include Og::EntityMixin
-    
-    property :unique_id, String, :sql => 'PRIMARY KEY'
-    property :expires, Time
-    property :cache_name, String
-    property :content, String
-    
-    set_primary_key :unique_id, String
-  end
-
-  class OgCache
-
-    def initialize(cache_name, keepalive = nil)
-      @cache_name = cache_name
-      @keepalive = keepalive
-    end
-
-    def []=(k,v)
-      unless s = OgCached.find_by_unique_id_and_cache_name(k.to_s, @cache_name)
-        s = OgCached.new
-        s.cache_name = @cache_name
-        s.expires = Time.now + @keepalive if @keepalive
-        s.unique_id = k.to_s
-      end
-      #s.content = v.to_yaml
-      s.content = encode(v)
-      s.insert
-    end
-
-    def [](k)
-      s = OgCached.find_by_unique_id_and_cache_name(k.to_s, @cache_name)
-      decode(s.content) if s
-    end
-
-    def gc!
-      OgCached.find(:condition => ["expires < ? AND cache_name = ?", Time.now, @cache_name]).each {|s| s.delete }
-    end
-
-    def all
-      OgCached.find_by_cache_name(@cache_name)
-    end
-
-    private
-
-    def encode(c)
-      Base64.encode64(Marshal.dump(c))
-    end
-
-    def decode(c)
-      Marshal::load(Base64.decode64(c)) 
-      #s.content = YAML::load(s.content)
-    end
-
-  end
-end

data/lib/glue/configuration.rb

@@ -1,305 +0,0 @@
-require 'yaml'
-
-require 'facets/core/kernel/constant'
-require 'facets/more/synchash'
-require 'facets/more/dictionary'
-require 'facets/core/string/capitalized'
-require 'facets/core/class/cattr'
-
-module Glue
-
-# A Configuration holds a group of Settings organized by
-# Owners. An owner is a class that represents the system to be
-# configured. An alias for this class is Settings.
-#
-# You can pass strings, constants or symbols as keys for the
-# classes to be configured. Passing symbols you can configure
-# classes even before they are defined.
-#--
-# TODO: implement with annotations.
-#++
-
-class Configuration
-
-  # A hash of setting owners. Use double @'s to allow for
-  # the Settings alias.
-  #--
-  # TODO: find a better name.
-  #++
-    
-  @@owners = SyncHash.new  
-
-  # A datastructure to store Settings metadata.
-  # 
-  # Please note the difference between :default and :value,
-  # :default does NOT override :value.
-    
-  class Setting
-    attr_accessor :owner, :name, :type, :value, :options
-    
-    def initialize(owner, name, options)
-      if options.key? :value
-        @value = options[:value]
-      elsif options.key? :default 
-        @value = options[:default]
-      else
-        raise ArgumentError.new('A value is required')
-      end
-      
-      @owner, @name = owner, name
-      @options = options      
-      @type = options[:type] = options[:type] || @value.class
-    end
-
-    # Update the setting from an options hash. The update does
-    # NOT take default values into account!
-    
-    def update(hash)
-      if hash.key? :value
-        @value = hash[:value]
-        @type = @value.class
-      end
-      
-      if hash.key? :type
-        @type = hash[:type]
-      end
-
-      @options.update(hash)
-    end
-    
-    # Text representation of this setting.
-    
-    def to_s
-      @value.to_s
-    end
-
-  end
-
-  # A collection of Settings. This helper enables intuitive
-  # settings initialization like this:
-  #
-  # Configuration.Compiler.template_root = 'public'
-  # instead of
-  # Configuration.setting :compiler, :template_root, :value => 'public'
-  
-  class SettingCollection < Hash
-    attr_accessor :owner
-    
-    # Handles setting readers and writers.
-    
-    def method_missing(sym, *args)
-      if sym.to_s =~ /=$/
-        # Remove trailing 
-        sym = sym.to_s.gsub(/=/, '').to_sym
-        Configuration.setting @owner, sym, :value => args.first
-      else
-        self[sym]
-      end
-    end
-  end
-    
-  class << self
-
-    # The configuration mode, typical modes include :debug, 
-    # :stage, :live. 
-    #
-    # [:debug]
-    #    useful when debugging, extra debug information
-    #    is emmited, actions, templates and shaders are
-    #    reloaded, etc. The execution speed of the application
-    #    is impaired.
-    #
-    # [:stage]
-    #    test the application with live parameters 
-    #    (typically on a staging server).
-    #
-    #  [:live]
-    #    use the parameters for the live (production)
-    #    server. Optimized for speed.
-    #
-    # Tries to set the default value from the NITRO_MODE
-    # environment variable.
-    
-    attr_accessor :mode
-
-    def mode
-      mode = nil
-      if mode = ENV['CONFIGURATION_MODE']
-        $stderr.puts "CONFIGURATION_MODE is deprecated, use NITRO_MODE"
-      end
-      @mode || mode || ENV.fetch('NITRO_MODE', :debug).to_sym
-    end
-    
-    # The log output destination.
-    #
-    # ['STDOUT' 'STDERR']
-    #     Sets the log to stdout or stderr.
-    #
-    # [str]
-    #     Any other string is regarded as path
-    
-    attr_accessor :log
-    
-    def log
-      return @log if @log
-      
-      log = ENV.fetch('NITRO_LOG', Logger.new('log/app.log'))
-      
-      if log.kind_of?(String)
-        if log =~ /(STD(?:OUT|ERR))/i
-          log = Object.const_get($1.upcase)
-        elsif File.directory?(File.dirname(log))
-          log = Logger.new(log)
-        else
-          log = 'log/app.log'
-        end
-      end
-      
-      @log = log
-    end
-    
-    alias kernel_load load
-    
-    # Attempt to load external configuration in Ruby or
-    # YAML format. The files:
-    #
-    # * conf/mode.rb
-    # * conf/mode.yaml
-    #
-    # are considered.
-    
-    def load(m = mode)
-      ruby_conf = "conf/#{m}.rb"
-      kernel_load(ruby_conf) if File.exist?(ruby_conf)
-
-      # Try to configure from a yaml file.
-      yml_conf = "conf/#{m}.yml"
-      Configuration.load_yaml(yml_conf) if File.exist?(yml_conf)
-    end
-  
-    # Inject the configuration parameters provided as a hash
-    # (dictionary, ordered) to classes to be configured.
-    # 
-    # === Warning: Pass an ordered hash (dictionary)
-    
-    def setup(options)
-      options.each do |owner, ss|
-        next unless ss
-        ss.each do |name, s|
-          add_setting(owner, name.to_sym, :value => s)
-        end 
-      end
-    end
-
-    # Parse configuration parameters in yaml format.
-    
-    def parse_yaml(options)
-      temp = YAML::load(options)
-      options = Dictionary.new
-      temp.each do |k, v| 
-        options[k.gsub(/\./, '::').to_sym] = v
-      end
-
-      setup(options)
-    end
-    
-    # Load an external ruby configuration file. Constant missing
-    # errors are not reported for extra flexibility.
-    
-    def load_ruby(filename)
-    end
-    
-    # Load and parse an external yaml configuration file.
-    
-    def load_yaml(filename)
-      parse_yaml(File.read(filename))
-    end
-
-    # Manually add a configuration setting. The class key can
-    # be the actual class name constant or a symbol. If the
-    # setting is already defined it updates it. 
-    # 
-    # === Examples
-    #
-    # Configuration.add_setting Compiler, :verification, :value => 12, :doc => '...'
-    # Configuration.setting :IdPart, :verify_registration_email, :value => false
-    # s = Configuration.Compiler.verification.value 
-        
-    def add_setting(owner, name, options)
-      owner = owner.to_s.to_sym 
-      @@owners[owner] ||= {}
-      if s = @@owners[owner][name]
-        # The setting already exists, update it.
-        s.update(options)
-      else
-        # The setting does not exist, create it.
-        @@owners[owner][name] = Setting.new(owner, name, options)
-      end
-    end
-    alias_method :setting, :add_setting
-
-    # Return the settings for the given owner. The owner is 
-    # typically the Class that represents the system to be 
-    # configured. If no class is provided, it returns all the
-    # registered settings.
-        
-    def settings(owner = nil)
-      if owner
-        owner = owner.to_s.to_sym 
-        @@owners[owner]
-      else
-        @@owners.values.inject([]) { |memo, obj| memo.concat(obj.values) }
-      end
-    end
-    alias_method :all, :settings
-    alias_method :[], :settings
-
-    #--
-    # FIXME: this does not work as expected.
-    #++
-    
-    def method_missing(sym)
-      if sym.to_s.capitalized?
-         bdl = SettingCollection.new
-         bdl.owner = sym
-         if hash = self[sym]
-           bdl.update(hash)
-         end
-         return bdl
-      end
-    end
-  end
-  
-end
-
-# Alias for the Configuration class (shorter).
-
-Settings = Configuration
-
-end
-
-class Module
-
-  # Defines a configuration setting for the enclosing class.
-  #
-  # === Example
-  #
-  # class Compiler
-  #   setting :template_root, :default => 'src/template', :doc => 'The template root dir'
-  # end
-  
-  def setting(sym, options = {})
-    Glue::Configuration.add_setting(self, sym, options)
-    
-    module_eval %{
-      def self.#{sym}
-        Glue::Configuration[#{self}][:#{sym}].value
-      end
-      
-      def self.#{sym}=(obj)
-        Glue::Configuration.setting #{self}, :#{sym}, :value => obj
-      end
-    }
-  end
-  
-end

data/lib/glue/fixture.rb

@@ -1,154 +0,0 @@
-require 'facet/kernel/constant'
-
-require 'facet/ormsupport'
-
-require 'glue/configuration'
-require 'nitro/template'
-
-module Glue
-
-# A collection of helper methods.
-
-class Fixtures
-
-  # The directory where the fixtures are located.
-  
-  setting :root_dir, :default => 'test/fixture', :doc => 'The directory where the fixtures are located'
-
-  @fixtures = {}
-  
-  class << self
-  
-    def load(*classes)
-      for klass in classes
-        f = Fixture.new(klass).load
-        @fixtures[f.name] = f
-      end
-    end  
-
-    def [](klass)
-      @fixtures[klass]
-    end
-    
-    def []=(klass, fixture)
-      @fixtures[klass] = fixture
-    end
-    
-    def method_missing(sym)
-      if f = @fixtures[sym.to_s]
-        return f
-      end
-      super
-    end  
-  end
-end
-
-# Fixtures is a fancy word for ‘sample data’. Fixtures allow you 
-# to populate your database with predefined data. Fixtures are
-# typically used during testing or when providing initial data
-# (bootstrap data) for a live application.
-#
-# A Fixture is a collection (Hash) of objects.
-
-class Fixture < Hash
-
-  # The name of this Fixture.
-  
-  attr_accessor :name
-  
-  # The class that the Fixtures refer to.
-  
-  attr_accessor :klass
-
-  # Used to keep the order.
-  
-  attr_accessor :objects
-  
-  def initialize(klass, options = { } )
-    @klass = klass
-    @name = class_to_name(klass)
-    @objects = []    
-    load(options[:root_dir] || options[:root] || Fixtures.root_dir)
-  end
-
-  def load(root_dir = Fixtures.root_dir)
-    raise("The fixture root directory '#{root_dir}' doesn't exits") unless File.exist?(root_dir)
-
-    if path = "#{root_dir}/#{@name}.yml" and File.exist?(path)
-      parse_yaml(path)
-    end
-
-    if path = "#{root_dir}/#{@name}.yaml" and File.exist?(path)
-      parse_yaml(path)
-    end
-    
-    if path = "#{root_dir}/#{@name}.csv" and File.exist?(path)
-      parse_csv(path)
-    end
-    
-    return self
-  end
-  
-  # Parse a fixture file in YAML format.
-  
-  def parse_yaml(path)
-    require 'yaml'
-
-    str = Nitro::Template.new.render(File.read(path))
-    
-    if yaml = YAML::load(str)
-      for name, data in yaml
-        self[name] = instantiate(data)
-      end
-    end
-
-    # sort the objects.
-        
-    str.scan(/^(\w*?):$/).each do |key|
-      @objects << self[key.to_s]
-    end
-  end
-
-  # Parse a fixture file in CSV format. Many RDBM systems and 
-  # Spreadsheets can export to CVS, so this is a rather useful
-  # format.
-  
-  def parse_csv(path)
-    require 'csv'
-
-    str = Nitro::Template.new.render(File.read(path))
-    
-    reader = CSV::Reader.create(str)
-    header = reader.shift
-
-    reader.each_with_index do |row, i|
-      data = {}
-      row.each_with_index do |cell, j| 
-        data[header[j].to_s.strip] = cell.to_s.strip 
-      end
-      self["#{@name}_#{i+1}"] = obj = instantiate(data)
-      @objects << obj
-    end
-  end
-  
-private    
-
-  # Instantiate an actual object from the Fixture data.
-    
-  def instantiate(data)
-    obj = @klass.allocate
-    
-    for key, value in data
-      obj.instance_variable_set("@#{key}", value)
-    end
-    
-    return obj
-  end
-
-  def class_to_name(klass)
-    klass.to_s.demodulize.underscore
-  end  
-  
-end
-
-end