simple_file_store 0.0.4

data/.gitignore

@@ -0,0 +1,10 @@
+announcement.txt
+coverage
+doc
+pkg
+.raketasks
+.rvmrc
+README.html
+README.pdf
+*.lock
+*.sw?

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/History.txt

@@ -0,0 +1,23 @@
+== 0.0.4 / 2011-12-17
+* Completely rehauled the gem infrastructure:
+  * Dropped Bones in favor of Bundler for gem management;
+  * Added Bundler for managing development/test dependencies;
+  * Completely rewritten the rake tasks, to make them simpler and more useful;
+* Ensured the library is 1.9.2 compatible;
+* Changed the base class from SimpleFileStore to SimpleFileStore::Base, which
+  allows us to use the module as a global namespace for project related code;
+* Simplified tests;
+* Various other cleanup.
+
+== 0.0.3 / 2011-07-02
+* Dropped using the BlankSlate gem in favor of a minimal, local lib;
+* Introduced a features() class methods for easily adding store features.
+
+== 0.0.2 / 2011-03-07
+* Added CachingFileStore, cleaned up and simplified all existing Stores; 
+* Added automated/unit testing for everything.
+
+== 0.0.1 / 2011-02-10
+
+* 1 major enhancement:
+  * Birthday!

data/README.asciidoc

@@ -0,0 +1,86 @@
+Simple File Store
+=================
+Alexandru Ungur <alexaandru@gmail.com>
+:icons:
+:toc:
+:website: http://github.com/alexaandru/simple_file_store
+
+Description
+-----------
+
+A micro-framework for storing and loading files to/from the filesystem.
+
+Features/Problems
+-----------------
+
+* Simplicity! which makes it trivial to extend (see SecureFileStore or ScalableFileStore)
+* Handles the details of file_name composition/decomposition in a DSLish way
+* Handles file content storing/loading to/from file
+* TODO: implement validations (file name components should not be blank, etc.)
+
+Synopsis
+--------
+
+.Example Usage
+--------------------------------------------------------------------
+class MyUpload < SimpleFileStore::Base
+
+  features :scalable, :encrypted
+
+  file_name_tokens :user_id, :category_id, :timestamp
+
+end
+
+params = {:content => "IO or string", :user_id => 1, :category_id => 17}
+m = MyUpload.new(params) # file content is saved to fstore/my_uploads/29/b7/f2/25/1-17-1324284042.txt
+m.file_name # => "1-17-1324284042.txt"
+
+to load, simply call:
+m = MyUpload.new(:file_name => "1-17-1324284042.txt")
+m.content # => "file content"
+--------------------------------------------------------------------
+
+Requirements
+------------
+
+* ActiveSupport (for Inflections);
+* Encryption Store needs an encryption library;
+
+Install
+-------
+
+----------------------------------
+gem install simple_file_store
+
+or add this to Gemfile:
+
+gem 'simple_file_store'
+----------------------------------
+
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2011 Alexandru Ungur
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// vim: set syntax=asciidoc:

data/Rakefile

@@ -0,0 +1,69 @@
+require 'bundler/gem_tasks'
+
+def root
+  Pathname.new(File.dirname(__FILE__))
+end
+
+def test_files
+  Dir[root.join('test', '*_test.rb')].map{|x| x.inspect}.join(' ')
+end
+
+namespace :test do
+  desc "Check code quality"
+  task :quality do
+    %w|roodi flog flay|.each do |e|
+      puts "=== #{e.capitalize} #{'=' * 80}"
+      sh "#{e} lib/**/*.rb"
+      puts
+    end
+  end
+
+  namespace :unit do
+    test_files.split(' ').each do |tt|
+      name = File.basename(tt, '.rb"')[0..-6]
+      desc "Run #{name} unit test"
+      task name do
+        sh "ruby #{root.join('test', 'loader.rb')} #{tt}"
+      end
+    end
+  end
+
+  desc "List the tests spec"
+  task :spec do
+    require 'test/unit'
+    test_files.delete('"').split(' ').sort.each do |file|
+      out = Test::Unit::TestCase.new(nil).capture_io { load file }.join
+      klass = File.basename(file, '.rb').classify
+
+      unless Object.const_defined?(klass.to_s)
+        puts "Skipping #{klass} because it doesn't map to a Class"
+        next
+      end
+
+      klass = klass.constantize
+      name = klass.name.gsub('Test', '')
+      puts name, '-' * name.size
+      test_methods = klass.instance_methods.grep(/^test/).map {|s| s.to_s.gsub(/^test: /, '')}.sort
+      test_methods.each { |m| puts "    " << m }
+      puts out.nil? || out.empty? ? nil : [out, nil]
+    end
+
+    exit 1 # to skip running tests suite
+  end
+end
+
+desc "Run all tests"
+task :test do
+  sh "ruby #{root.join('test', 'loader.rb')} #{test_files}"
+end
+
+namespace :test do
+  task :prepare_coverage do
+    ENV['COVERAGE'] = '1'
+  end
+
+  desc "Run tests coverage report"
+  task :coverage => [:prepare_coverage, :test]
+end
+
+task :default => :test

data/lib/mini_blank_slate.rb

@@ -0,0 +1,13 @@
+#
+# Credit goes to Jim Weirich for the BlankSlate technique,
+# adapted from his example at: http://onestepback.org/index.cgi/Tech/Ruby/BlankSlate.rdoc
+#
+class MiniBlankSlate
+
+  BlankMethods = /^__|^instance_|object_id$|class$|inspect$|respond_to\?$/.freeze
+
+  instance_methods.each do |m|
+    m =~ BlankMethods or undef_method(m)
+  end
+
+end

data/lib/simple_file_store.rb

@@ -0,0 +1,7 @@
+# Load BlankSlate
+require File.join(File.dirname(__FILE__), 'mini_blank_slate')
+
+# Load all SimpleFileStore libs
+Dir[File.join(File.dirname(__FILE__), 'simple_file_store', '*.rb')].each do |lib|
+  require lib
+end

data/lib/simple_file_store/caching_file_store.rb

@@ -0,0 +1,30 @@
+#
+# This adds a transparent file caching layer.
+#
+# Behavior: when neither file_name nor content are
+# provided, the generate_content() method is called
+# and the output loaded into file (and thus, the
+# file autosaved).
+#
+# Requirements: a generate_content() method.
+#
+# TODO: Implement an easy way to select the caching method
+# vs. use the current convention.
+# TODO: imlpement some hooks in base class, so that redefining
+# methods should not be necessary.
+#
+
+module CachingFileStore
+
+  protected
+
+  def load_or_store!
+    self.content = generate_content unless File.exist?(path)
+    open {|f| content.nil? ? pull(f) : push(f)}
+  end
+
+  def generate_content
+    raise NoMethodError, "You must implement the method yourself"
+  end
+
+end

data/lib/simple_file_store/scalable_file_store.rb

@@ -0,0 +1,29 @@
+#
+# This adds transparent file path scalability (by using
+# 4 depth trees hierarchy based on the file name). 
+#
+# This allows one to have as many files (as the underlying
+# filesystem allows) without every having to worry about
+# too many files under one folder.
+#
+
+require 'digest'
+module ScalableFileStore
+
+  def path
+    scale_path
+    root.join(self.class.name.tableize, @inter_tree, file_name)
+  end
+
+  private
+
+  def scale_path
+    raise ArgumentError, "Cowardly refusing to scale empty filename" if file_name.nil?
+
+    @inter_tree ||= begin
+      h = Digest::SHA256.hexdigest(file_name)
+      File.join(*[h[0,2],h[2,2],h[4,2],h[6,2]].reject{|z| z.nil? || z.empty?})
+    end
+  end
+
+end

data/lib/simple_file_store/secure_file_store.rb

@@ -0,0 +1,21 @@
+#
+# This adds transparent file content encryption/decryption
+# on top of SimpleFileStore
+#
+# TODO: Implement an easy way to select the encryptor/decryptor.
+#
+
+module SecureFileStore
+
+  private
+
+  def pull(f)
+    raw = f.read
+    self.content = App.decrypt(raw) || raw
+  end
+
+  def push(f)
+    f.write(App.encrypt(content))
+  end
+
+end

data/lib/simple_file_store/simple_file_store.rb

@@ -0,0 +1,158 @@
+#
+# SimpleFileStore implements a micro-framework for mundane file
+# operations such as storing or loading a file.
+#
+# At it's core it does one of two things:
+#
+#  * auto loads a file (if :file_name => <file_name> is passed)
+#  * auto stores a file (if :content => <content> is passed)
+#
+# To put it simple, if you give it some content, it will store it
+# and give you a file name. If you give it a file name it will load
+# the file content.
+#
+# This class is not intended to perform any other work, than just
+# this basic one. Any extra functionality will be layered on top
+# of it (see for example ScalableFileStore or SecureFileStore).
+#
+# It also offers a very handy way of composing/deomposing file names:
+# you simply indicate the tokens that should compose the filename,
+# and it will auto construct the file name (on content auto saving),
+# respectiely it will decompose the file name into tokens when auto
+# loading date from file.
+#
+
+#
+# TODO: implement further validations (file name components should
+# not be blank, etc.);
+# TODO: make FileStoreRoot and Separator configurable.
+#
+require 'pathname'
+require 'fileutils'
+require 'rubygems'
+require 'active_support/inflector'
+
+module SimpleFileStore
+
+  class Base < MiniBlankSlate
+
+    KnownFeatures = Dir.glob(File.join(File.dirname(__FILE__), '*_file_store.rb')).map do |f|
+      f =~ %r|.*/([a-z]+)_file_store.rb$|
+      $1 && $1 != 'simple' ? $1 : nil
+    end.compact.freeze
+    FileStoreRoot = "fstore".freeze
+    Separator     = "-".freeze
+
+    attr_accessor :root, :content_type, :timestamp, :usec
+    attr :content
+    attr :file_name
+
+    class << self
+      def file_name_tokens(*args)
+        @file_name_tokens ||= []
+        unless args.empty?
+          @file_name_tokens.concat(args)
+          args.each do |token|
+            next if [:timestamp, :usec].include?(token.to_sym)
+            instance_eval { attr_accessor token }
+          end
+        end
+        @file_name_tokens
+      end
+
+      def features(*args)
+        args = args.flatten.compact
+        raise ArgumentError, "Unknown feature" unless args.all?{|a| KnownFeatures.include?(a.to_s)}
+
+        args.each do |a|
+          instance_eval { include "#{a}_file_store".classify.constantize }
+        end
+      end
+    end
+
+    def initialize(args = {})
+      init_root!
+      validate!
+      load_arguments(args)
+      load_or_store!
+    end
+
+    def path
+      root.join(self.class.name.tableize, file_name)
+    end
+
+    def file_name=(new_name)
+      return false if new_name.nil? || new_name.empty?
+
+      if new_name =~ /^(.*)\.(.*?)$/
+        @file_name, self.content_type = new_name, $2
+        file_name_tokens.zip($1.split(Separator)) {|(k, v)| __send__("#{k}=", v)}
+      else
+        raise ArgumentError, "Unrecognized file name: #{new_name}"
+      end
+    end
+
+    def content=(new_content)
+      return false if new_content.nil?
+
+      @content = if new_content.respond_to?(:read) then    new_content.read
+                 elsif new_content.respond_to?(:to_s) then new_content.to_s
+                 else                                      new_content
+                 end
+    end
+
+    def open(flag = 'r+', &block)
+      path.dirname.mkpath
+      FileUtils.touch(path)
+      File.open(path, flag, &block)
+    end
+
+    protected
+
+    def load_or_store!
+      open {|f| content.nil? ? pull(f) : push(f)}
+    end
+
+    def pull(f)
+      self.content = f.read
+    end
+
+    def push(f)
+      f.write(content)
+    end
+
+    private
+
+    def init_root!
+      self.root ||= case
+                    when defined?(Rails) then   Rails.root
+                    when defined?(AppRoot) then AppRoot.is_a?(Pathname) ? AppRoot : Pathname.new(AppRoot.to_s)
+                    else                        Pathname.new(FileUtils.pwd)
+                    end.join(FileStoreRoot)
+    end
+
+    def validate!
+      raise Errno::ENOENT, "Root not found: #{root}!" unless root.exist?
+    end
+
+    def load_arguments(args)
+      # passed (as-is) args
+      args = {:content_type => 'csv'}.merge(args)
+      args.each {|(k,v)| __send__ "#{k}=", v}
+
+      # custom (builtin) args
+      t = Time.now
+      self.timestamp = t.to_i
+      self.usec      = t.usec
+
+      # hybrid args (depending on passed+builtin)
+      @file_name ||= file_name_tokens.map{|k| __send__(k)}.join(Separator) << '.' << content_type
+    end
+
+    def file_name_tokens
+      self.class.file_name_tokens
+    end
+
+  end
+
+end

data/lib/simple_file_store/version.rb

@@ -0,0 +1,5 @@
+module SimpleFileStore
+
+  VERSION = '0.0.4'
+
+end

data/simple_file_store.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'simple_file_store/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'simple_file_store'
+  s.version     = SimpleFileStore::VERSION
+  s.authors     = ['Alex Ungur']
+  s.date        = '2011-12-17'
+  s.email       = ['alexaandru@gmail.com']
+  s.homepage    = %q|http://rubygems.org/gems/simple_file_store|
+  s.summary     = %q|A file storing/loading micro-framework.|
+  s.description = %q|A micro-framework for automating storing and loading files to/from the filesystem.|
+
+  s.rubyforge_project = 'simple_file_store'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+  s.rdoc_options  = ['--main', 'README.asciidoc']
+
+  # specify any dependencies here; for example:
+  s.add_runtime_dependency 'activesupport', ['~>2.3.0']
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'shoulda'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'roodi'
+  s.add_development_dependency 'flay'
+  s.add_development_dependency 'flog'
+end

data/test/base.rb

@@ -0,0 +1,50 @@
+require 'test/unit'
+require 'fileutils'
+
+require 'rubygems'
+require 'shoulda'
+if RUBY_VERSION >= '1.9.0'
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/test/"
+    add_group "Libraries",   "/lib/"
+    command_name "Combined Tests"
+  end if ENV['COVERAGE']
+end
+
+require './lib/simple_file_store'
+# The testing fstore root
+AppRoot = File.dirname(__FILE__)
+
+module SimpleFileStore
+
+  class TestCase < Test::Unit::TestCase
+
+    def assert_dir_content_difference(dir, depth = ['*'], difference = 1)
+      raise ArgumentError, "Directory not found" unless File.exist?(dir)
+      before_content = Dir[File.join(dir, *depth)]
+      yield
+      after_content = Dir[File.join(dir, *depth)]
+      assert_equal before_content.size + difference, after_content.size,
+        "Expected an increase of #{difference} in '#{dir}' folder contents, got a difference of #{after_content.size - before_content.size}"
+      after_content - before_content
+    end
+
+    def assert_no_dir_content_difference(dir, depth = ['*'], &block)
+      assert_dir_content_difference(dir, depth, 0, &block)
+    end
+
+    def assert_attributes_set(ts, file_content, record_id, expected_file_name)
+      assert_equal file_content, ts.content, "Should set file/data"
+      assert_equal File.basename(expected_file_name), ts.file_name, "Should set file_name"
+      assert_equal record_id, ts.record_id, "Should set record ID"
+      assert ts.timestamp, "Should set timestamp"
+      assert ts.usec, "Should set timestamp/.usec"
+      assert_equal 'csv', ts.content_type, "Should set content_type"
+      assert_match %r|/test/fstore$|, ts.root.to_s, "Should set root"
+      assert_match %r|#{expected_file_name}$|, ts.path.to_s, "Should set path"
+    end
+
+  end
+
+end

data/test/caching_file_store_test.rb

@@ -0,0 +1,85 @@
+require './test/base'
+
+class TestCachingStore < SimpleFileStore::Base
+  features :caching
+
+  file_name_tokens :record_id, :alt_rec_id
+
+  def generate_content
+    "auto generated content %s/%s" % [record_id, alt_rec_id]
+  end
+end
+
+class TestBadCachingStore < SimpleFileStore::Base
+  include CachingFileStore
+
+  file_name_tokens :res_id, :alt_rec_id
+end
+
+class CachingFileStoreTest < SimpleFileStore::TestCase
+  context "Auto-saving to CachingFileStore" do
+    setup do
+      @record_id    = "102"
+      @alt_rec_id   = "foobar"
+      @file_content = "auto generated content 102/foobar"
+      @file_names   = assert_dir_content_difference('test/fstore/test_caching_stores') {
+        @ts = TestCachingStore.new(:record_id => @record_id, :alt_rec_id => @alt_rec_id)
+      }
+      @expected_file_name = "test/fstore/test_caching_stores/#{@record_id}-#{@alt_rec_id}.csv"
+    end
+
+    teardown do
+      @file_names.each {|f| File.unlink(f)} unless @file_names.nil?
+    end
+
+    should "save content to store" do
+      assert File.exist?(@expected_file_name)
+      assert_equal @expected_file_name, @file_names.first
+    end
+
+    should "set attributes" do
+      assert_attributes_set(@ts, @file_content, @record_id, @alt_rec_id, @expected_file_name)
+    end
+
+    should "raise an error if generate_content is not defined" do
+      assert_raise NoMethodError do
+        TestBadCachingStore.new(:record_id => @record_id, :alt_rec_id => @alt_rec_id)
+      end
+    end
+  end
+
+  context "Auto-loading from CachingFileStore" do
+    setup do
+      @record_id    = "1"
+      @alt_rec_id   = "2"
+      @file_content = "xyz"
+      @file_name    = "#{@record_id}#{TestCachingStore::Separator}#{@alt_rec_id}.csv"
+      @file_path    = File.join('test', 'fstore', 'test_caching_stores', @file_name)
+      FileUtils.mkdir_p(File.dirname(@file_path))
+      File.open(@file_path, 'w') {|f| f.write @file_content}
+      @file_names   = assert_no_dir_content_difference('test/fstore/test_caching_stores') {
+        @ts = TestCachingStore.new(:file_name => @file_name)
+      }
+      @expected_file_name = "test/fstore/test_caching_stores/#{@record_id}#{TestCachingStore::Separator}#{@alt_rec_id}.csv"
+    end
+
+    teardown do
+      File.unlink(@file_path)
+    end
+
+    should "load content from store" do
+      assert_equal @file_content, @ts.content
+    end
+
+    should "set attributes" do
+      assert_attributes_set(@ts, @file_content, @record_id, @alt_rec_id, @expected_file_name)
+    end
+  end
+
+  protected
+
+  def assert_attributes_set(ts, file_content, record_id, alt_rec_id, expected_file_name)
+    super(ts, file_content, record_id, expected_file_name)
+    assert_equal alt_rec_id, ts.alt_rec_id, "Should set record ID"
+  end
+end

data/test/combined_file_store_test.rb

@@ -0,0 +1,5 @@
+require './test/base'
+
+class CombinedFileStoreTest < SimpleFileStore::TestCase
+  should "test all combinations of stores"
+end

data/test/loader.rb

@@ -0,0 +1 @@
+ARGV.each {|f| load f unless f =~ /^-/}

data/test/scalable_file_store_test.rb

@@ -0,0 +1,77 @@
+require './test/base'
+
+class TestScalableStore < SimpleFileStore::Base
+  features :scalable
+
+  file_name_tokens :record_id, :alt_rec_id
+end
+
+class ScalableFileStoreTest < SimpleFileStore::TestCase
+  context "Auto-saving to ScalableFileStore" do
+    setup do
+      @record_id    = "101"
+      @alt_rec_id   = "2345678"
+      @file_content = "xyz"
+      @file_names   = assert_dir_content_difference('test/fstore/test_scalable_stores', %w|* * * * **|) {
+        @ts = TestScalableStore.new(:content => @file_content, :record_id => @record_id, :alt_rec_id => @alt_rec_id)
+      }
+      @expected_file_name = "test/fstore/test_scalable_stores/bb/37/22/88/#{@record_id}-#{@alt_rec_id}.csv"
+    end
+
+    teardown do
+      @file_names.each do |f|
+        path = File.dirname(File.dirname(File.dirname(File.dirname(f))))
+        raise ArgumentError, "You may be 'rm -rf'-ing the wrong path: '#{path}'. Aborting!" unless \
+          path =~ %r|test/fstore/test_scalable_stores/.*|
+        FileUtils.rm_rf(path)
+      end if @file_names
+    end
+
+    should "save content to store" do
+      assert File.exist?(@expected_file_name)
+      assert_equal @expected_file_name, @file_names.first
+    end
+
+    should "set attributes" do
+      assert_attributes_set(@ts, @file_content, @record_id, @alt_rec_id, @expected_file_name)
+    end
+  end
+
+  context "Auto-loading from ScalableFileStore" do
+    setup do
+      @record_id    = "1"
+      @alt_rec_id   = "2"
+      @file_content = "xyz"
+      @file_name    = "#{@record_id}#{TestScalableStore::Separator}#{@alt_rec_id}.csv"
+      @file_path    = File.join('test', 'fstore', 'test_scalable_stores', '96', 'c2', 'c5', 'c0', @file_name)
+      FileUtils.mkdir_p(File.dirname(@file_path))
+      File.open(@file_path, 'w') {|f| f.write @file_content}
+      @file_names   = assert_no_dir_content_difference('test/fstore/test_scalable_stores', %w|* * * * **|) {
+        @ts = TestScalableStore.new(:file_name => @file_name)
+      }
+      @expected_file_name = "test/fstore/test_scalable_stores/96/c2/c5/c0/#{@record_id}#{TestScalableStore::Separator}#{@alt_rec_id}.csv"
+    end
+
+    teardown do
+      path = File.dirname(File.dirname(File.dirname(File.dirname(@file_path))))
+      raise ArgumentError, "You may be 'rm -rf'-ing the wrong path: '#{path}'. Aborting!" unless \
+        path =~ %r|test/fstore/test_scalable_stores/.*|
+      FileUtils.rm_rf(path)
+    end
+
+    should "load content from store" do
+      assert_equal @file_content, @ts.content
+    end
+
+    should "set attributes" do
+      assert_attributes_set(@ts, @file_content, @record_id, @alt_rec_id, @expected_file_name)
+    end
+  end
+
+  protected
+
+  def assert_attributes_set(ts, file_content, record_id, alt_rec_id, expected_file_name)
+    super(ts, file_content, record_id, expected_file_name)
+    assert_equal alt_rec_id, ts.alt_rec_id, "Should set record ID"
+  end
+end

data/test/secure_file_store_test.rb

@@ -0,0 +1,81 @@
+require './test/base'
+
+# This is pretending to encrypt something.
+module App
+  extend self
+
+  def rot13(str)
+    str.tr "A-Za-z", "N-ZA-Mn-za-m"
+  end
+
+  alias :encrypt :rot13
+  alias :decrypt :rot13
+end
+
+class TestSecureStore < SimpleFileStore::Base
+  features :secure
+
+  file_name_tokens :record_id, :alt_rec_id
+end
+
+class SecureFileStoreTest < SimpleFileStore::TestCase
+  context "Auto-saving to SecureFileStore" do
+    setup do
+      @record_id       = "102"
+      @alt_rec_id   = "foobar"
+      @file_content = "foo bar baz"
+      @file_names   = assert_dir_content_difference('test/fstore/test_secure_stores') {
+        @ts = TestSecureStore.new(:content => @file_content, :record_id => @record_id, :alt_rec_id => @alt_rec_id)
+      }
+      @expected_file_name = "test/fstore/test_secure_stores/#{@record_id}-#{@alt_rec_id}.csv"
+    end
+
+    teardown do
+      @file_names.each {|f| File.unlink(f)} unless @file_names.nil?
+    end
+
+    should "save content to store" do
+      assert File.exist?(@expected_file_name)
+      assert_equal @expected_file_name, @file_names.first
+    end
+
+    should "set attributes" do
+      assert_attributes_set(@ts, @file_content, @record_id, @alt_rec_id, @expected_file_name)
+    end
+  end
+
+  context "Auto-loading from SecureFileStore" do
+    setup do
+      @record_id       = "1"
+      @alt_rec_id   = "2"
+      @file_content = "xyz"
+      @file_name    = "#{@record_id}#{TestSecureStore::Separator}#{@alt_rec_id}.csv"
+      @file_path    = File.join('test', 'fstore', 'test_secure_stores', @file_name)
+      FileUtils.mkdir_p(File.dirname(@file_path))
+      File.open(@file_path, 'w') {|f| f.write @file_content}
+      @file_names   = assert_no_dir_content_difference('test/fstore/test_secure_stores') {
+        @ts = TestSecureStore.new(:file_name => @file_name)
+      }
+      @expected_file_name = "test/fstore/test_secure_stores/#{@record_id}#{TestSecureStore::Separator}#{@alt_rec_id}.csv"
+    end
+
+    teardown do
+      File.unlink(@file_path)
+    end
+
+    should "load content from store" do
+      assert_equal App.decrypt(@file_content), @ts.content
+    end
+
+    should "set attributes" do
+      assert_attributes_set(@ts, App.decrypt(@file_content), @record_id, @alt_rec_id, @expected_file_name)
+    end
+  end
+
+  protected
+
+  def assert_attributes_set(ts, file_content, record_id, alt_rec_id, expected_file_name)
+    super(ts, file_content, record_id, expected_file_name)
+    assert_equal alt_rec_id, ts.alt_rec_id, "Should set record ID"
+  end
+end

data/test/simple_file_store_test.rb

@@ -0,0 +1,57 @@
+require './test/base'
+
+class TestStore < SimpleFileStore::Base
+  file_name_tokens :record_id, :timestamp, :usec
+end
+
+class SimpleFileStoreTest < SimpleFileStore::TestCase
+  context "Auto-saving to SimpleFileStore" do
+    setup do
+      @record_id    = "100"
+      @file_content = "abc"
+      @file_names   = assert_dir_content_difference('test/fstore/test_stores') {
+        @ts = TestStore.new(:content => @file_content, :record_id => @record_id)
+        @expected_file_name = File.join('test', TestStore::FileStoreRoot, 'test_stores',
+          "#{@ts.record_id}#{TestStore::Separator}#{@ts.timestamp}-#{@ts.usec}.#{@ts.content_type}")
+      }
+    end
+
+    teardown do
+      @file_names.each {|f| File.unlink(f)} unless @file_names.nil?
+    end
+
+    should "save content to store" do
+      assert File.exist?(@expected_file_name), "File '#{@expected_file_name}' should have been created!"
+      assert_equal @expected_file_name, @file_names.first
+    end
+
+    should "set attributes" do
+      assert_attributes_set(@ts, @file_content, @record_id, @expected_file_name)
+    end
+  end
+
+  context "Auto-loading from SimpleFileStore" do
+    setup do
+      @record_id    = "101"
+      @file_content = "cde"
+      @file_name    = "101-#{Time.now.to_i}-1.csv"
+      @file_path    = File.join('test', 'fstore', 'test_stores', @file_name)
+      File.open(@file_path, 'w') {|f| f.write @file_content}
+      @file_names   = assert_no_dir_content_difference('test/fstore/test_stores') {
+        @ts = TestStore.new(:file_name => @file_name)
+      }
+    end
+
+    teardown do
+      FileUtils.rm_f(@file_path)
+    end
+
+    should "load content from store" do
+      assert_equal @file_content, @ts.content
+    end
+
+    should "set attributes" do
+      assert_attributes_set(@ts, @file_content, @record_id, @file_path)
+    end
+  end
+end

metadata

@@ -0,0 +1,205 @@
+--- !ruby/object:Gem::Specification 
+name: simple_file_store
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Alex Ungur
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-17 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: roodi
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: flay
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: flog
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+description: A micro-framework for automating storing and loading files to/from the filesystem.
+email: 
+- alexaandru@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- History.txt
+- README.asciidoc
+- Rakefile
+- lib/mini_blank_slate.rb
+- lib/simple_file_store.rb
+- lib/simple_file_store/caching_file_store.rb
+- lib/simple_file_store/scalable_file_store.rb
+- lib/simple_file_store/secure_file_store.rb
+- lib/simple_file_store/simple_file_store.rb
+- lib/simple_file_store/version.rb
+- simple_file_store.gemspec
+- test/base.rb
+- test/caching_file_store_test.rb
+- test/combined_file_store_test.rb
+- test/fstore/test_caching_stores/.keep
+- test/fstore/test_scalable_stores/.keep
+- test/fstore/test_secure_stores/.keep
+- test/fstore/test_stores/.keep
+- test/loader.rb
+- test/scalable_file_store_test.rb
+- test/secure_file_store_test.rb
+- test/simple_file_store_test.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/simple_file_store
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.asciidoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: simple_file_store
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A file storing/loading micro-framework.
+test_files: []
+