runo 0.1.0

data/lib/_storage/_storage.rb

@@ -0,0 +1,213 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+class Runo::Storage
+
+  def self.instance(sd)
+    if folder = sd[:folder]
+      if folder != sd[:parent]
+        Temp.new sd
+      else
+        klass = Runo['storage']['default'].capitalize
+        self.const_get(klass).new sd
+      end
+    else
+      Temp.new sd
+    end
+  end
+
+  def self.available?
+    false
+  end
+
+  attr_reader :sd
+
+  def initialize(sd)
+    @sd = sd
+  end
+
+  def persistent?
+    true
+  end
+
+  def order
+    @sd[:order]
+  end
+
+  def select(conds = {})
+    _cast conds
+    item_ids = _select(conds)
+    item_ids = _sort(item_ids, conds)
+    item_ids = _page(item_ids, conds)
+    ((conds[:order] || order) =~ /^-/) ? item_ids.reverse : item_ids
+  end
+
+  def build(v)
+    self
+  end
+
+  def clear
+    self
+  end
+
+  def store(id, v)
+    id
+  end
+
+  def delete(id)
+    id
+  end
+
+  def navi(conds)
+    conds[:p] = '1' unless conds[:p] || conds[:id] || (@sd[:p_size].to_i < 1)
+    navi = {}
+    (([:id, :p, :d] & conds.keys) | conds.keys).each {|cid|
+      next unless conds[cid] && respond_to?("_sibs_#{cid}", true)
+      sibs = __send__("_sibs_#{cid}", conds)
+
+      c = (c.is_a?(::Array) && c.size < 2) ? conds[cid].first : conds[cid]
+      if i = sibs.index(c)
+        if !navi[:prev] && i > 0
+          navi[:prev] = conds.merge(cid => sibs[i - 1])
+          if ![:id, :p].include? cid
+            navi[:prev][:id] = _select_without(:id, navi[:prev]).last if conds[:id]
+            navi[:prev][:p] = _p_count(navi[:prev]).to_s if conds[:p]
+          end
+        end
+        if !navi[:next] && i < (sibs.size - 1)
+          navi[:next] = conds.merge(cid => sibs[i + 1])
+          if ![:id, :p].include? cid
+            navi[:next][:id] = _select_without(:id, navi[:next]).first if conds[:id]
+            navi[:next][:p] = '1' if conds[:p]
+          end
+        end
+      end
+      navi[:sibs] ||= {cid => sibs} if navi[:prev] || navi[:next]
+
+      break if navi[:prev] && navi[:next]
+    }
+
+    navi
+  end
+
+  def last(cid, conds)
+    __send__("_sibs_#{cid}", conds).last
+  end
+
+  private
+
+  def _cast(conds)
+    ([:d, :id, :p] & conds.keys).each {|cid|
+      case cid
+        when :d
+          conds[:d] = conds[:d].to_s
+          conds[:d] = last(:d, conds) if conds[:d] =~ /9999(99)?(99)?/
+          conds[:d] = nil unless conds[:d] =~ Runo::REX::COND_D
+        when :id
+          conds[:id] = Array(conds[:id]).collect {|id|
+            case id
+              when '99999999_9999', 'last'
+                last(:id, conds)
+              when /\A#{Runo::REX::ID_SHORT}\z/
+                "00000000_#{id}"
+              when Runo::REX::ID, Runo::REX::ID_NEW
+                id
+            end
+          }.uniq.compact
+        when :p
+          conds[:p] = conds[:p].to_s
+          conds[:p] = last(:p, conds) if conds[:p] == 'last'
+          conds[:p] = nil unless conds[:p] =~ /^\d+$/
+      end
+    }
+    conds
+  end
+
+  def _select(conds)
+    if conds[:id]
+      _select_by_id(conds) | (@sd.instance_variable_get(:@item_object).keys & conds[:id].to_a)
+    elsif cid = (conds.keys - [:order, :p]).first
+      m = "_select_by_#{cid}"
+      respond_to?(m, true) ? __send__(m, conds) : []
+    else
+      _select_all(conds) | @sd.instance_variable_get(:@item_object).keys
+    end
+  end
+
+  def _sort(item_ids, conds)
+    item_ids.sort
+  end
+
+  def _page(item_ids, conds)
+    size = @sd[:p_size].to_i
+    return item_ids if size < 1
+
+    page = conds[:p].to_i
+    page = 1 if page < 1
+    item_ids[(page - 1) * size, size].to_a
+  end
+
+  def _sibs_id(conds)
+    _select_without(:id, conds)
+  end
+
+  def _sibs_p(conds)
+    p_count = _p_count(conds)
+    p_count ? (1..p_count).collect {|i| i.to_s } : []
+  end
+
+  def _sibs_d(conds)
+    rex_d = /^\d{#{conds[:d].length}}/
+    _select_without(:id, :p, :d, conds).collect {|id| id[rex_d] }.uniq.compact
+  end
+
+  def _select_without(*cids)
+    conds = cids.pop.dup
+    cids.each {|cid| conds.delete cid }
+    _sort(_select(conds), conds)
+  end
+
+  def _p_count(conds)
+    (_select_without(:id, :p, conds).size / @sd[:p_size].to_f).ceil unless @sd[:p_size].to_f == 0
+  end
+
+  def cast_ids(ids)
+    ids.to_a.collect {|i|
+      id = (i =~ /^[a-z]/) ? "00000000_#{i}" : i
+      id if id =~ Runo::REX::ID
+    }.compact
+  end
+
+  def new_id(v = {})
+    return "00000000_#{v['_id']}" if v.is_a?(::Hash) && v['_id'] =~ /\A#{Runo::REX::ID_SHORT}\z/
+
+    if v.is_a?(::Hash) && v['_timestamp'] && v['_timestamp']['published'].is_a?(::Time)
+      d = v['_timestamp']['published'].strftime '%Y%m%d'
+    else
+      d = Time.now.strftime '%Y%m%d'
+    end
+    if max_in_d = _select(:d => d).sort.last
+      max_in_d.succ
+    else
+      d + '_0001'
+    end
+  end
+
+  def new_id?(id, v)
+    if id == :new_id
+      true
+    elsif !v.is_a?(::Hash)
+      false
+    elsif id =~ /_#{Runo::REX::ID_SHORT}\z/
+      v['_id'] =~ /\A#{Runo::REX::ID_SHORT}\z/ &&
+      id != new_id(v)
+    else
+      v['_timestamp'] &&
+      v['_timestamp']['published'].is_a?(::Time) &&
+      id !~ /\A#{v['_timestamp']['published'].strftime('%Y%m%d')}/
+    end
+  end
+
+end

data/lib/_storage/file.rb

@@ -0,0 +1,200 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+require 'rubygems'
+require 'yaml'
+require 'ya2yaml'
+require 'fileutils'
+
+class Runo::Storage::File < Runo::Storage
+
+  def self.traverse(dir = '/', root = Runo['storage']['File']['data_dir'], &block)
+    ::Dir.glob(::File.join root, dir, '*').sort.collect {|file|
+      ftype     = ::File.ftype file
+      base_name = ::File.basename file
+      id, ext    = base_name.split('.', 2)
+      id = "main-#{id}" if id =~ Runo::REX::ID
+      full_name = ::File.join(dir, id).gsub(::File::SEPARATOR, '-')
+
+      if ftype == 'file' && id.sub(/^([^\d\-]+-)+/, '') =~ Runo::REX::ID
+        val = nil
+        ::File.open(file, 'r') {|f|
+          f.flock ::File::LOCK_SH
+          f.binmode
+          val = f.read
+          f.flock ::File::LOCK_UN
+        }
+        block.call(
+          :dir       => dir,
+          :base_name => base_name,
+          :full_name => full_name,
+          :ext       => ext,
+          :val       => (ext == 'yaml' ? YAML.load(val) : val)
+        )
+      elsif ftype == 'directory' && base_name !~ /\A#{Runo::REX::DIR_STATIC}\z/
+        self.traverse(::File.join(dir, base_name), root, &block)
+      end
+    }.compact.flatten
+  end
+
+  def self.load_skel
+    self.traverse('/', Runo['skin_dir']) {|entry|
+      dir = ::File.join(Runo['storage']['File']['data_dir'], entry[:dir])
+      unless ::File.exists? ::File.join(dir, entry[:base_name])
+        ::FileUtils.mkpath(dir) unless ::File.directory? dir
+        ::FileUtils.cp(
+          ::File.join(Runo['skin_dir'], entry[:dir], entry[:base_name]),
+          ::File.join(dir, entry[:base_name]),
+          {:preserve => true}
+        )
+      end
+    }
+  end
+
+  def self.available?
+    Runo['storage']['File'] && Runo['storage']['File']['data_dir']
+  end
+
+  def initialize(sd)
+    super
+    unless @@loaded ||= false
+      entries = ::Dir.glob ::File.join(Runo['storage']['File']['data_dir'], '*')
+      self.class.load_skel if entries.empty?
+      @@loaded = true
+    end
+    @dir = ::File.join(Runo['storage']['File']['data_dir'], @sd[:folder][:dir])
+    ::FileUtils.mkpath(@dir) unless ::File.directory? @dir
+  end
+
+  def val(id = nil)
+    if id
+      load id
+    else
+      # this could be HUGE.
+      _select_all({}).inject({}) {|v, id|
+        v[id] = load id
+        v
+      }
+    end
+  end
+
+  def build(v)
+    clear
+    v.each {|id, v| store(id, v) }
+    self
+  end
+
+  def clear
+    glob.each {|file| ::File.unlink ::File.join(@dir, file) }
+    self
+  end
+
+  def store(id, v, ext = nil)
+    save(id, v, ext)
+  end
+
+  def delete(id)
+    remove_file(id) && id
+  end
+
+  def move(old_id, new_id)
+    rename_file(old_id, new_id) && new_id
+  end
+
+  private
+
+  def _select_by_id(conds)
+    glob(conds[:id].to_a).collect {|f| f[/\d.*/][Runo::REX::ID] }.compact
+  end
+
+  def _select_by_d(conds)
+    glob(conds[:d].to_s).collect {|f| f[/\.yaml$/] && f[/\d.*/][Runo::REX::ID] }.compact
+  end
+
+  def _select_all(conds)
+    glob.collect {|f| f[/\.yaml$/] && f[/\d.*/][Runo::REX::ID] }.compact
+  end
+
+  def glob(id = :all)
+    glob_pattern = "#{file_prefix}#{pattern_for id}.[a-z]*"
+    ::Dir.chdir(@dir) { ::Dir.glob glob_pattern }
+  end
+
+  def file_prefix
+    (@sd[:name] == 'main') ? '' : @sd[:name].sub(/^main-/, '') + '-'
+  end
+
+  def pattern_for(id)
+    if id.is_a? Array
+      "{#{id.join ','}}"
+    elsif id == :all
+      '[0-9]*_*'
+    elsif id =~ /\A\d{4,8}\z/
+      "#{id}*"
+    end
+  end
+
+  def load(id)
+    v = nil
+    file = glob(id.to_a).sort.first
+    ::File.open(::File.join(@dir, file), 'r') {|f|
+      f.flock ::File::LOCK_SH
+      f.binmode
+      v = f.read
+      f.flock ::File::LOCK_UN
+    } if file
+    (file[/\.yaml$/] ? YAML.load(v) : v) if v
+  end
+
+  def save(id, v, ext)
+    if new_id?(id, v)
+      old_id = id
+      id = new_id v
+    end
+
+    if ext
+      val = v
+      ext = 'y' if ext == 'yaml'
+      remove_file id
+    else
+      val = v.ya2yaml(:syck_compatible => true)
+      ext = 'yaml'
+    end
+
+    file = "#{file_prefix}#{id}.#{ext}"
+    if old_id && f = ::File.open(::File.join(@dir, file), 'a')
+      return if f.pos != 0 # duplicate id
+      move(old_id, id) unless old_id == :new_id
+    end
+    ::File.open(::File.join(@dir, file), 'a') {|f|
+      f.flock ::File::LOCK_EX
+      f.binmode
+      f.seek 0
+      f.truncate 0
+      f << val
+      f.flock ::File::LOCK_UN
+      f.chmod 0664
+    } && id
+  end
+
+  def remove_file(id)
+    glob_pattern = "#{file_prefix}#{pattern_for id.to_a}[.-]*"
+    files = ::Dir.chdir(@dir) { ::Dir.glob glob_pattern } # may include child files
+    files.each {|file|
+      ::File.unlink ::File.join(@dir, file)
+    }
+  end
+
+  def rename_file(old_id, new_id)
+    glob_pattern = "#{file_prefix}#{pattern_for old_id.to_a}*"
+    files = ::Dir.chdir(@dir) { ::Dir.glob glob_pattern } # may include child files
+    rex = /^\A#{file_prefix}#{old_id}/
+    files.each {|file|
+      to_file = file.sub(rex, "#{file_prefix}#{new_id}")
+      ::File.rename(::File.join(@dir, file), ::File.join(@dir, to_file))
+    }
+  end
+
+end

data/lib/_storage/sequel.rb

@@ -0,0 +1,174 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009-2010 Akira FUNAI
+
+require 'rubygems'
+require 'sequel'
+require 'yaml'
+require 'ya2yaml'
+
+class Runo::Storage::Sequel < Runo::Storage
+
+  def self.db
+    if Runo['storage']['Sequel'] && Runo['storage']['Sequel']['uri']
+      @db ||= ::Sequel.connect Runo['storage']['Sequel']['uri']
+      self.load_skel unless @db.table_exists? :runo_main
+    end
+    @db
+  end
+
+  def self.load_skel
+    @db.create_table(:runo_main) {
+      String :full_name
+      String :ext
+      String :owner
+      String :body
+      Blob   :binary_body
+      primary_key :full_name
+    } unless @db.table_exists? :runo_main
+    Runo::Storage::File.traverse('/', Runo['skin_dir']) {|entry|
+      @db[:runo_main].insert(
+        :full_name   => entry[:full_name],
+        :ext         => entry[:ext],
+        :owner       => entry[:val]['_owner'],
+        :body        => entry[:val].ya2yaml(:syck_compatible => true),
+        :binary_body => (entry[:ext] == 'yaml') ? nil : entry[:val].to_sequel_blob
+      ) unless @db[:runo_main][:full_name => entry[:full_name]]
+    }
+  end
+
+  def self.available?
+    self.db
+  end
+
+  def initialize(sd)
+    super
+    @dataset = Runo::Storage::Sequel.db[:runo_main]
+    @dirname = @sd[:full_name]
+  end
+
+  def val(id = nil)
+    if id
+      load id
+    else
+      # this could be HUGE.
+      _select_all({}).inject({}) {|v, id|
+        v[id] = load id
+        v
+      }
+    end
+  end
+
+  def build(v)
+    clear
+    v.each {|id, v| store(id, v) } if v
+    self
+  end
+
+  def clear
+    @dataset.grep(:full_name, _full_name('%')).delete
+    self
+  end
+
+  def store(id, v, ext = nil)
+    save(id, v, ext)
+  end
+
+  def delete(id)
+    @dataset.filter(_conds id).delete &&
+    @dataset.grep(:full_name, _full_name("#{id}-%")).and(~:ext => 'yaml').delete &&
+    id
+  end
+
+  def move(old_id, new_id)
+    rename(old_id, new_id) && new_id
+  end
+
+  private
+
+  def _select_by_id(conds)
+    @dataset.filter(_conds conds[:id]).collect {|v| _id v[:full_name] }
+  end
+
+  def _select_by_d(conds)
+    @dataset.
+      grep(:full_name, _full_name("#{conds[:d]}%")).
+      and(:ext => 'yaml').
+      collect {|v| _id v[:full_name] }
+  end
+
+  def _select_all(conds)
+    @dataset.
+      grep(:full_name, _full_name('%')).
+      and(:ext => 'yaml').
+      collect {|v| _id v[:full_name] }
+  end
+
+# TODO: overrride _sort() & _page() (they can be done in _select_*)
+
+  def _conds(id)
+    (id == :all) ? {} : {:full_name => _full_name(id)}
+  end
+
+  def _full_name(id)
+    "#{@dirname}-#{id}"
+  end
+
+  def _id(full_name)
+    full_name.sub("#{@dirname}-", '')
+  end
+
+  def load(id)
+# TODO: cache in _select_*
+    v = @dataset[:full_name => _full_name(id)]
+    (v[:ext] == 'yaml' ? YAML.load(v[:body]) : v[:binary_body]) if v
+  end
+
+  def save(id, v, ext)
+    Runo::Storage::Sequel.db.transaction {
+      if new_id?(id, v)
+        old_id = id
+        id = new_id v
+      end
+
+      full_name = _full_name id
+
+      if ext
+        ext = 'y' if ext == 'yaml'
+        val = {
+          :full_name   => full_name,
+          :ext         => ext,
+          :binary_body => v.to_sequel_blob,
+        }
+      else
+        val = {
+          :full_name => full_name,
+          :ext       => 'yaml',
+          :owner     => v['_owner'],
+          :body      => v.ya2yaml(:syck_compatible => true),
+        }
+      end
+
+      if old_id
+        return if @dataset[:full_name => full_name] # duplicate id
+        move(old_id, id) unless old_id == :new_id
+      end
+      if @dataset[:full_name => full_name]
+        @dataset[:full_name => full_name] = val
+      else
+        @dataset.insert val
+      end
+      id
+    }
+  end
+
+  def rename(old_id, new_id)
+    @dataset.grep(:full_name, _full_name("#{old_id}%")).each {|v|
+      @dataset[:full_name => v[:full_name]] = v.merge(
+        :full_name => v[:full_name].sub(_full_name(old_id), _full_name(new_id))
+      )
+    }
+  end
+
+end