runo 0.2.1 → 0.2.2

data/lib/_path.rb

@@ -1,86 +0,0 @@
-# encoding: UTF-8
-
-# Author::    Akira FUNAI
-# Copyright:: Copyright (c) 2009 Akira FUNAI
-
-module Runo::Path
-
-  module_function
-
-  def tid_of(path)
-    path[Runo::REX::TID]
-  end
-
-  def steps_of(path)
-    _dirname(path).gsub(Runo::REX::PATH_ID, '').split('/').select {|step_or_cond|
-      step_or_cond != '' &&
-      step_or_cond !~ Regexp.union(Runo::REX::COND, Runo::REX::COND_D, Runo::REX::TID)
-    }
-  end
-
-  def base_of(path)
-    base = Runo::Set::Static::Folder.root.item steps_of(path)
-    if base.is_a? Runo::Set::Static::Folder
-      base.item('main') || base.find {|item| item.is_a? Runo::Set::Dynamic } || base
-    else
-      base
-    end
-  end
-
-  def conds_of(path)
-    dir   = _dirname path.gsub(Runo::REX::PATH_ID, '')
-    conds = $& ? {:id => sprintf('%.8d_%.4d', $1, $2)} : {}
-
-    dir.split('/').inject(conds) {|conds, step_or_cond|
-      if step_or_cond =~ Runo::REX::COND
-        conds[$1.intern] = $2
-      elsif step_or_cond =~ Runo::REX::COND_D
-        conds[:d] = $&
-      end
-      conds
-    }
-  end
-
-  def action_of(path)
-    a = _basename(path).to_s[/^[a-z]+/]
-    a.intern if a && a != 'index'
-  end
-
-  def sub_action_of(path)
-    a = _basename(path).to_s[/_([a-z]+)/, 1]
-    a.intern if a
-  end
-
-  def path_of(conds)
-    conds = {} unless conds.is_a? ::Hash
-    (
-      (conds.keys - [:order, :p, :id]) |
-      ([:order, :p, :id] & conds.keys)
-    ).collect {|cid|
-      if cid == :id
-        ids = Array(conds[:id]).collect {|id|
-          (id =~ /_(#{Runo::REX::ID_SHORT})$/) ? $1 : (id if Runo::REX::ID)
-        }.compact
-        if (ids.size == 1) && (ids.first =~ Runo::REX::ID)
-          '%s/%d/' % [$1, $2.to_i]
-        elsif ids.size > 0
-          "id=#{ids.join ','}/"
-        end
-      elsif cid == :d
-        conds[:id] ? '' : "#{conds[:d]}/"
-      else
-        "#{cid}=#{Array(conds[cid]).join ','}/"
-      end
-    }.join.sub(%r{/p=1/$}, '/')
-  end
-
-  def _dirname(path) # returns '/foo/bar/' for '/foo/bar/'
-    path[%r{^.*/}] || ''
-  end
-
-  def _basename(path) # returns nil for '/foo/bar/'
-    path[%r{[^/]+$}]
-  end
-
-end
-

data/lib/_storage/_storage.rb

@@ -1,215 +0,0 @@
-# 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].first if conds[:d].is_a? ::Array
-          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].first if conds[:p].is_a? ::Array
-          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 & Array(conds[:id]))
-    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
-    Array item_ids[(page - 1) * size, size]
-  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)
-    Array(ids).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

@@ -1,201 +0,0 @@
-# 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(Array(conds[:id])).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(Array(id)).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')
-      f.seek(0, IO::SEEK_END)
-      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 Array(id)}[.-]*"
-    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 Array(old_id)}*"
-    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