olelo 0.9.0

data/plugins/utils/cache.rb

@@ -0,0 +1,53 @@
+description  'Caching support'
+dependencies 'utils/worker', 'utils/store'
+
+class Cache
+  def initialize(store)
+    @store = store
+    @disabled = false
+  end
+
+  def disable!
+    @disabled = true
+  end
+
+  # Block around cacheable return value identified by a <i>key</i>.
+  # The following options can be specified:
+  # * :disable Disable caching
+  # * :update  Force cache update
+  # * :defer   Deferred cache update
+  def cache(key, options = {}, &block)
+    if options[:disable] || !Config['production']
+      yield(self)
+    elsif @store.key?(key) && (!options[:update] || options[:defer])
+      Worker.defer { update(key, options, &block) } if options[:update]
+      @store[key]
+    else
+      update(key, options, &block)
+    end
+  end
+
+  def clear
+    @store.clear
+  end
+
+  private
+
+  def update(key, options = {}, &block)
+    content = block.call(self)
+    @store[key] = content if !@disabled
+    content
+  end
+
+  class<< self
+    def store
+      @store ||= Store.create(Config['cache_store'])
+    end
+
+    def cache(*args, &block)
+      Cache.new(store).cache(*args, &block)
+    end
+  end
+end
+
+Olelo::Cache = Cache

data/plugins/utils/image_magick.rb

@@ -0,0 +1,34 @@
+description  'ImageMagick'
+dependencies 'utils/shell', 'utils/semaphore'
+
+class ImageMagick < Shell
+  def self.semaphore
+    @semaphore ||= Semaphore.new
+  end
+
+  def initialize
+    if (`gm -version` rescue '').include?('GraphicsMagick')
+      @prefix = 'gm'
+    elsif !(`convert -version` rescue '').include?('ImageMagick')
+      raise 'GraphicsMagick or ImageMagick not found'
+    end
+  end
+
+  def label(text)
+    convert('-pointsize', 16, '-background', 'transparent', "label:#{text}", 'PNG:-').run rescue nil
+  end
+
+  def method_missing(name, *args, &block)
+    if %w(convert identify).include?(name.to_s)
+      super(@prefix, name, *args, &block)
+    else
+      super
+    end
+  end
+
+  def self.run(cmd, data)
+    semaphore.synchronize { super }
+  end
+end
+
+Olelo::ImageMagick = ImageMagick

data/plugins/utils/pygments.css

@@ -0,0 +1 @@
+.pygmentstable{background:transparent;width:100%}.pygmentstable td{background-color:#f8f8ff;padding:0.3em;vertical-align:top}.pygmentstable .linenos{width:0px;color:#555555}.pygmentstable .code{width:100%}.pygmentstable pre{padding:0;border:none}.pygments{background-color:#f8f8ff}.pygments .c{color:#999988;font-style:italic}.pygments .err{color:#a61717;background-color:#e3d2d2}.pygments .k{color:#000000;font-weight:bold}.pygments .o{color:#000000;font-weight:bold}.pygments .cm{color:#999988;font-style:italic}.pygments .cp{color:#999999;font-weight:bold}.pygments .c1{color:#999988;font-style:italic}.pygments .cs{color:#999999;font-weight:bold;font-style:italic}.pygments .gd{color:#000000;background-color:#ffdddd}.pygments .gd .x{color:#000000;background-color:#ffaaaa}.pygments .ge{color:#000000;font-style:italic}.pygments .gr{color:#aa0000}.pygments .gh{color:#999999}.pygments .gi{color:#000000;background-color:#ddffdd}.pygments .gi .x{color:#000000;background-color:#aaffaa}.pygments .go{color:#888888}.pygments .gp{color:#555555}.pygments .gs{font-weight:bold}.pygments .gu{color:#aaaaaa}.pygments .gt{color:#aa0000}.pygments .kc{color:#000000;font-weight:bold}.pygments .kd{color:#000000;font-weight:bold}.pygments .kp{color:#000000;font-weight:bold}.pygments .kr{color:#000000;font-weight:bold}.pygments .kt{color:#445588;font-weight:bold}.pygments .m{color:#009999}.pygments .s{color:#d14}.pygments .na{color:#008080}.pygments .nb{color:#0086B3}.pygments .nc{color:#445588;font-weight:bold}.pygments .no{color:#008080}.pygments .ni{color:#800080}.pygments .ne{color:#990000;font-weight:bold}.pygments .nf{color:#990000;font-weight:bold}.pygments .nn{color:#555555}.pygments .nt{color:#000080}.pygments .nv{color:#008080}.pygments .ow{color:#000000;font-weight:bold}.pygments .w{color:#bbbbbb}.pygments .mf{color:#009999}.pygments .mh{color:#009999}.pygments .mi{color:#009999}.pygments .mo{color:#009999}.pygments .sb{color:#d14}.pygments .sc{color:#d14}.pygments .sd{color:#d14}.pygments .s2{color:#d14}.pygments .se{color:#d14}.pygments .sh{color:#d14}.pygments .si{color:#d14}.pygments .sx{color:#d14}.pygments .sr{color:#009926}.pygments .s1{color:#d14}.pygments .ss{color:#990073}.pygments .bp{color:#999999}.pygments .vc{color:#008080}.pygments .vg{color:#008080}.pygments .vi{color:#008080}.pygments .il{color:#009999}

data/plugins/utils/pygments.rb

@@ -0,0 +1,50 @@
+description    'Pygments syntax highlighter'
+dependencies   'utils/assets', 'utils/shell'
+export_scripts 'pygments.css'
+
+module Pygments
+  FORMAT_OPTIONS = %w(-O encoding=utf8 -O linenos=table -O cssclass=pygments -f html -l)
+  @patterns = {}
+  @formats = []
+
+  include Util
+
+  def self.pre(text)
+    "<pre>#{escape_html(text.strip)}</pre>"
+  end
+
+  private_class_method :pre
+
+  def self.pygmentize(text, format)
+    return pre(text) if !@formats.include?(format)
+    options = FORMAT_OPTIONS + [format]
+    content = Shell.pygmentize(*options).run(text)
+    content.blank? ? pre(text) : content
+  end
+
+  def self.file_format(name)
+    pattern = @patterns.keys.find {|p| File.fnmatch(p, name)}
+    pattern && @patterns[pattern]
+  end
+
+  def self.setup
+    format = ''
+    output = `pygmentize -L lexer`
+    output.split("\n").each do |line|
+      if line =~ /^\* ([^:]+):$/
+        format = $1.split(', ')
+        @formats += format
+      elsif line =~ /^   [^(]+ \(filenames ([^)]+)/
+        $1.split(', ').each {|s| @patterns[s] = format.first }
+      end
+    end
+  rescue Errno::ENOENT => ex
+    Olelo.logger.warn 'pygmentize not found'
+  end
+end
+
+setup do
+  Pygments.setup
+end
+
+Olelo::Pygments = Pygments

data/plugins/utils/pygments.scss

@@ -0,0 +1,83 @@
+.pygmentstable {
+  background: transparent;
+  width: 100%;
+  td {
+    background-color: #f8f8ff;
+    padding: 0.3em;
+    vertical-align: top;
+  }
+  .linenos {
+    width: 0px;
+    color: #555555;
+  }
+  .code {
+    width: 100%;
+  }
+  pre {
+    padding: 0;
+    border: none;
+  }
+}
+
+.pygments {
+  background-color: #f8f8ff;
+  .c { color: #999988; font-style: italic } /* Comment */
+  .err { color: #a61717; background-color: #e3d2d2 } /* Error */
+  .k { color: #000000; font-weight: bold } /* Keyword */
+  .o { color: #000000; font-weight: bold } /* Operator */
+  .cm { color: #999988; font-style: italic } /* Comment.Multiline */
+  .cp { color: #999999; font-weight: bold } /* Comment.Preproc */
+  .c1 { color: #999988; font-style: italic } /* Comment.Single */
+  .cs { color: #999999; font-weight: bold; font-style: italic } /* Comment.Special */
+  .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
+  .gd .x { color: #000000; background-color: #ffaaaa } /* Generic.Deleted.Specific */
+  .ge { color: #000000; font-style: italic } /* Generic.Emph */
+  .gr { color: #aa0000 } /* Generic.Error */
+  .gh { color: #999999 } /* Generic.Heading */
+  .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
+  .gi .x { color: #000000; background-color: #aaffaa } /* Generic.Inserted.Specific */
+  .go { color: #888888 } /* Generic.Output */
+  .gp { color: #555555 } /* Generic.Prompt */
+  .gs { font-weight: bold } /* Generic.Strong */
+  .gu { color: #aaaaaa } /* Generic.Subheading */
+  .gt { color: #aa0000 } /* Generic.Traceback */
+  .kc { color: #000000; font-weight: bold } /* Keyword.Constant */
+  .kd { color: #000000; font-weight: bold } /* Keyword.Declaration */
+  .kp { color: #000000; font-weight: bold } /* Keyword.Pseudo */
+  .kr { color: #000000; font-weight: bold } /* Keyword.Reserved */
+  .kt { color: #445588; font-weight: bold } /* Keyword.Type */
+  .m { color: #009999 } /* Literal.Number */
+  .s { color: #d14 } /* Literal.String */
+  .na { color: #008080 } /* Name.Attribute */
+  .nb { color: #0086B3 } /* Name.Builtin */
+  .nc { color: #445588; font-weight: bold } /* Name.Class */
+  .no { color: #008080 } /* Name.Constant */
+  .ni { color: #800080 } /* Name.Entity */
+  .ne { color: #990000; font-weight: bold } /* Name.Exception */
+  .nf { color: #990000; font-weight: bold } /* Name.Function */
+  .nn { color: #555555 } /* Name.Namespace */
+  .nt { color: #000080 } /* Name.Tag */
+  .nv { color: #008080 } /* Name.Variable */
+  .ow { color: #000000; font-weight: bold } /* Operator.Word */
+  .w { color: #bbbbbb } /* Text.Whitespace */
+  .mf { color: #009999 } /* Literal.Number.Float */
+  .mh { color: #009999 } /* Literal.Number.Hex */
+  .mi { color: #009999 } /* Literal.Number.Integer */
+  .mo { color: #009999 } /* Literal.Number.Oct */
+  .sb { color: #d14 } /* Literal.String.Backtick */
+  .sc { color: #d14 } /* Literal.String.Char */
+  .sd { color: #d14 } /* Literal.String.Doc */
+  .s2 { color: #d14 } /* Literal.String.Double */
+  .se { color: #d14 } /* Literal.String.Escape */
+  .sh { color: #d14 } /* Literal.String.Heredoc */
+  .si { color: #d14 } /* Literal.String.Interpol */
+  .sx { color: #d14 } /* Literal.String.Other */
+  .sr { color: #009926 } /* Literal.String.Regex */
+  .s1 { color: #d14 } /* Literal.String.Single */
+  .ss { color: #990073 } /* Literal.String.Symbol */
+  .bp { color: #999999 } /* Name.Builtin.Pseudo */
+  .vc { color: #008080 } /* Name.Variable.Class */
+  .vg { color: #008080 } /* Name.Variable.Global */
+  .vi { color: #008080 } /* Name.Variable.Instance */
+  .il { color: #009999 } /* Literal.Number.Integer.Long */
+}

data/plugins/utils/semaphore.rb

@@ -0,0 +1,50 @@
+description 'Semaphore class'
+
+# Semaphore implementation based on {Mutex} and {ConditionVariable}.
+# A mutex allows a number of threads to enter a synchronized section in parallel.
+class Semaphore
+  # @param [Integer] counter Number of threads which can enter the section in parallel
+  def initialize(counter = 1)
+    @mutex = Mutex.new
+    @cond = ConditionVariable.new
+    @counter = counter
+  end
+
+  # Enter synchronized section
+  #
+  # Decrements the semaphore counter
+  #
+  # @api public
+  # @return [void]
+  def enter
+    @mutex.synchronize do
+      @cond.wait(@mutex) if (@counter -= 1) < 0
+    end
+  end
+
+  # Leave synchronized section
+  #
+  # Increments the semaphore counter
+  #
+  # @api public
+  # @return [void]
+  def leave
+    @mutex.synchronize do
+      @cond.signal if (@counter += 1) <= 0
+    end
+  end
+
+  # Synchronize block with this semaphore
+  #
+  # @api public
+  # @yield Block to synchronize
+  # @return [void]
+  def synchronize
+    enter
+    yield
+  ensure
+    leave
+  end
+end
+
+Olelo::Semaphore = Semaphore

data/plugins/utils/shell.rb

@@ -0,0 +1,45 @@
+description 'Shell utility'
+require 'shellwords'
+
+class Shell
+  def run(data = nil)
+    cmd = @cmd.join(' | ')
+    return `#{cmd}` if !data
+    Open3.popen3(cmd) do |stdin, stdout, stderr|
+      output = ''
+      len = 0
+      begin
+        while len < data.length
+          if found = IO.select([stdout], [stdin], nil, 0)
+            len += stdin.write_nonblock(data[len..-1]) if found[1].first
+            output << stdout.read_nonblock(1048576) if found[0].first && !stdout.eof?
+          end
+        end
+      rescue Errno::EPIPE
+      end
+      stdin.close
+      begin
+        output << stdout.read
+      rescue Errno::EAGAIN
+        retry
+      end
+      output
+    end
+  end
+
+  def cmd(*args)
+    yield(args) if block_given?
+    (@cmd ||= []) << args.compact.map(&:to_s).shelljoin
+    self
+  end
+
+  def method_missing(*args, &block)
+    cmd(*args, &block)
+  end
+
+  def self.method_missing(*args, &block)
+    new.send(*args, &block)
+  end
+end
+
+Olelo::Shell = Shell

data/plugins/utils/store.rb

@@ -0,0 +1,315 @@
+description 'Key/value store'
+require 'delegate'
+
+# Simple interface to key/value stores with Hash-like interface.
+#
+# Store supports a subset of the Moneta interface,
+# Moneta can be used as a drop-in replacement.
+# It is recommended to wrap the moneta store in a Store::Delegated
+# to only expose the Store interface.
+#
+# @abstract
+class Store
+  extend Factory
+
+  # Exists the value with key
+  #
+  # @param [String] key
+  # @return [Boolean]
+  # @api public
+  # @abstract
+  def key?(key)
+    raise NotImplementedError
+  end
+
+  # Read value with key. Return nil if the key doesn't exist
+  #
+  # @param [String] key
+  # @return [Object] value
+  # @api public
+  # @abstract
+  def [](key)
+    raise NotImplementedError
+  end
+
+  # Write value with key
+  #
+  # @param [String] key
+  # @param [Object] value
+  # @return value
+  # @api public
+  # @abstract
+  def []=(key, value)
+    raise NotImplementedError
+  end
+
+  # Delete the key from the store and return the current value
+  #
+  # @param [String] key
+  # @return [Object] current value
+  # @api public
+  # @abstract
+  def delete(key)
+    raise NotImplementedError
+  end
+
+  # Clear all keys in this store
+  #
+  # @return [void]
+  # @api public
+  # @abstract
+  def clear
+    raise NotImplementedError
+  end
+
+  protected
+
+  # Serialize value
+  #
+  # @param [Object] value Serializable object
+  # @return [String] serialized object
+  # @api private
+  def serialize(value)
+    Marshal.dump(value)
+  end
+
+  # Deserialize value
+  #
+  # @param [String] value Serialized object
+  # @return [Object] Deserialized object
+  # @api private
+  def deserialize(value)
+    value && Marshal.load(value)
+  end
+
+  # Create store instance
+  #
+  # @param [Config] Store configuration
+  # @return [Store]
+  # @api public
+  def self.create(config)
+    self[config[:type]].new(config[config[:type]])
+  end
+
+  # Delegated store
+  Delegated = DelegateClass(Store)
+
+  # Synchronized store
+  def self.Synchronized(type)
+    klass = Class.new
+    klass.class_eval %{
+      def initialize(config)
+        @store = #{type.name}.new(config)
+        @lock = Mutex.new
+      end
+
+      def method_missing(*args)
+        @lock.synchronize { @store.send(*args) }
+      end
+    }
+    klass
+  end
+
+  # Memory based store (uses hash)
+  class Memory < Delegated
+    def initialize(config)
+      super({})
+    end
+  end
+
+  register :memory, Memory
+
+  # Memcached client
+  class Memcached < Delegated
+    def initialize(config)
+      super(Store::Synchronized(Native).new(config))
+    rescue LoadError
+      super(Ruby.new(config))
+    end
+
+    # Uses the memcached gem
+    class Native < Store
+      include Util
+
+      def initialize(config)
+        require 'memcached'
+        @server = ::Memcached.new(config[:server], :prefix_key => (config[:prefix] rescue nil))
+      end
+
+      # @override
+      def key?(key)
+        @server.get(md5(key), false)
+        true
+      rescue ::Memcached::NotFound
+        false
+      end
+
+      # @override
+      def [](key)
+        @server.get(md5(key))
+      rescue ::Memcached::NotFound
+      end
+
+      # @override
+      def []=(key, value)
+        @server.set(md5(key), value)
+        value
+      end
+
+      # @override
+      def delete(key)
+        key = md5(key)
+        value = @server.get(key)
+        @server.delete(key)
+        value
+      rescue ::Memcached::NotFound
+      end
+
+      # @override
+      def clear
+        @server.flush
+      end
+    end
+
+    # Uses the dalli gem (memcache-client successor)
+    class Ruby < Store
+      include Util
+
+      def initialize(config)
+        require 'dalli'
+        @server = ::Dalli::Client.new(config[:server], :namespace => (config[:prefix] rescue nil))
+      end
+
+      # @override
+      def key?(key)
+        !@server.get(md5(key)).nil?
+      end
+
+      # @override
+      def [](key)
+        deserialize(@server.get(md5(key)))
+      end
+
+      # @override
+      def []=(key, value)
+        @server.set(md5(key), serialize(value))
+        value
+      end
+
+      # @override
+      def delete(key)
+        key = md5(key)
+        value = deserialize(@server.get(key))
+        @server.delete(key)
+        value
+      end
+
+      # @override
+      def clear
+        @server.flush_all
+      end
+    end
+  end
+
+  register :memcached, Memcached
+
+  # PStore based store
+  class PStore < Store
+    def initialize(config)
+      require 'pstore'
+      FileUtils.mkpath(::File.dirname(config[:file]))
+      @store = ::PStore.new(config[:file])
+    end
+
+    # @override
+    def key?(key)
+      @store.transaction(true) { @store.root?(key) }
+    end
+
+    # @override
+    def [](key)
+      @store.transaction(true) { @store[key] }
+    end
+
+    # @override
+    def []=(key, value)
+      @store.transaction { @store[key] = value }
+    end
+
+    # @override
+    def delete(key)
+      @store.transaction { @store.delete(key) }
+    end
+
+    # @override
+    def clear
+      @store.transaction do
+        @store.roots.each do |key|
+          @store.delete(key)
+        end
+      end
+    end
+  end
+
+  register :pstore, Synchronized(PStore)
+
+  # File based store
+  class File < Store
+    def initialize(config)
+      @root = config[:root]
+    end
+
+    # @override
+    def key?(key)
+      ::File.exist?(store_path(key))
+    end
+
+    # @override
+    def [](key)
+      deserialize(::File.read(store_path(key)))
+    rescue Errno::ENOENT
+    end
+
+    # @override
+    def []=(key, value)
+      temp_file = ::File.join(@root, "value-#{$$}-#{Thread.current.object_id}")
+      FileUtils.mkpath(@root)
+      ::File.open(temp_file, 'wb') {|file| file.write(serialize(value)) }
+      path = store_path(key)
+      FileUtils.mkpath(::File.dirname(path))
+      ::File.unlink(path) if ::File.exist?(path)
+      FileUtils.mv(temp_file, path)
+    rescue
+      ::File.unlink(temp_file) rescue nil
+    ensure
+      value
+    end
+
+    # @override
+    def delete(key)
+      value = self[key]
+      ::File.unlink(store_path(key))
+      value
+    rescue Errno::ENOENT
+    end
+
+    # @override
+    def clear
+      temp_dir = "#{@root}-#{$$}-#{Thread.current.object_id}"
+      FileUtils.mv(@root, temp_dir)
+      FileUtils.rm_rf(temp_dir)
+    rescue Errno::ENOENT
+    end
+
+    protected
+
+    def store_path(key)
+      key = Util.md5(key)
+      ::File.join(@root, key[0..1], key[2..-1])
+    end
+  end
+
+  register :file, File
+end
+
+Olelo::Store = Store