parcel 0.1

data/lib/parcel.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(__FILE__), "parcel", "has_parcel")
+require File.join(File.dirname(__FILE__), "parcel", "zip_file_repository")
+
+module Parcel
+  
+  @options = Hash.new
+  
+  def self.storage_root
+    @options[:storage_root] || "./:class_name/:id"
+  end
+  
+  def self.storage_root=(value)
+    @options[:storage_root] = value
+  end
+  
+  def self.temp_path(filename)
+    date_stamp = "%04d_%02d_%02d" % [Time.now.year, Time.now.month, Time.now.day]
+    path = File.join(temp_root, date_stamp, "#{Time.now.to_i}_#{rand(999999)}_#{filename}")
+    FileUtils.mkdir_p( File.dirname(path) )
+    path
+  end
+  
+  def self.temp_root=(value)
+    @options[:temp_root] = value
+  end
+  
+  def self.temp_root
+    @options[:temp_root] || "/tmp/parcel"
+  end
+  
+  def self.underscore(camel_cased_word)
+    camel_cased_word.to_s.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+  
+  def self.interpolate_path(path, options, reference)
+    new_path = path.to_s
+    
+    framework_opts = Hash.new
+    if defined?(Rails)
+      framework_opts[:rails_root] = Rails.root
+      framework_opts[:id] = reference.id if reference.is_a?(ActiveRecord::Base)
+    end
+    
+    framework_opts[:id] ||= reference.object_id
+    
+    merge_opts = framework_opts.merge({ :class_name => underscore(reference.class.name) }).merge(options)
+    
+    puts merge_opts.inspect
+    
+    merge_opts.to_a.sort_by { |(k,v)| -k.to_s.length }.each do |(k,v)|
+      new_path = new_path.gsub(":#{k}", v.to_s)
+    end
+    
+    new_path
+  end
+  
+  def self.create_repository(owner, options, source = nil)
+    repo = if options[:class] == :zip
+      ZipFileRepository.new(owner, options)
+    else
+      nil
+    end
+    
+    raise ArgumentError, "Repository not supported: #{options[:class]}" if repo.nil?
+    
+    if source.is_a?(String) && source.starts_with?("/")
+      repo.import(File.open(source, "r"))
+    elsif source.is_a?(String)
+      repo.import_data(source)
+    elsif source.respond_to?(:to_file)
+      repo.import(source.to_file)
+    elsif source.respond_to?(:read)
+      repo.import(source)
+    elsif File.exist?(repo.commit_path)
+      repo.import(File.open(repo.commit_path, "r"))
+    end
+    
+    repo
+  end
+  
+end
+
+Object.send(:include, Parcel::HasParcel)

data/lib/parcel/has_parcel.rb

@@ -0,0 +1,63 @@
+module Parcel
+  module HasParcel
+    def self.included(base)
+      base.module_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+  
+    module InstanceMethods
+      def parcel_data_path(filename)
+        data_path = File.join(Parcel.interpolate_path(Parcel.storage_root, Hash.new, self), filename.to_s)
+        data_path
+      end
+      
+      def commit_parcels!
+        Array(instance_variables.select { |v| v =~ /\@_parcel_/ }).each do |name|
+          instance = instance_variable_get(name)
+          instance.commit! if instance
+        end
+        
+        true
+      end
+      
+      def destroy_parcels!
+        FileUtils.rm_rf(self.class.parcel_data_path("."))
+      end
+    end
+  
+    module ClassMethods
+    
+      def has_parcel(name, options = {})
+        options = { :class => :zip }.merge(options).merge({ :name => name })
+
+        unless included_modules.include?(InstanceMethods)
+          include(InstanceMethods)
+          
+          if defined?(ActiveRecord) && is_a?(ActiveRecord::Base)
+            after_save :commit_parcels!
+            after_destroy :destroy_parcels!
+          end
+        end
+      
+        define_method(name.to_sym) do
+          instance_variable_get("@_parcel_#{name}") || begin
+            parcel = Parcel.create_repository(self, options)
+            instance_variable_set("@_parcel_#{name}", parcel)
+            parcel
+          end
+        end
+      
+        define_method("#{name}=".to_sym) do |input|
+          instance = instance_variable_get("@_parcel_#{name}")
+          instance.destroy if instance
+          
+          instance_variable_set("@_parcel_#{name}", Parcel.create_repository(self, options, input))
+        end
+        
+      end
+    end
+    
+  end
+end

data/lib/parcel/zip_file_repository.rb

@@ -0,0 +1,97 @@
+require 'fileutils'
+require 'zip/zip'
+require 'ostruct'
+
+module Parcel
+  
+  # The FileRepository class represents a compressed archive of files
+  # providing an easy interface for enumerating and updating the contents.
+  class ZipFileRepository
+  
+    # Create a blank FileRepository, or open one from an existing file object.
+    def initialize(owner = nil, options = Hash.new)
+      @temp_file = Parcel.temp_path("#{owner.object_id}_#{rand(99999)}.zip")
+      @owner = owner
+      @name = options[:name]
+    end
+    
+    def import(source)
+      File.open(@temp_file, "w") { |f| f.write source.read }
+    end
+    
+    def import_data(data)
+      File.open(@temp_file, "w") { |f| f.write data }
+    end
+    
+    def commit_path
+      @owner.parcel_data_path(@name) + ".zip"
+    end
+  
+    # Returns true if there are no files in the repository, or if the attachment is nil.
+    def blank?
+      files.blank?
+    end
+    
+    # Clears the repository.
+    def clear!
+      File.unlink(@temp_file) if File.exist?(@temp_file)
+      
+      Zip::ZipFile.open( @temp_file, Zip::ZipFile::CREATE ) do
+      end
+    end
+  
+    # Returns all the files present in the repository.
+    def files
+      return [] if @temp_file.nil? || !File.exist?(@temp_file)
+    
+      result = Array.new
+      Zip::ZipFile.foreach(@temp_file) { |entry| result << OpenStruct.new(:name => entry.name, :size => entry.size) }
+      result
+    end
+  
+    # Returns the contents of the given file. Supports wildcard matching, 
+    # in which case returns the contents of the first file found.
+    def read_file(filename)
+      return nil if blank?
+    
+      file_match = Regexp.new("^" + filename.gsub(".", "\\.").gsub("*", ".*").gsub("?", ".") + "$", Regexp::IGNORECASE)
+    
+      Zip::ZipFile.foreach(@temp_file) do |entry|
+        if entry.name =~ file_match
+          read_file = Parcel.temp_path(File.basename(entry.name))
+          entry.extract(read_file)
+          result = IO.read(read_file)
+          File.unlink(read_file)
+          return result
+        end
+      end
+    
+      return nil
+    end
+  
+    # Adds a file to the repository.
+    def add_file(filename, contents)
+      Zip::ZipFile.open( @temp_file, Zip::ZipFile::CREATE ) do |writer|
+        writer.get_output_stream(filename) { |file| file.write contents }
+      end
+    end
+  
+    # Returns an open file stream of the repository.
+    def to_file
+      blank? ? nil : File.open(@temp_file)
+    end
+    
+    def save_to(destination)
+      FileUtils.mkdir_p(File.dirname(destination))
+      FileUtils.cp(@temp_file, destination) if @temp_file && File.exist?(@temp_file)
+    end
+    
+    def commit!
+      raise ArgumentError, "No owner defined, use \#save_to instead" if @owner == nil
+      save_to(commit_path)
+    end
+  
+  end
+  
+  
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: parcel
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Sean St. Quentin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-15 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyzip
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: "    Parcel is a simple library which allows normal ruby objects to maintain a series\n    of files stored in one or more repositories which are accessible through normal ruby attributes.\n    Possible repositories include Zip Files, Tar Files, Subversion Repos, Repos, GridFS Zips, etc.\n    It also provides an common and easy to use interface to all these repositories (i.e. more ruby like than RubyZip), and\n    works with ActiveRecord but doesn't depend on it.\n"
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/parcel.rb
+- lib/parcel/has_parcel.rb
+- lib/parcel/zip_file_repository.rb
+has_rdoc: true
+homepage: http://github.com/elseano/parcel
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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.3.5
+signing_key: 
+specification_version: 3
+summary: Simple repository management
+test_files: []
+