active_capture 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '03486bb96c7c947866d02dbd2a0d3427c81b8ccaea70440ce5ff4463a1905c43'
-  data.tar.gz: ba44f0ab8b7d31f34a9c2470031569514bc5346ad1acbd328a74d2f06ddb7b27
+  metadata.gz: 35e9f57cd205fbbb0ed7e4139101787cb4f66e53a32186b27473f9db72b40498
+  data.tar.gz: ea2747f578ebc4dff315d542b7e6e4cb9193e53e0dd49f2231f37654d39047bc
 SHA512:
-  metadata.gz: e116aa0888362fd7f400bff904af9051a9aaaf60c941bd609008db77940c1007e5f20369ac5490cf918355cb3cfe693677074be0b98500e7346fd60f54fcccee
-  data.tar.gz: d3857c7bea275437fe8af8df3337c33da86bd2dfcc8738faea767c4081934381bfc14d3911c34a500f02d5bee0f219858f493af79b259e27fa2030e190578e6d
+  metadata.gz: f72ad16293a0f39eed9e2471ba7ece51022abdcb6f6005244f25502f7d903eb5054b983a2414fbbeb18c0b1878a93bf674333c71bcd4e4cea57a37df841cc8bf
+  data.tar.gz: c4d02f5b01eb45a1a2e98cd349b4fd3d765a8a4ff27dfe48a57568ac06594431ba501dd69652292776724f548c8528f92b3cd1a613cff5c0a5f22024d4355868

data/lib/active_capture.rb

@@ -1,106 +1,143 @@
-require 'active_capture/version'
-require_relative 'active_capture/capture_storage'
+require 'support/version'
+require_relative 'support/capture_storage'
 require 'json'
 require 'active_record'
 
 module ActiveCapture
-  class Capture
-    def self.take(record, associations: [], name: nil)
-      raise ArgumentError, 'Record must be an ActiveRecord::Base instance' unless record.is_a?(ActiveRecord::Base)
-
-      capture_data = {
-        model: record.class.name,
-        record_id: record.id,
-        attributes: record.attributes,
-        associations: capture_associations(record, associations)
-      }
-
-      CaptureStorage.save_capture(record, capture_data, name)
+  def self.take(record, associations: [], name: nil)
+    validate_record(record)
+
+    capture_data = {
+      model: record.class.name,
+      record_id: record.id,
+      attributes: record.attributes,
+      associations: capture_associations(record, associations)
+    }
+
+    begin
+      Support::CaptureStorage.save_capture(record, capture_data, name)
+    rescue StandardError => e
+      raise "Failed to save capture: #{e.message}"
     end
+  end
 
-    def self.restore(record, capture_file, merge: false)
-      captured_records = CaptureStorage.load_capture(capture_file)
-
-      raise ArgumentError, 'capture file does not match the given record' unless captured_records['record_id'] == record.id
+  def self.restore(record, capture_file, merge: false)
+    captured_records = Support::CaptureStorage.load_capture(capture_file)
+    validate_capture(record, captured_records)
 
-      ActiveRecord::Base.transaction do
+    ActiveRecord::Base.transaction do
+      begin
         record.update!(captured_records['attributes'])
         restore_associations(record, captured_records['associations'], merge: merge)
+      rescue StandardError => e
+        raise "Failed to restore record: #{e.message}"
       end
     end
+  end
 
-    private
+  private
 
-    def self.capture_associations(record, associations)
-      association_data = {}
+  def self.validate_record(record)
+    unless record.is_a?(ActiveRecord::Base)
+      raise ArgumentError, 'Record must be an ActiveRecord::Base instance'
+    end
+  end
+
+  def self.validate_capture(record, captured_records)
+    unless captured_records['record_id'] == record.id
+      raise ArgumentError, 'Capture file does not match the given record'
+    end
+  end
 
-      associations.each do |association|
-        nested_associations = []
+  def self.capture_associations(record, associations)
+    associations.each_with_object({}) do |association, association_data|
+      association_name, nested_associations = parse_association(association)
 
-        if association.is_a?(Hash)
-          association_name = association.keys.first
-          nested_associations = association.values.flatten
-        else
-          association_name = association
-        end
+      next unless record.respond_to?(association_name)
 
-        if record.respond_to?(association_name)
-          related_records = record.send(association_name)
-
-          if related_records.is_a?(ActiveRecord::Base)
-            association_data[association_name] = {
-              attributes: related_records.attributes,
-              associations: capture_associations(related_records, nested_associations)
-            }
-          elsif related_records.respond_to?(:map)
-            association_data[association_name] = related_records.map do |related_record|
-              {
-                attributes: related_record.attributes,
-                associations: capture_associations(related_record, nested_associations)
-              }
-            end
-          end
-        end
+      begin
+        related_records = record.send(association_name)
+        association_data[association_name] = capture_related_records(related_records, nested_associations)
+      rescue StandardError => e
+        raise "Failed to capture association #{association_name}: #{e.message}"
       end
+    end
+  end
 
-      association_data
+  def self.capture_related_records(related_records, nested_associations)
+    if related_records.is_a?(ActiveRecord::Base)
+      {
+        attributes: related_records.attributes,
+        associations: capture_associations(related_records, nested_associations)
+      }
+    elsif related_records.respond_to?(:map)
+      related_records.map do |related_record|
+        {
+          attributes: related_record.attributes,
+          associations: capture_associations(related_record, nested_associations)
+        }
+      end
     end
+  end
 
-    def self.restore_associations(record, associations_data, merge: false)
-      associations_data.each do |association_name, related_data|
-        if related_data.is_a?(Array)
-          associated_class = record.class.reflect_on_association(association_name).klass
-          existing_records = record.send(association_name)
-
-          related_data.each do |related_record_data|
-            if related_record_data['attributes']['id'] && existing_record = existing_records.find_by(id: related_record_data['attributes']['id'])
-              existing_record.update!(related_record_data['attributes'])
-              restore_associations(existing_record, related_record_data['associations'], merge: merge)
-            else
-              new_record = associated_class.create!(related_record_data['attributes'])
-              restore_associations(new_record, related_record_data['associations'], merge: merge)
-            end
-          end
-        else
-          associated_class = record.class.reflect_on_association(association_name).klass
-          if merge && related_data['attributes']['id']
-            existing_record = record.send(association_name)
-
-            if existing_record && existing_record.id == related_data['attributes']['id']
-              existing_record.update!(related_data['attributes'])
-              restore_associations(existing_record, related_data['associations'], merge: merge)
-            else
-              new_record = associated_class.create!(related_data['attributes'])
-              record.update!(association_name => new_record)
-              restore_associations(new_record, related_data['associations'], merge: merge)
-            end
-          else
-            new_record = associated_class.create!(related_data['attributes'])
-            record.update!(association_name => new_record)
-            restore_associations(new_record, related_data['associations'], merge: merge)
-          end
+  def self.parse_association(association)
+    if association.is_a?(Hash)
+      [association.keys.first, association.values.flatten]
+    else
+      [association, []]
+    end
+  end
+
+  def self.restore_associations(record, associations_data, merge: false)
+    associations_data.each do |association_name, related_data|
+      if related_data.is_a?(Array)
+        restore_collection_association(record, association_name, related_data, merge)
+      else
+        restore_single_association(record, association_name, related_data, merge)
+      end
+    end
+  end
+
+  def self.restore_collection_association(record, association_name, related_data, merge)
+    associated_class = record.class.reflect_on_association(association_name).klass
+    existing_records = record.send(association_name)
+
+    related_data.each do |related_record_data|
+      if merge && related_record_data['attributes']['id']
+        existing_record = existing_records.find_by(id: related_record_data['attributes']['id'])
+        if existing_record
+          update_and_restore(existing_record, related_record_data, merge)
+          next
         end
       end
+      create_and_restore(associated_class, related_record_data, record, association_name)
     end
   end
+
+  def self.restore_single_association(record, association_name, related_data, merge)
+    associated_class = record.class.reflect_on_association(association_name).klass
+
+    if merge && related_data['attributes']['id']
+      existing_record = record.send(association_name)
+      if existing_record&.id == related_data['attributes']['id']
+        update_and_restore(existing_record, related_data, merge)
+        return
+      end
+    end
+
+    new_record = create_and_restore(associated_class, related_data)
+    record.update!(association_name => new_record)
+  end
+
+  def self.update_and_restore(record, related_data, merge)
+    record.update!(related_data['attributes'])
+    restore_associations(record, related_data['associations'], merge: merge)
+  end
+
+  def self.create_and_restore(associated_class, related_data, parent_record = nil, association_name = nil)
+    new_record = associated_class.create!(related_data['attributes'])
+    restore_associations(new_record, related_data['associations'], merge: false)
+    parent_record&.update!(association_name => new_record) if association_name
+    new_record
+  end
 end

data/lib/support/capture_storage.rb

@@ -0,0 +1,151 @@
+require 'json'
+require 'fileutils'
+require 'pathname'
+
+module Support
+  class CaptureStorage
+    CAPTURE_DIR = 'captures'.freeze
+    MAX_FILENAME_LENGTH = 100
+    VALID_FILENAME_REGEX = /\A[a-zA-Z0-9\-_\.]+\z/
+
+    class << self
+      def save_capture(record, capture_data, name = nil)
+        validate_record(record)
+        validate_capture_data(capture_data)
+        
+        file_name = generate_filename(record, name)
+        dir_path = create_capture_directory(record)
+        file_path = File.join(dir_path, file_name)
+
+        write_capture_file(file_path, capture_data)
+        
+        { success: true, file_path: file_path }
+      rescue => e
+        { success: false, error: e.message }
+      end
+
+      def load_capture(capture_file)
+        validate_file_path(capture_file)
+        
+        file_content = read_file_safely(capture_file)
+        parsed_data = JSON.parse(file_content)
+        
+        validate_parsed_data(parsed_data)
+        
+        parsed_data
+      rescue => e
+        raise StorageError, "Failed to load capture: #{e.message}"
+      end
+
+      private
+
+      def validate_record(record)
+        unless record.respond_to?(:class) && record.respond_to?(:id)
+          raise ArgumentError, "Invalid record: must respond to :class and :id"
+        end
+
+        if record.id.nil?
+          raise ArgumentError, "Cannot capture unsaved record (ID is nil)"
+        end
+      end
+
+      def validate_capture_data(data)
+        unless data.is_a?(Hash)
+          raise ArgumentError, "Capture data must be a Hash"
+        end
+
+        required_keys = [:model, :record_id, :attributes]
+        missing_keys = required_keys.reject { |k| data.key?(k) }
+        unless missing_keys.empty?
+          raise ArgumentError, "Missing required keys in capture data: #{missing_keys.join(', ')}"
+        end
+      end
+
+      def generate_filename(record, custom_name)
+        model_name = record.class.name.downcase.gsub(/[^a-z0-9]/, '_')
+        record_id = record.id.to_s
+        timestamp = Time.now.strftime('%Y%m%d%H%M%S')
+
+        if custom_name
+          validate_filename(custom_name)
+          base_name = custom_name.gsub(/\s+/, '_')[0..MAX_FILENAME_LENGTH]
+          "#{base_name}.json"
+        else
+          "#{model_name}_#{record_id}_#{timestamp}.json"
+        end
+      end
+
+      def validate_filename(name)
+        if name.empty?
+          raise ArgumentError, "Filename cannot be empty"
+        end
+
+        if name.length > MAX_FILENAME_LENGTH
+          raise ArgumentError, "Filename too long (max #{MAX_FILENAME_LENGTH} chars)"
+        end
+
+        unless name.match(VALID_FILENAME_REGEX)
+          raise ArgumentError, "Filename contains invalid characters"
+        end
+      end
+
+      def create_capture_directory(record)
+        model_name = record.class.name.downcase.gsub(/[^a-z0-9]/, '_')
+        dir_path = File.join(CAPTURE_DIR, model_name)
+
+        begin
+          FileUtils.mkdir_p(dir_path)
+        rescue SystemCallError => e
+          raise StorageError, "Failed to create directory '#{dir_path}': #{e.message}"
+        end
+
+        dir_path
+      end
+
+      def write_capture_file(file_path, data)
+        begin
+          temp_path = "#{file_path}.tmp"
+          File.write(temp_path, JSON.pretty_generate(data))
+          File.rename(temp_path, file_path)
+        rescue SystemCallError => e
+          File.delete(temp_path) if File.exist?(temp_path)
+          raise StorageError, "Failed to write capture file '#{file_path}': #{e.message}"
+        end
+      end
+
+      def validate_file_path(file_path)
+        unless File.exist?(file_path)
+          raise StorageError, "File does not exist: #{file_path}"
+        end
+
+        unless File.readable?(file_path)
+          raise StorageError, "No read permission for file: #{file_path}"
+        end
+
+        if File.directory?(file_path)
+          raise StorageError, "Path is a directory, not a file: #{file_path}"
+        end
+      end
+
+      def read_file_safely(file_path)
+        File.read(file_path)
+      rescue SystemCallError => e
+        raise StorageError, "Failed to read file '#{file_path}': #{e.message}"
+      end
+
+      def validate_parsed_data(data)
+        unless data.is_a?(Hash)
+          raise StorageError, "Invalid capture format: expected JSON object"
+        end
+
+        required_keys = ['model', 'record_id', 'attributes']
+        missing_keys = required_keys.reject { |k| data.key?(k) }
+        unless missing_keys.empty?
+          raise StorageError, "Invalid capture data: missing keys #{missing_keys.join(', ')}"
+        end
+      end
+    end
+
+    class StorageError < StandardError; end
+  end
+end

data/lib/support/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Support
+  VERSION = "1.1.1"
+end

data/test/support/test_capture_storage.rb

@@ -0,0 +1,155 @@
+require 'test_helper'
+require 'minitest/autorun'
+require 'fileutils'
+
+# Define our test classes at the top level
+class TestModel; end
+class NewModel; end
+class ProtectedModel; end
+
+class CaptureStorageTest < Minitest::Test
+  # Simple test record class that mimics ActiveRecord::Base
+  class TestRecord
+    attr_reader :id
+
+    def initialize(id, class_name)
+      @id = id
+      @class_name = class_name
+    end
+
+    def class
+      @class_name.constantize
+    end
+  end
+
+  def setup
+    # Create test data directory
+    @test_dir = 'test_data'
+    FileUtils.mkdir_p(@test_dir)
+
+    # Create sample capture data
+    @sample_data = {
+      model: 'TestModel',
+      record_id: 1,
+      attributes: { name: 'Test', value: 42 },
+      associations: {
+        comments: [
+          { attributes: { id: 1, content: 'First comment' } },
+          { attributes: { id: 2, content: 'Second comment' } }
+        ]
+      }
+    }
+
+    # Create test files
+    @valid_file = "#{@test_dir}/valid.json"
+    File.write(@valid_file, JSON.generate(@sample_data))
+
+    @invalid_json_file = "#{@test_dir}/invalid.json"
+    File.write(@invalid_json_file, 'not valid json')
+
+    @empty_file = "#{@test_dir}/empty.json"
+    File.write(@empty_file, '')
+
+    # Clear captures directory before each test
+    FileUtils.rm_rf(Support::CaptureStorage::CAPTURE_DIR) if File.directory?(Support::CaptureStorage::CAPTURE_DIR)
+  end
+
+  def teardown
+    # Clean up test files
+    FileUtils.rm_rf(@test_dir)
+    FileUtils.rm_rf(Support::CaptureStorage::CAPTURE_DIR)
+  end
+
+  def test_save_capture_creates_valid_file
+    test_record = TestRecord.new(1, 'TestModel')
+    result = Support::CaptureStorage.save_capture(test_record, @sample_data)
+
+    assert result[:success], "Save should succeed: #{result[:error]}"
+    assert File.exist?(result[:file_path]), "File should exist at #{result[:file_path]}"
+
+    file_content = JSON.parse(File.read(result[:file_path]))
+    assert_equal 'TestModel', file_content['model']
+    assert_equal 1, file_content['record_id']
+  end
+
+  def test_save_capture_with_custom_name
+    test_record = TestRecord.new(1, 'TestModel')
+    custom_name = 'custom_capture'
+    result = Support::CaptureStorage.save_capture(test_record, @sample_data, custom_name)
+
+    assert result[:success], "Save should succeed: #{result[:error]}"
+    assert_match /#{custom_name}\.json/, result[:file_path]
+    assert File.exist?(result[:file_path]), "File should exist at #{result[:file_path]}"
+  end
+
+  def test_save_capture_invalid_filename
+    test_record = TestRecord.new(1, 'TestModel')
+    result = Support::CaptureStorage.save_capture(test_record, @sample_data, 'invalid/name')
+
+    refute result[:success], "Save should fail with invalid filename"
+    assert_match /Filename contains invalid characters/, result[:error], "Error should mention invalid filename"
+  end
+
+  def test_load_capture_valid_file
+    data = Support::CaptureStorage.load_capture(@valid_file)
+
+    assert_equal 'TestModel', data['model']
+    assert_equal 1, data['record_id']
+    assert_equal 2, data['associations']['comments'].size
+  end
+
+  def test_load_capture_nonexistent_file
+    assert_raises Support::CaptureStorage::StorageError do
+      Support::CaptureStorage.load_capture('nonexistent.json')
+    end
+  end
+
+  def test_load_capture_invalid_json
+    assert_raises Support::CaptureStorage::StorageError do
+      Support::CaptureStorage.load_capture(@invalid_json_file)
+    end
+  end
+
+  def test_load_capture_empty_file
+    assert_raises Support::CaptureStorage::StorageError do
+      Support::CaptureStorage.load_capture(@empty_file)
+    end
+  end
+
+  def test_load_capture_missing_required_keys
+    incomplete_data = { 'some_key' => 'some_value' }
+    incomplete_file = "#{@test_dir}/incomplete.json"
+    File.write(incomplete_file, JSON.generate(incomplete_data))
+
+    assert_raises Support::CaptureStorage::StorageError do
+      Support::CaptureStorage.load_capture(incomplete_file)
+    end
+  end
+
+  def test_atomic_write_handles_failure
+    # Create a directory we can't write to
+    protected_dir = "#{@test_dir}/protected"
+    FileUtils.mkdir_p(protected_dir)
+    FileUtils.chmod(0444, protected_dir) # read-only
+
+    test_record = TestRecord.new(1, 'ProtectedModel')
+    file_path = "#{protected_dir}/test.json"
+
+    assert_raises Support::CaptureStorage::StorageError do
+      Support::CaptureStorage.send(:write_capture_file, file_path, @sample_data)
+    end
+
+    # Verify no temp file remains
+    refute File.exist?("#{file_path}.tmp")
+  ensure
+    FileUtils.chmod(0755, protected_dir) if File.exist?(protected_dir)
+  end
+
+  def test_directory_creation
+    test_record = TestRecord.new(1, 'NewModel')
+    result = Support::CaptureStorage.save_capture(test_record, @sample_data)
+
+    assert result[:success], "Save should succeed: #{result[:error]}"
+    assert File.directory?('captures/newmodel'), "Directory should be created"
+  end
+end

data/test/test_active_capture.rb

@@ -2,6 +2,7 @@ require 'test_helper'
 require 'minitest/autorun'
 
 class ActiveCaptureTest < Minitest::Test
+  # Setup method to initialize test data before each test
   def setup
     @user = User.create!(name: "John Doe", email: "john@example.com")
     @post = @user.posts.create!(title: "First Post", content: "This is my first post.")
@@ -9,29 +10,50 @@ class ActiveCaptureTest < Minitest::Test
     @comment2 = @post.comments.create!(content: "Thanks for sharing.")
   end
 
+  # Teardown method to clean up after each test
+  def teardown
+    FileUtils.rm_rf('captures/')
+  end
+
+  # Test capturing a user with associated posts and comments
   def test_capture_with_associations
-    ActiveCapture::Capture.take(@user, associations: [:posts, { posts: :comments }])
+    # Take a capture of the user and their associations
+    ActiveCapture.take(@user, associations: [:posts, { posts: :comments }])
 
+    # Verify that capture files are created
     capture_files = Dir["captures/user/*.json"]
     assert !capture_files.empty?, "capture file should be created"
 
+    # Verify the content of the capture file
     capture_content = JSON.parse(File.read(capture_files.last))
     assert_equal 1, capture_content["associations"]["posts"].size
     assert_equal 2, capture_content["associations"]["posts"].first["associations"]["comments"].size
   end
 
+  # Test restoring a user with merge functionality
   def test_restore_with_merge
-    ActiveCapture::Capture.take(@user, associations: [:posts, { posts: :comments }])
+    # Take a capture of the user and their associations
+    ActiveCapture.take(@user, associations: [:posts, { posts: :comments }])
     capture_file = Dir["captures/user/*.json"].last
+
+    # Modify the post and add a new comment
     @post.update(title: "updated title")
     new_comment = @post.comments.create!(content: "Another comment")
-    ActiveCapture::Capture.restore(@user, capture_file, merge: true)
 
+    # Restore the user from the capture file with merge enabled
+    ActiveCapture.restore(@user, capture_file, merge: true)
+
+    # Reload the user and post to verify changes
     @user.reload
     @post.reload
 
+    # Verify that the user's name is restored
     assert_equal "John Doe", @user.name
+
+    # Verify that the post's title is restored
     assert_equal "First Post", @post.title
+
+    # Verify that the new comment still exists after the merge
     assert_equal 3, @post.comments.count
     assert @post.comments.exists?(new_comment.id), "New comment should still exist after merge"
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_capture
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Tanmay Bhawsar
@@ -32,8 +32,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/active_capture.rb
-- lib/active_capture/capture_storage.rb
-- lib/active_capture/version.rb
+- lib/support/capture_storage.rb
+- lib/support/version.rb
+- test/support/test_capture_storage.rb
 - test/test_active_capture.rb
 - test/test_helper.rb
 homepage: https://github.com/bhawsartanmay/active_capture

data/lib/active_capture/capture_storage.rb

@@ -1,29 +0,0 @@
-require 'json'
-require 'fileutils'
-
-module ActiveCapture
-  class CaptureStorage
-    CAPTURE_DIR = 'captures'
-
-    def self.save_capture(record, capture_data, name = nil)
-      model_name = record.class.name.downcase
-      record_id = record.id
-      timestamp = Time.now.strftime('%Y%m%d%H%M%S')
-      file_name = name ? "#{name}.json" : "#{record_id}_#{timestamp}.json"
-
-      dir_path = File.join(CAPTURE_DIR, model_name)
-      FileUtils.mkdir_p(dir_path)
-
-      file_path = File.join(dir_path, file_name)
-      File.write(file_path, JSON.pretty_generate(capture_data))
-
-      puts "Capture saved to #{file_path}"
-    end
-
-    def self.load_capture(capture_file)
-      raise ArgumentError, "Capture file does not exist #{capture_file}" unless File.exist?(capture_file)
-
-      JSON.parse(File.read(capture_file))
-    end
-  end
-end

data/lib/active_capture/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveCapture
-  VERSION = "1.1.0"
-end