crnixon-active_files 0.1.0

data/History.txt

@@ -0,0 +1,9 @@
+== 0.2.0 / 2008-06-06
+* 1 major enhancement
+  * Moved from inheritance and ostruct limitation to inclusion
+
+== 0.1.0 / 2004-02-01
+
+* 1 major enhancement
+  * Created
+  

data/Manifest.txt

@@ -0,0 +1,19 @@
+.gitignore
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+lib/active_files.rb
+lib/active_files/record.rb
+lib/lib_helper.rb
+tasks/bones.rake
+tasks/gem.rake
+tasks/manifest.rake
+tasks/notes.rake
+tasks/post_load.rake
+tasks/rdoc.rake
+tasks/rubyforge.rake
+tasks/setup.rb
+tasks/test.rake
+test/test_active_files.rb
+test/test_helper.rb

data/README.rdoc

@@ -0,0 +1,81 @@
+= ActiveFiles
+
+by Clinton R. Nixon
+
+URL: http://github.com/crnixon/active_files
+
+== Description
+
+This library attempts to implement an ActiveRecord-like interface to
+a directory structure of flat files containing serialized objects,
+probably in YAML.
+
+== Features/problems
+
+* Serializes any object
+* No validations yet
+
+== Requirements
+
+To run tests, you need the spect and Shoulda gems.
+
+== Synopsis
+
+    ActiveFiles.base_dir = '/tmp/af'
+
+    class Person < Hash
+      include ActiveFiles::Record
+      add_file_id_to_initialize
+    end
+
+    class Wingdom
+      include ActiveFiles::Record
+
+      attr_reader :feathers, :color
+  
+      def initialize(id, feathers, color)
+        self.file_id = id
+        @feathers = feathers
+        @color = color
+      end
+
+      def to_activefile
+        { :plumoj => @feathers.to_s.split(//).reverse,
+          :koloro => [@color, @color, @color].join('\/') }.to_yaml.reverse
+      end
+
+      def self.from_activefile(yaml, file_id)
+        hash = YAML::load(yaml.reverse)
+        feathers = hash[:plumoj].reverse.inject("") { |s, c| s << c }.to_i
+        color = hash[:koloro].split('\/')[1]
+        Wingdom.new(file_id, feathers, color)
+      end
+    end
+
+    herbert = Person.new('herbert')
+    herbert['address'] = '103 Choctaw Dr'
+    herbert['birthday'] = Date.parse('2/4/1979')
+    herbert.save
+
+    also_herbert = Person.find("herbert")
+    also_herbert = Person.find(:first, "herb*")
+    herbs = Person.find("herb*")
+    herbs = Person.find(:all, "herb*")
+
+== License
+
+(ISC License)
+
+Copyright (c) 2008 Clinton R. Nixon of Viget Labs
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/lib/active_files.rb

@@ -0,0 +1,56 @@
+# Equivalent to a header guard in C/C++
+# Used to prevent the class/module from being loaded more than once
+unless defined? ActiveFiles
+
+  require File.dirname(__FILE__) + '/lib_helper'
+  require 'fileutils'
+  require 'yaml'
+
+  module ActiveFiles
+
+    # :stopdoc:
+    VERSION = '0.1.0'
+    LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+    PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+    # :startdoc:
+
+    def self.version
+      VERSION
+    end
+
+    @@base_dir = nil
+    @@ext = '.yaml'
+
+    # This should definitely be used right off the bat, like so:
+    #
+    # <tt>ActiveFiles.base_dir = '/dir/where/I/store/files'</tt>
+    #
+    # This is where all your ActiveFiles files will be loaded from
+    # and saved to.
+    def self.base_dir=(dir)
+      FileUtils.mkdir_p dir
+      @@base_dir = dir
+    end
+
+    # Accessor! Find out your ActiveFiles directory.
+    def self.base_dir
+      @@base_dir
+    end
+
+    # Probably never used, but you can change the default
+    # ActiveFiles extension, which is ".yaml".
+    def self.ext=(ext)
+      @@ext = ext
+    end
+
+    # Accessor! Get your ActiveFiles file extension.
+    def self.ext
+      @@ext
+    end
+    
+  end  # module ActiveFiles
+
+  LibHelper.require_all_libs_relative_to __FILE__
+
+end  # unless defined?
+

data/lib/active_files/record.rb

@@ -0,0 +1,159 @@
+class ActiveFiles::FileNotFound < Exception; end
+class ActiveFiles::NoFileId < Exception; end
+
+module ActiveFiles::Record
+  def self.included(base)
+    base.module_eval do
+      extend ActiveFiles::Record::ClassMethods
+    end
+  end
+
+  module ClassMethods
+    # Adds a parameter to the beginning of initialize to accept a file_id.
+    # If you run this, you must run it after your own initialize (or not have
+    # an initialize at all.)
+    #
+    # Feel free to take care of file_id yourself somehow.    
+    def add_file_id_to_initialize
+      self.module_eval do
+        def initialize_with_file_id(file_id, *args)
+          self.file_id = file_id
+          initialize_without_file_id(*args)
+        end
+        alias :initialize_without_file_id :initialize
+        alias :initialize :initialize_with_file_id
+      end
+    end
+    
+    # Find. Tries way too hard to replicate ActiveRecord.
+    #
+    # Find operates with three different retrieval mechanisms.
+    #
+    # * Find by name: Enter a name, or a glob. If one record
+    #   can be found matching that name, then only one is
+    #   returned. If more than one can be found, an array
+    #   is returned. If no record can be found,
+    #   ActiveFiles::FileNotFound is thrown.
+    #
+    # * Find first (<tt>:first</tt>): This will return the
+    #   first record matched by the options used. If no
+    #   record can matched, nil is returned.
+    #
+    # * Find all (<tt>:all</tt>: This will return all the
+    #   records matched by the options used. If no records
+    #   are found, an empty array is returned.
+    #
+    # The last two approached accept an option hash as their
+    # last parameter. The options are:
+    # * <tt>:name => name</tt>:: Glob-based record name.
+    def find(*args)
+      name = '*'
+      order = nil
+
+      if (args.length == 1 and args[0].kind_of?(String)) then
+        name = args[0]
+        mode = :name
+      elsif (args.first == :first or args.first == :all)
+        mode = args.first
+        options = extract_find_options!(args)
+        name = options[:name] if options.has_key?(:name)
+        order = options[:order] if options.has_key?(:order)
+      else
+        raise ArgumentError, "Unknown mode: #{args.first}"
+      end
+
+      files = Dir[File.join(self.file_store, name + ActiveFiles.ext)]
+      
+      if files.empty? then
+        case mode
+        when :name
+          raise ActiveFiles::FileNotFound
+        when :first
+          return nil
+        when :all
+          return Array.new()
+        end
+      elsif (mode == :first or (mode == :name and files.length == 1)) then
+        return self.from_activefile(File.read(files.first), self.parse_file_id(files.first))
+      else
+        objs = Array.new()
+        files.each do |file|
+          objs.push(self.from_activefile(File.read(file), self.parse_file_id(file)))
+        end
+
+        return case order
+               when 'asc' then objs.sort { |a,b| a.file_id <=> b.file_id }
+               when 'desc' then objs.sort { |a,b| b.file_id <=> a.file_id }
+               else objs
+               end
+      end
+    rescue Errno::ENOENT
+      self.create_file_store
+      self.find(*args)
+    end
+
+    # Directory in which this class's ActiveFiles are stored.
+    def file_store
+      File.join(ActiveFiles.base_dir, self.to_s)
+    end
+
+    def create_file_store
+      FileUtils.mkdir_p(file_store) unless File.exists?(file_store)
+    end
+
+    protected
+    
+    def extract_find_options!(args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      unknown_options = options.keys - [:name, :order].flatten
+      raise(ArgumentError, "Unknown key(s): #{unknown_options.join(", ")}") unless unknown_options.empty?
+      options
+    end
+
+    def parse_file_id(file)
+      File.basename(file, ActiveFiles.ext)
+    end
+
+    def from_activefile(yaml, file_id)
+      obj = YAML::load(yaml)
+      if obj.respond_to?(:file_id=)
+        obj.send(:file_id=, file_id)
+      end
+      obj
+    end
+  end
+  
+  def save
+    raise ActiveFiles::NoFileId if self.file_id.nil?
+    File.open(filename, 'w') do |file|
+      file.puts self.to_activefile
+    end
+    true
+  rescue Errno::ENOENT
+    self.class.create_file_store
+    self.save
+  end
+
+  def delete
+    File.delete(filename)
+  end
+
+  def file_id
+    @file_id
+  end
+
+  protected
+
+  def to_activefile
+    self.to_yaml
+  end
+
+  def filename
+    File.join(self.class.file_store, self.file_id + ActiveFiles.ext)
+  end
+
+  def file_id=(id)
+    @file_id = id
+  end
+
+end

data/lib/lib_helper.rb

@@ -0,0 +1,14 @@
+module LibHelper
+  # Utility method used to rquire all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+                                   ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+end

data/test/test_active_files.rb

@@ -0,0 +1,120 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Person < Hash
+  include ActiveFiles::Record
+  add_file_id_to_initialize
+end
+
+class Wingdom
+  include ActiveFiles::Record
+
+  attr_reader :feathers, :color
+  
+  def initialize(id, feathers, color)
+    self.file_id = id
+    @feathers = feathers
+    @color = color
+  end
+
+  def to_activefile
+    { :plumoj => @feathers.to_s.split(//).reverse,
+      :koloro => [@color, @color, @color].join('\/') }.to_yaml.reverse
+  end
+
+  def self.from_activefile(yaml, file_id)
+    hash = YAML::load(yaml.reverse)
+    feathers = hash[:plumoj].reverse.inject("") { |s, c| s << c }.to_i
+    color = hash[:koloro].split('\/')[1]
+    Wingdom.new(file_id, feathers, color)
+  end
+end
+
+class TestActiveFiles < Test::Unit::TestCase
+
+  context "with a base directory" do
+    setup do
+      dirname = File.join(File.dirname(__FILE__), 'sample_data')
+      ActiveFiles.base_dir = dirname
+    end
+
+    teardown do
+      FileUtils.rm_rf(File.join(File.dirname(__FILE__), 'sample_data'))
+    end
+
+    should "be able to save a new object" do
+      p = Person.new('test')
+      expect(p.save).to.be true
+      expect(File.exist?(p.send(:filename))).to.be true
+    end
+
+    should "be able to save and reload an insane object" do
+      w = Wingdom.new('cardinal', 1372, 'red')
+      w.save
+
+      w = Wingdom.find('cardinal')
+      expect(w.feathers).to.be 1372
+      expect(w.color).to.be 'red'
+    end
+
+    context "with an existing object" do
+      setup do
+        @herbert = Person.new('Herbert')
+        @herbert[:birthday] = Date.parse('February 4, 1979')
+        @herbert.save
+      end
+
+      should "be able to find object" do
+        p = Person.find('Herbert')
+        expect(p).not.to.be.nil
+        expect(p).is_a Person
+        expect(p[:birthday]).to.equal Date.parse('2/4/1979')
+      end
+
+      should "be able to delete object" do
+        @herbert.delete
+        expect(File.exist?(@herbert.send(:filename))).not.to.be true
+      end
+    end
+
+    context "with more than one existing object" do
+      setup do
+        3.times do |i|
+          Person.new("person_#{i}").save
+        end
+      end
+
+      should "be able to find many by globbing" do
+        expect(Person.find('person*').size).to.be 3
+      end
+
+      should "be able to find first by globbing" do
+        person = Person.find(:first, 'person*')
+        expect(person).is.kind_of Person
+        expect(person.file_id).to.be 'person_1'
+      end
+    end
+
+    context "with no matching elements" do
+      setup do
+        Person.find(:all, "b*").each do |person|
+          person.delete
+        end
+      end
+
+      should "raise an error when simple finding" do
+        expect(ActiveFiles::FileNotFound).to.be.raised_by do
+          Person.find('bill')
+        end
+      end
+
+      should "return nil when explicitly finding first" do
+        expect(Person.find(:first, 'bill')).to.be.nil
+      end
+
+      should "return an empty array when explicitly finding all" do
+        expect(Person.find(:all, 'b*')).to.be.empty
+      end
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+require 'spect'
+require 'mocha'
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'active_files')

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: crnixon-active_files
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Clinton R. Nixon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-10 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: TODO
+email: crnixon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Manifest.txt
+- README.rdoc
+- VERSION.yml
+- History.txt
+- lib/active_files.rb
+- lib/lib_helper.rb
+- lib/active_files
+- lib/active_files/record.rb
+- test/test_active_files.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/crnixon/active_files
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A file store for arbitrary objects, all easy-peasy.
+test_files: []
+