jsl-archived_attributes 0.0.1

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'spec'
+
+require 'rake'
+require 'spec/rake/spectask'
+require 'rake/rdoctask'
+
+desc 'Test the plugin.'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts  = ["--format", "specdoc", "--colour"]
+  t.libs << 'lib'
+  t.verbose = true
+end
+
+desc "Run all the tests"
+task :default => :spec
+
+desc 'Generate documentation for the compressed_attributes plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ArchivedAttributes'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/archived_attributes.gemspec

@@ -0,0 +1,30 @@
+Gem::Specification.new do |s|
+  s.name     = "archived_attributes"
+  s.version  = "0.0.1"
+  s.date     = "2009-01-25"
+  s.summary  = "Rails plugin to save content to a pluggable back-end"
+  s.email    = "justin@phq.org"
+  s.homepage = "http://github.com/jsl/archived_attributes"
+  s.description = "ArchivedAttributes allows for data to be saved to a backend other than the rdbms"
+  s.has_rdoc = true
+  s.authors  = ["Justin Leitgeb"]
+  s.files    = [
+    "Rakefile",
+    "archived_attributes.gemspec",
+    "init.rb",
+    "config/archived_attributes.yml",
+    "lib/archived_attributes.rb",
+    "lib/archived_attributes/archived_attribute.rb",
+    "lib/archived_attributes/global_configuration.rb",
+    "lib/archived_attributes/backends/s3.rb",
+    "lib/archived_attributes/backends/filesystem.rb"
+  ]
+  s.test_files = [
+    "spec/archived_attributes/global_configuration_spec.rb",
+    "spec/archived_attributes/archived_attribute_spec.rb",
+    "spec/archived_attributes/backends/filesystem_spec.rb",
+    "spec/archived_attributes/backends/s3_spec.rb"
+  ]
+  s.add_dependency("right_aws", ["> 0.0.0"])
+  s.add_dependency("assaf-uuid", ["> 0.0.0"])
+end

data/config/archived_attributes.yml

@@ -0,0 +1,19 @@
+test:
+    storage: filesystem
+    s3:
+        bucket: test_archived_attributes
+        access_key: your access key
+        secret_key: your secret key
+        protocol: https
+        
+development:
+    storage: s3
+    s3:
+        bucket: development_archived_attributes
+        access_key: your access key
+        secret_key: your secret key
+
+anotherenv:
+    storage: filesystem
+    filesystem:
+        archive_root: /tmp/archived_attributes

data/init.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[lib archived_attributes]))
+
+ActiveRecord::Base.send(:include, ArchivedAttributes)
+

data/lib/archived_attributes/archived_attribute.rb

@@ -0,0 +1,72 @@
+require 'activesupport'
+
+require File.expand_path(File.join(File.dirname(__FILE__),  
+    %w[ backends filesystem ]))
+
+require File.expand_path(File.join(File.dirname(__FILE__),  %w[ backends s3 ]))
+
+module ArchivedAttributes
+  
+  class ArchivedAttribute
+    attr_reader :name, :instance
+
+    def initialize(name, instance, opts = {})
+      @name     = name
+      @instance = instance
+      @dirty    = false
+
+      @_options = ArchivedAttributes::GlobalConfiguration.instance.to_hash.
+        merge(opts)
+
+      @backend = instantiate_backend_from(options)
+    end
+    
+    def value
+      val = defined?(@stashed_value) ? @stashed_value : @backend.load
+      val = compress? ? Zlib::Inflate.inflate(val) : val
+      val = marshal? ? Marshal.load(val) : val
+    end
+
+    def value=(other)
+      other = marshal? ? Marshal.dump(other) : other
+      other = compress? && !other.nil? ? Zlib::Deflate.deflate(other) : other
+      @stashed_value = other
+      @dirty = true
+    end
+
+    def dirty?
+      @dirty
+    end
+
+    # First saves this record to the back-end.  If backend storage raises an
+    # error, we capture it and add it to the AR validation errors.
+    def save
+      @backend.save(@stashed_value) if self.dirty?
+    end
+
+    def destroy
+      @backend.destroy
+    end
+
+    # Returns a backend object based on the options given (e.g., filesystem,
+    # s3).
+    def instantiate_backend_from(options)
+      "ArchivedAttributes::Backends::#{options[:storage].to_s.camelize}".
+        constantize.new(self)
+    end
+
+    def options
+      @_options
+    end
+
+    private
+
+    [:marshal, :compress].each do |sym|
+      define_method("#{sym}?") do                   # def marshal?
+        options[sym].nil? ? false : options[sym]    #   options[:marshal].nil? ? false : options[:marshal]
+      end                                           # end
+    end
+
+  end
+  
+end

data/lib/archived_attributes/backends/filesystem.rb

@@ -0,0 +1,58 @@
+module ArchivedAttributes
+  module Backends
+    
+    class Filesystem
+
+      def initialize(archived_attribute)
+        @archived_attribute = archived_attribute
+      end
+
+      def save(content)
+        create_filesystem_path unless File.exist?(filepath)
+        write_to_disk(content)
+      end
+
+      def destroy
+        FileUtils.rm_f(filename)
+      end
+
+      def load
+        File.read( filename ) if File.exist?( filename )
+      end
+
+      # Returns the full file path + name of this archived attribute
+      def filename
+        File.join(filepath, @archived_attribute.name.to_s)
+      end
+
+      private
+
+      # Writes content to disk, or raises an error if the content is unable to
+      # be saved
+      def write_to_disk(content)
+        File.open(filename, 'w') { |f| f.write(content) }
+      end
+
+      def create_filesystem_path
+        FileUtils.mkdir_p(filepath)
+      end
+
+      # The file path used for archiving this attribute.  Includes either the
+      # options[:filesystem][:archive_root] attribute, if available, or the
+      # RAILS_ROOT/tmp/archived_attribute_archive/attribute_name.
+      def filepath
+        config_path = @archived_attribute.options[:filesystem][:archive_root]
+
+        base_path =  config_path || File.join(
+          %W[#{RAILS_ROOT} tmp archived_attribute_archive]
+        )
+
+        File.expand_path( File.join(base_path,
+            @archived_attribute.name.to_s,
+            @archived_attribute.instance.uuid ))
+      end
+
+    end
+    
+  end
+end

data/lib/archived_attributes/backends/s3.rb

@@ -0,0 +1,58 @@
+require 'right_aws'
+
+module ArchivedAttributes
+  module Backends
+
+    class S3
+
+      def initialize(archived_attribute)
+        @archived_attribute = archived_attribute
+        @config = ArchivedAttributes::GlobalConfiguration.instance[:s3]
+      end
+
+      def save(content)
+        bucket.put( key_name, StringIO.new( content ) ) unless content.nil?
+      end
+
+      def destroy
+        bucket.key(key_name).delete
+      end
+
+      def load
+        bucket.get(key_name)
+      end
+
+      private
+
+      def bucket
+        @bucket ||= right_aws_s3.bucket(bucket_name)
+      end
+
+      def right_aws_s3        
+        @s3 ||= RightAws::S3.new(
+          @config[:access_key],
+          @config[:secret_key]
+        )
+      end
+
+      # Returns the bucket name to be used based on attributes of the archived
+      # attribute.
+      def bucket_name
+        @config[:bucket]
+      end
+
+      def key_name
+        [ @archived_attribute.instance.class.table_name,
+          @archived_attribute.name,
+          @archived_attribute.instance.uuid ].join('/')
+      end
+
+      # Returns a string representing whether we use http or https for this
+      # connection.
+      def protocol
+        @config[:protocol] || 'https'
+      end
+    end
+
+  end
+end

data/lib/archived_attributes/global_configuration.rb

@@ -0,0 +1,49 @@
+module ArchivedAttributes
+
+  # Singleton class for reading the defaults archived attribute configuration
+  # for this environment.
+  class GlobalConfiguration
+    include Singleton
+
+    DEFAULTS = HashWithIndifferentAccess.new({
+      :storage    => 'filesystem',
+      :marshal    => false,
+      :compress   => false,
+      :s3 => {
+        :protocol => 'https'
+      },
+      :filesystem => {
+        :archive_root => nil
+      }
+    })
+    
+    def [](val)
+      config[val]
+    end
+
+    def to_hash
+      config
+    end
+
+    def to_s
+      config.inspect
+    end
+
+    private
+
+    def config
+      @config ||= HashWithIndifferentAccess.new(
+        DEFAULTS.merge(load_yaml_configuration)
+      )
+
+      @config.dup
+    end
+
+    def load_yaml_configuration
+      YAML.load_file(
+        File.join( RAILS_ROOT, 'config', 'archived_attributes.yml' )
+      )[RAILS_ENV]
+    end
+  end
+
+end

data/lib/archived_attributes.rb

@@ -0,0 +1,80 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[archived_attributes archived_attribute] ))
+require File.expand_path(File.join(File.dirname(__FILE__), %w[archived_attributes global_configuration] ))
+
+require 'uuid'
+
+module ArchivedAttributes
+
+  def self.included(base)
+    base.extend(SingletonMethods)
+  end
+
+  module SingletonMethods
+
+    def archived_attribute(*args)
+      attribute = args.first
+
+      options = args.extract_options!
+      options.reverse_merge! :marshalled => false
+
+      if archived_attribute_definitions.nil?
+        write_inheritable_attribute(:archived_attribute_definitions, {})
+
+        before_save :generate_uuid
+        before_save :save_archived_attributes
+        before_destroy :destroy_archived_attributes
+      end
+      
+      archived_attribute_definitions[attribute] = options
+
+      self.__send__(:include, InstanceMethods)
+
+      define_method attribute do
+        archive_stash_for(attribute).value
+      end
+
+      define_method "#{attribute}=" do |value|
+        archive_stash_for(attribute).value = value
+      end
+    end
+
+    # Returns the attachment definitions defined by each call to
+    # has_attached_file.
+    def archived_attribute_definitions
+      read_inheritable_attribute(:archived_attribute_definitions)
+    end
+
+  end
+
+  module InstanceMethods
+    def archive_stash_for(model)
+      @_archived_attribute_stashes ||= {}
+      @_archived_attribute_stashes[model] ||= ArchivedAttribute.new(
+        model, self, self.class.archived_attribute_definitions[model]
+      )
+    end
+
+    def each_archived_stash
+      self.class.archived_attribute_definitions.each do |name, definition|
+        yield(name, archive_stash_for(name))
+      end
+    end
+
+    def save_archived_attributes
+      each_archived_stash do |name, stash|
+        stash.__send__(:save)
+      end
+    end
+
+    def destroy_archived_attributes
+      each_archived_stash do |name, stash|
+        stash.__send__(:destroy)
+      end
+    end
+
+    def generate_uuid
+      self.uuid = UUID.new.generate if self.new_record?
+    end
+
+  end
+end

data/spec/archived_attributes/archived_attribute_spec.rb

@@ -0,0 +1,120 @@
+require File.join(File.dirname(__FILE__), %w[ .. spec_helper ])
+
+describe ArchivedAttributes::ArchivedAttribute do
+  before do
+    options = { :storage => 'filesystem' }
+    stub_model = stub(:uuid => '43')
+    @aa = ArchivedAttributes::ArchivedAttribute.new(:glorp, stub_model, options)
+  end
+
+  describe "#dirty?" do
+    it "should return false when a value has not been set" do
+      @aa.should_not be_dirty
+    end
+
+    it "should return when the value has been set" do
+      @aa.value = 'stuff'
+      @aa.should be_dirty
+    end
+  end
+
+  describe "#marshal?" do
+    it "should return false if configuration option is nil" do
+      @aa.expects(:options).returns({:marshal => nil})
+      @aa.__send__(:marshal?).should be_false
+    end
+
+    it "should return value from configuration if configuration option is not nil" do
+      @aa.expects(:options).returns({:marshal => false}).times(2)
+      @aa.__send__(:marshal?).should be_false
+    end
+  end
+
+  describe "#compress?" do
+    it "should return false if configuration option is nil" do
+      @aa.expects(:options).returns({:compress => nil})
+      @aa.__send__(:compress?).should be_false
+    end
+
+    it "should return value from configuration if configuration option is not nil" do
+      @aa.expects(:options).returns({:compress => false}).times(2)
+      @aa.__send__(:compress?).should be_false
+    end
+  end
+
+  describe "#destroy" do
+    it "should call destroy on the backend object" do
+      backend = mock('backend', :destroy => true)
+      @aa.instance_variable_set(:'@backend', backend)
+      @aa.destroy
+    end
+  end
+
+  describe "when marshal is on" do
+    before do
+      @content = 'mary had a little lamb'
+      stub_backend = stub('backend', :load => Marshal.dump(@content))
+      @aa.stubs(:options).
+        returns({ :storage => 'filesystem', :marshal => true })
+      @aa.__send__(:instance_variable_set, :'@backend', stub_backend)
+    end
+
+    it "should call Marshal.load to restore value" do
+      Marshal.expects(:load)
+      @aa.value
+    end
+
+    it "should call Marshal.dump to save value" do
+      Marshal.expects(:dump)
+      @aa.value = 'foo'
+    end
+
+    it "should retrieve same content string stored in Marshalled form" do
+      @aa.value.should == @content
+    end
+  end
+
+  describe "when gzip is on" do
+    before do
+      @content = "The band formed in 1988 in Oxford"
+      stub_backend = stub('backend', :load => Zlib::Deflate.deflate(@content))
+      @aa.stubs(:options).
+        returns({ :storage => 'filesystem', :compress => true })
+      @aa.__send__(:instance_variable_set, :'@backend', stub_backend)
+    end
+
+    it "should call Zlib::Inflate.inflate to restore value" do
+      Zlib::Inflate.expects(:inflate)
+      @aa.value
+    end
+
+    it "should call Zlib::Deflate.deflate to save value" do
+      Zlib::Deflate.expects(:deflate)
+      @aa.value = 'foo'
+    end
+
+    it "should retrieve same content string stored in gzip form" do
+      @aa.value.should == @content
+    end
+
+    it "should not raise an error with nil content" do
+      lambda {
+        @aa.value = nil
+      }.should_not raise_error
+    end
+  end
+
+  describe "when compress and marshal are on" do
+    before do
+      @content = "The band formed in 1988 in Oxford"
+      stub_backend = stub('backend', :load => Zlib::Deflate.deflate(Marshal.dump(@content)))
+      @aa.stubs(:options).
+        returns({ :storage => 'filesystem', :compress => true, :marshal => true })
+      @aa.__send__(:instance_variable_set, :'@backend', stub_backend)
+    end
+
+    it "should retrieve the same content given" do
+      @aa.value.should == @content
+    end
+  end
+end

data/spec/archived_attributes/backends/filesystem_spec.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__), %w[ .. .. spec_helper ])
+
+require 'tmpdir'
+
+describe ArchivedAttributes::Backends::Filesystem do
+
+  before do
+    @unique_path_part = 'archived_attributes_test'
+    @path = File.join(Dir.tmpdir, @unique_path_part)
+    
+    
+    @instance = stub('http_retrieval',
+      :uuid => '63d3a120-caca-012b-d468-002332d4f91e',
+      :name => :foo
+    )
+
+    aa = ArchivedAttributes::ArchivedAttribute.new(:content, @instance,
+      :filesystem => { :archive_root => @path } )
+    
+    @fs = ArchivedAttributes::Backends::Filesystem.new(aa)
+  end
+
+  it "should write to the correct path" do
+    @fs.__send__(:filepath).should ==
+      File.expand_path(File.join(@path, 'content', @instance.uuid))
+  end
+
+  describe "#save" do    
+    before do
+      if File.exist?(@path)
+        err = <<-EOS
+          Test directory #{@path} already exists.  Please remove it and run the
+          test suite again.
+        EOS
+        raise RuntimeError, err
+      else
+        @remove_path = true
+        FileUtils.mkdir(@path)
+      end
+    end
+
+    it "should call methods to create path and save file to disk" do
+      @fs.save('test')
+      File.exist?(@fs.filename).should be_true
+    end
+    
+    after(:all) do
+      FileUtils.rm_rf(@path) if @remove_path
+    end
+    
+  end
+
+  describe "#destroy" do
+    before do
+      if File.exist?(@path)
+        err = <<-EOS
+          Test directory #{@path} already exists.  Please remove it and run the
+          test suite again.
+        EOS
+        raise RuntimeError, err
+      else
+        @remove_path = true
+        FileUtils.mkdir(@path)
+      end
+    end
+
+    it "should call methods to remove path and file" do
+      @fs.save('test')
+      File.exist?(@fs.filename).should be_true
+
+      @fs.destroy
+      File.exist?(@fs.filename).should be_false
+    end
+
+    after(:all) do
+      FileUtils.rm_rf(@path) if @remove_path
+    end
+
+  end
+
+
+end

data/spec/archived_attributes/backends/s3_spec.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), %w[ .. .. spec_helper ])
+
+describe ArchivedAttributes::Backends::S3 do
+
+  before do
+    @instance = stub('ar_instance', 
+      :uuid => '63d3a120-caca-012b-d468-002332d4f91e',
+      :table_name => 'glorps'
+    )
+    
+    @aa = ArchivedAttributes::ArchivedAttribute.new(:stuff, @instance)
+    @s3 = ArchivedAttributes::Backends::S3.new(@aa)
+    @config = ArchivedAttributes::GlobalConfiguration.instance
+  end
+
+  describe "#initialize" do
+    it "should initialize an s3 object without error" do
+      lambda { ArchivedAttributes::Backends::S3.new(@aa) }.should_not raise_error
+    end
+  end
+
+  describe "#protocol" do
+    it "should be https by default" do
+      @s3.__send__(:protocol).should == "https"
+    end
+
+    it "should use http if specified in the configuration object" do
+      config = { :protocol => 'http' }
+      @s3.instance_variable_set(:"@config", config)
+      
+      @s3.__send__(:protocol).should == "http"
+    end
+
+  end
+
+  describe "#load" do
+    it "should call method to load data from s3" do
+      bucket = mock('bucket')
+      bucket.expects(:get).once
+      aws_s3 = mock('aws_s3')
+      aws_s3.expects(:bucket).returns(bucket)
+      @s3.expects(:key_name).returns('some-key')
+      @s3.expects(:right_aws_s3).returns(aws_s3)
+      @s3.load
+    end
+  end
+
+  describe "#save" do
+    it "should call method to store data in s3" do
+      bucket = mock('bucket')
+      content = 'hey'
+      key = 'fookey'
+      @s3.expects(:key_name).returns(key)
+      bucket.expects(:put).once
+      aws_s3 = mock('aws_s3')
+      aws_s3.expects(:bucket).returns(bucket)
+      @s3.expects(:right_aws_s3).returns(aws_s3)
+      @s3.save(content)
+    end
+  end
+
+  describe "#destroy" do
+    it "should call method to delete key" do
+      key = mock('key', :delete => true)
+      bucket = mock('bucket', :key => key)
+      aws_s3 = mock('aws_s3')
+      aws_s3.expects(:bucket).returns(bucket)
+      @s3.expects(:right_aws_s3).returns(aws_s3)
+      @s3.expects(:key_name).returns('foo-key')
+      @s3.destroy
+    end
+  end
+
+  describe "#bucket_name" do
+    it "should be based on the attribute class and model" do
+      @s3.__send__(:bucket_name).should == @config[:s3]['bucket']
+    end
+  end
+end

data/spec/archived_attributes/global_configuration_spec.rb

@@ -0,0 +1,72 @@
+require File.join(File.dirname(__FILE__), %w[ .. spec_helper ])
+
+describe ArchivedAttributes::GlobalConfiguration do
+  before do
+    @conf = ArchivedAttributes::GlobalConfiguration.instance
+  end
+
+  describe "defaults" do
+    it "should set default marshal value to false" do
+      ArchivedAttributes::GlobalConfiguration::DEFAULTS[:marshal].should == false
+    end
+    
+    it "should set gzip value to false" do
+      ArchivedAttributes::GlobalConfiguration::DEFAULTS[:marshal].should == false
+    end
+  end
+
+  it "should read default access key from the configuration file" do
+    @conf[:s3]['access_key'].should == 'your access key'
+  end
+
+  it "should the default secret key from configuration" do
+    @conf[:s3]['secret_key'].should == 'your secret key'
+  end
+
+  it "should read the default bucket from the configuration file" do
+    @conf[:s3]['bucket'].should == 'test_archived_attributes'
+  end
+
+  describe "#to_s" do
+    it "should return a string" do
+      @conf.to_s.should be_an_instance_of(String)
+    end
+  end
+
+  describe "hash cloning" do
+    it "should be able to alter a Hash without affecting the original object" do
+      conf = @conf.to_hash
+      previous = @conf[:storage]
+      conf[:storage] = 'foo'
+      @conf[:storage].should == previous
+    end
+
+    it "should not affect deeply nested attributes when values are changed" do
+      conf = @conf.to_hash
+      previous = @conf[:s3][:protocol]
+      conf[:s3][:protocol] = 'puddle'
+      @conf[:s3][:protocol].should == previous
+    end
+  end
+
+  describe "#to_hash" do
+    it "should return an instance of Hash" do
+      @conf.to_hash.should be_an_instance_of(HashWithIndifferentAccess)
+    end
+  end
+
+  describe "when an option is not specified in the yaml config file" do
+    it "should have a section for s3 options in hash" do
+      @conf[:s3].should_not be_nil
+    end
+
+    it "should default to https for protocol" do
+      @conf[:s3][:protocol].should == 'https'
+    end
+
+    it "should set default storage attribute to :filesystem" do
+      @conf[:storage].should == 'filesystem'
+    end
+  end
+
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: jsl-archived_attributes
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Justin Leitgeb
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-25 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: right_aws
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: assaf-uuid
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+description: ArchivedAttributes allows for data to be saved to a backend other than the rdbms
+email: justin@phq.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- archived_attributes.gemspec
+- init.rb
+- config/archived_attributes.yml
+- lib/archived_attributes.rb
+- lib/archived_attributes/archived_attribute.rb
+- lib/archived_attributes/global_configuration.rb
+- lib/archived_attributes/backends/s3.rb
+- lib/archived_attributes/backends/filesystem.rb
+has_rdoc: true
+homepage: http://github.com/jsl/archived_attributes
+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.2.0
+signing_key: 
+specification_version: 2
+summary: Rails plugin to save content to a pluggable back-end
+test_files: 
+- spec/archived_attributes/global_configuration_spec.rb
+- spec/archived_attributes/archived_attribute_spec.rb
+- spec/archived_attributes/backends/filesystem_spec.rb
+- spec/archived_attributes/backends/s3_spec.rb