ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/contrib/facebook.rb

@@ -1,23 +0,0 @@
-require __DIR__/:facebook/:facebook
-
-module Ramaze
-  module Helper::Facebook
-    def self.included(klass)
-      klass.send(:helper, :aspect)
-    end
-
-    def error
-      if Facebook::ADMINS.include? facebook[:user]
-        error = Ramaze::Dispatcher::Error.current
-        [error, *error.backtrace].join '<br/>'
-      end
-    end
-
-    private
-
-    def facebook
-      @facebook ||= Facebook::Client.new
-    end
-    alias fb facebook
-  end
-end

data/lib/ramaze/contrib/file_cache.rb

@@ -1,65 +0,0 @@
-#
-# drop-in replacement for Ramaze's built-in MemoryCache built on the
-# filesystem.  # to use with sessions do
-#
-#   Ramaze::Global::cache_alternative[:sessions] = Ramaze::FileCache
-#
-# to use with everything do
-#
-#   Ramaze::Global::cache = Ramaze::FileCache
-#
-
-module Ramaze::FileCache
-  require "fileutils"
-  require "socket"
-
-  Host = Socket.gethostname
-  Pid = Process.pid
-  Fu = FileUtils
-  Root = File.join Ramaze::APPDIR, "cache"
-
-  Fu.mkdir_p(Root) rescue nil
-
-  def self.[] key
-    path = File.join Root, key, "data"
-    Marshal.load(IO.read(path))
-  rescue
-    nil
-  end
-
-  def self.[]= key, value
-    tmp = File.join Root, key, "data.#{ Host }.#{ Pid }"
-    dirname = File.join Root, key
-    path = File.join Root, key, "data"
-    data = Marshal.dump value
-    Fu.rm_rf dirname rescue nil
-    Fu.mkdir_p dirname rescue nil
-    open(tmp, 'w'){|fd| fd.write data}
-    Fu.mv tmp, path
-  rescue
-    nil
-  end
-
-  def self.values_at *keys
-    keys.map{|key| self[key]}
-  end
-
-  def self.delete *keys
-    keys.map do |key|
-      dirname = File.join Root, key
-      Fu.rm_rf dirname rescue next 
-    end
-  end
-
-  def self.clear
-    Dir["#{ Root }/*"].each{|entry| Fu.rm_rf entry}
-  end
-
-  def self.new
-    self
-  end
-
-  def self.to_sym
-    name.split(%r/::/).last.to_sym
-  end
-end

data/lib/ramaze/contrib/gettext/mo.rb

@@ -1,155 +0,0 @@
-=begin
-    mo.rb - A simple class for operating GNU MO file.
-
-    Copyright (C) 2003-2006  Masao Mutoh
-    Copyright (C) 2002  Masahiro Sakai, Masao Mutoh
-    Copyright (C) 2001  Masahiro Sakai
-
-        Masahiro Sakai                  <s01397ms@sfc.keio.ac.jp>
-        Masao Mutoh                     <mutoh@highway.ne.jp>
-
-    You can redistribute this file and/or modify it under the same term
-    of Ruby.  License of Ruby is included with Ruby distribution in
-    the file "README".
-
-    $Id: mo.rb,v 1.7 2006/06/11 15:36:20 mutoh Exp $
-=end
-
-require 'iconv'
-
-class MOFile < Hash
-  class InvalidFormat < RuntimeError; end;
-
-  attr_reader :filename
-
-  Header = Struct.new(:magic,
-                      :revision,
-                      :nstrings,
-                      :orig_table_offset,
-                      :translated_table_offset,
-                      :hash_table_size,
-                      :hash_table_offset)
-
-  MAGIC_BIG_ENDIAN    = "\x95\x04\x12\xde"
-  MAGIC_LITTLE_ENDIAN = "\xde\x12\x04\x95"
-
-  def self.open(arg = nil, output_charset = nil)
-    result = self.new(output_charset)
-    result.load(arg)
-  end
-
-  def initialize(output_charset = nil)
-    @filename = nil
-    @last_modified = nil
-    @little_endian = true
-    @output_charset = output_charset
-    super
-  end
-
-  def update!
-    if FileTest.exist?(@filename)
-      st = File.stat(@filename)
-      load(@filename) unless (@last_modified == [st.ctime, st.mtime])
-    else
-      puts "#{@filename} was lost." if $DEBUG
-      clear
-    end
-    self
-  end
-
-  def load(arg)
-    case arg
-    when String
-      begin
-	      st = File.stat(arg)
-	      @last_modified = [st.ctime, st.mtime]
-      rescue Exception
-      end
-      load_from_file(arg)
-    when IO
-      load_from_stream(arg)
-    end
-    @filename = arg
-    self
-  end
-
-  def load_from_stream(io)
-    magic = io.read(4)
-    case magic
-    when MAGIC_BIG_ENDIAN
-      @little_endian = false
-    when MAGIC_LITTLE_ENDIAN
-      @little_endian = true
-    else
-      raise InvalidFormat.new("Unknown signature %s" % magic.dump)
-    end
-
-    header = Header.new(magic, *(io.read(4 * 6).unpack(@little_endian ? 'V6' : 'N6')))
-    raise InvalidFormat.new(sprintf("file format revision %d isn't supported", header.revision)) if header.revision > 0
-
-    io.pos = header.orig_table_offset
-    orig_table_data = io.read((4 * 2) * header.nstrings).unpack(@little_endian ? 'V*' : 'N*')
-
-    io.pos = header.translated_table_offset
-    trans_table_data = io.read((4 * 2) * header.nstrings).unpack(@little_endian ? 'V*' : 'N*')
-
-    original_strings = Array.new(header.nstrings)
-    for i in 0...header.nstrings
-      io.pos = orig_table_data[i * 2 + 1]
-      original_strings[i] = io.read(orig_table_data[i * 2 + 0])
-    end
-
-    clear
-    for i in 0...header.nstrings
-      io.pos = trans_table_data[i * 2 + 1]
-      str = io.read(trans_table_data[i * 2 + 0])
-
-      if original_strings[i] == ""
-        if str
-          @charset = nil
-          @nplurals = nil
-          @plural = nil
-          str.each_line{|line|
-            if /^Content-Type:/i =~ line and /charset=((?:\w|-)+)/i =~ line
-              @charset = $1
-            elsif /^Plural-Forms:\s*nplurals\s*\=\s*(\d*);\s*plural\s*\=\s*([^;]*)\n?/ =~ line
-              @nplurals = $1
-              @plural = $2
-            end
-            break if @charset and @nplurals
-          }
-          @nplurals = "1" unless @nplurals
-          @plural = "0" unless @plural
-        end
-      else
-        if @output_charset
-          begin
-            str = Iconv.iconv(@output_charset, @charset, str).join if @charset
-          rescue Iconv::Failure
-            if $DEBUG
-              $stderr.print "@charset = ", @charset, "\n"
-              $stderr.print "@output_charset = ", @output_charset, "\n"
-              $stderr.print "msgid = ", original_strings[i], "\n"
-              $stderr.print "msgstr = ", str, "\n"
-            end
-          end
-        end
-      end
-      self[original_strings[i]] = str
-    end
-    self
-  end
-
-  def load_from_file(filename)
-    @filename = filename
-    File.open(filename, 'rb'){|f| load_from_stream(f)}
-  end
-
-  def set_comment(msgid_or_sym, comment)
-    #Do nothing
-  end
-
-
-  attr_accessor :little_endian, :path, :last_modified
-  attr_reader :charset, :nplurals, :plural
-end

data/lib/ramaze/contrib/gettext/parser.rb

@@ -1,46 +0,0 @@
-# suppress load warning message
-verbose = $VERBOSE
-$VERBOSE = nil
-require 'gettext/rgettext'
-$VERBOSE = verbose
-
-module Ramaze::Tool::Gettext::Parser
-  module_function
-
-  TARGETS = Ramaze::Template::ENGINES.values.inject([]) do |exts, list|
-    list += exts
-  end
-
-  def target?(file)
-    TARGETS.include?(File.extname(file)[1..-1])
-  end
-
-  def parse(file, ary)
-    regex = Ramaze::Tool::Gettext.trait[:regex]
-    body = File.read(file)
-    body.gsub!(regex) do
-      msg = $1
-      unless msg.to_s.empty?
-        line_number = body[0..(body.index(msg))].split("\n").size
-        add_message(ary, msg, file, line_number)
-      end
-    end
-    return ary
-  end
-
-  def add_message(ary, msg, file, line_number)
-    loc = message_location(file, line_number)
-    if value = ary.assoc(msg)
-      value << loc
-    else
-      ary << [msg, loc]
-    end
-    return ary
-  end
-
-  def message_location(file, line_number)
-    file + ":line" + line_number.to_s
-  end
-end
-
-GetText::RGetText.add_parser(Ramaze::Tool::Gettext::Parser)

data/lib/ramaze/contrib/gettext/po.rb

@@ -1,109 +0,0 @@
-#! /usr/bin/env ruby
-=begin
-  rgettext.rb - Generate a .pot file.
-
-  Copyright (C) 2003-2006  Masao Mutoh
-  Copyright (C) 2001,2002  Yasushi Shoji, Masao Mutoh
-
-      Yasushi Shoji   <yashi at atmark-techno.com>
-      Masao Mutoh     <mutoh at highway.ne.jp>
-
-  You may redistribute it and/or modify it under the same
-  license terms as Ruby.
-=end
-
-
-module GetText
-
-  module RGetText #:nodoc:
-    extend GetText
-
-    MAX_LINE_LEN = 70 unless defined?(MAX_LINE_LEN)
-
-    module_function
-
-    def generate_pot_header # :nodoc:
-      time = Time.now.strftime("%Y-%m-%d %H:%M")
-      off = Time.now.utc_offset
-      sign = off <= 0 ? '-' : '+'
-      time += sprintf('%s%02d%02d', sign, *(off.abs / 60).divmod(60))
-
-      <<EOS
-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSION\\n"
-"POT-Creation-Date: #{time}\\n"
-"PO-Revision-Date: #{time}\\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
-"Language-Team: LANGUAGE <LL@li.org>\\n"
-"MIME-Version: 1.0\\n"
-"Content-Type: text/plain; charset=UTF-8\\n"
-"Content-Transfer-Encoding: 8bit\\n"
-EOS
-    end
-
-    def generate_pot(ary) # :nodoc:
-      str = ""
-      result = Array.new
-      ary.each do |key|
-	      msgid = key.shift.dup
-	      curr_pos = MAX_LINE_LEN
-	      key.each do |e|
-	        if curr_pos + e.size > MAX_LINE_LEN
-	          str << "\n#:"
-	          curr_pos = 3
-	        else
-	          curr_pos += (e.size + 1)
-	        end
-	        str << " " << e
-      	end
-      	msgid.gsub!(/"/, '\"')
-      	msgid.gsub!(/\r/, '')
-
-      	str << "\nmsgid \"" << msgid << "\"\n"
-    	  str << "msgstr \"\"\n"
-      end
-      str
-    end
-
-    def generate_translated_po(hash)
-      str = generate_pot_header
-      result = Array.new
-
-      hash.keys.sort.each do |msgid|
-        msgid = msgid.dup
-        msgstr = hash[msgid]
-
-        msgid.gsub!(/"/, '\"')
-      	msgid.gsub!(/\r/, '')
-
-      	if msgstr
-      	  msgstr.gsub!(/"/, '\"')
-        	msgstr.gsub!(/\r/, '')
-      	end
-
-      	str << "\nmsgid \"" << msgid << "\"\n"
-    	  str << "msgstr \"" << msgstr << "\"\n"
-      end
-
-      str
-    end
-
-    def generate(array)  # :nodoc:
-      str = ''
-      str << generate_pot_header
-      str << generate_pot(array)
-    end
-  end
-end
-
-if $0 == __FILE__
-  require 'yaml'
-  puts GetText::RGetText.generate_translated_po(YAML.load_file(ARGV[0]))
-end

data/lib/ramaze/contrib/gettext.rb

@@ -1,113 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'ramaze/tool/localize'
-require 'ramaze/contrib/gettext/mo'
-require 'ramaze/contrib/gettext/po'
-
-# Gettext helps transforming arbitrary text into localized forms using
-# a simple regular expression and substituting occurences with translations
-# stored in .mo files.
-#
-# == MO generation
-#
-# See http://www.gnu.org/software/gettext/ for a general overview over
-# Gettext.  Generally it's easier to use a graphical translator like Poedit.
-#
-# The default language is en, a .po template file will be saved by default
-# under `conf/locale_en.mo.pot`.  Individual languages are by default looked
-# up at `conf/locale_fi.mo` for localization.
-#
-# == Usage:
-#
-#   Ramaze::Dispatcher::Action::FILTER << Ramaze::Tool::Gettext
-
-module Ramaze
-  class Tool::Gettext < Tool::Localize
-
-    # Enable Localization
-    trait :enable => true
-
-    # Default language that is used if the browser don't suggests otherwise or
-    # the language requested is not available.
-    trait :default_language => 'en'
-
-    # languages supported
-    trait :languages => %w[ en ]
-
-    # YAML files the localizations are saved to and loaded from, %s is
-    # substituted by the values from trait[:languages]
-    trait :file => 'conf/locale_%s.mo'.freeze
-
-    # The pattern that is substituted with the translation of the current locale.
-    trait :regex => /\[\[(.*?)\]\]/
-
-    # Browsers may send different keys for the same language, this allows you to
-    # do some coercion between what you use as keys and what the browser sends.
-    trait :mapping => { 'en-us' => 'en', 'ja' => 'jp'}
-
-    # When this is set to false, it will not save newly collected translatable
-    # strings to disk.  Disable this for production use, as it slows the
-    # application down.
-    trait :collect => true
-
-
-    # Load given locales from disk and save it into the dictionary.
-
-    def self.load(*locales)
-      Log.debug "loading locales: #{locales.inspect}"
-
-      dict = trait[:dictionary] || {}
-
-      locales.each do |locale|
-        begin
-          dict[locale] = ::MOFile.open(trait[:file] % locale)
-        rescue Errno::ENOENT
-          Log.error "couldn't load #{trait[:file] % locale}"
-          dict[locale] = {}
-        end
-      end
-
-      trait[:dictionary] = dict
-    end
-
-    # Reloads given locales from the disk to refresh the dictionary.
-
-    def self.update
-      trait[:dictionary] = nil
-      dictionary.each do |locale, dict|
-        if dict.kind_of?(MOFile)
-          Log.debug("Reloading #{dict.filename}")
-          dict.update!
-        end
-      end
-    end
-
-    # Stores given locales from the dictionary to disk.
-
-    def self.store(*locales)
-      keys = []
-      dictionary.each do |locale, dict|
-        keys.concat dict.keys
-      end
-      keys.delete ""
-
-      data = ::GetText::RGetText.generate(keys.compact.uniq.sort.map {|x| [x] })
-      file = (trait[:file] % trait[:default_language]) + '.pot'
-      File.open(file, File::CREAT|File::TRUNC|File::WRONLY) do |fd|
-        fd.write data
-      end
-    rescue Errno::ENOENT => e
-      Log.error e
-    end
-  end
-end
-
-class Ramaze::Contrib::Gettext
-
-  # Called by Ramaze::Contrib.load, adds Gettext to Action::Filter
-
-  def self.startup
-    Ramaze::Dispatcher::Action::FILTER << Ramaze::Tool::Gettext
-  end
-end

data/lib/ramaze/contrib/gzip_filter.rb

@@ -1,56 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-# gzip_filter.rb
-#
-# Use this to compress "large" pages with gzip.  All major browsers support gzipped pages.
-# This filter brought to you by your friends in #ramaze: Pistos, manveru, rikur and Kashia.
-#
-# Usage, in start.rb:
-#
-#   require 'ramaze/contrib/gzip_filter'
-#   Ramaze::Dispatcher::Action::FILTER << Ramaze::Filter::Gzip
-
-require 'zlib'
-
-module Ramaze
-  module Filter
-    class Gzip
-
-      trait :enabled => true
-      trait :threshold => 32768 # bytes
-
-      class << self
-
-        include Ramaze::Trinity
-
-        # Enables being plugged into Dispatcher::Action::FILTER
-
-        def call( response, options = {} )
-          return response if not trait[ :enabled ]
-          return response if response.body.nil?
-          return response if response.body.respond_to?( :read )
-
-          accepts = request.env[ 'HTTP_ACCEPT_ENCODING' ]
-          return response if accepts.nil? || ( accepts !~ /(x-gzip|gzip)/ )
-
-          if response.content_type == 'text/html' && response.body.size > trait[ :threshold ]
-            output = StringIO.new
-            def output.close
-              # Zlib closes the file handle, so we want to circumvent this
-              rewind
-            end
-            gz = Zlib::GzipWriter.new( output )
-            gz.write( response.body )
-            gz.close
-
-            response.body = output.string
-            response.header[ 'Content-encoding' ] = 'gzip'
-          end
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/contrib/profiling.rb

@@ -1,36 +0,0 @@
-require "ruby-prof"
-
-module Ramaze
-  module Dispatcher
-    class ActionProfiler < Action
-      def self.process(path)
-        if RubyProf.running?
-          super
-        else
-          result = RubyProf.profile { super }
-          output = StringIO.new
-          printer = RubyProf::FlatPrinter.new(result)
-          options = {
-            :min_percent => Contrib::Profiling.trait[:min_percent],
-            :print_file => false
-          }
-          printer.print(output, options)
-          output.string.split("\n").each do |line|
-            Log.info(line)
-          end
-        end
-      end
-    end
-  end
-
-  module Contrib
-    class Profiling
-      trait :min_percent => 1
-
-      def self.startup
-        Dispatcher::FILTER.delete(Dispatcher::Action)
-        Dispatcher::FILTER << Dispatcher::ActionProfiler
-      end
-    end
-  end
-end

data/lib/ramaze/contrib/route.rb

@@ -1,22 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-module Ramaze
-  module Contrib
-    class Route
-      class << self
-        def startup
-          warn "Ramaze::Contrib::Route is being deprecated, use Ramaze::Route instead"
-        end
-
-        def [](key)
-          Ramaze::Route.trait[:routes][key]
-        end
-
-        def []=(key, value)
-          Ramaze::Route.trait[:routes][key] = value
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/contrib/sequel/fill.rb

@@ -1,12 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-module Sequel
-  class Model
-    class << self
-      def fill request_object = Ramaze::Request.current
-        create(request_object.params)
-      end
-    end
-  end
-end