frozen_record 0.13.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a2caf0ce8ea29240d70604b68d7e1edeaa8b331c
-  data.tar.gz: 4ccec1e2b69e9a882d48cbbad9df73c9732b5fae
+SHA256:
+  metadata.gz: a47352d34eb964f32bf8d253cffe682abc221f80db5782ed7dce6aee76967661
+  data.tar.gz: ea62e1c1bcc0cf927a2614f2fb4cfc1acbb6780cdfec273a44dbbe1bd14a55e2
 SHA512:
-  metadata.gz: 62e573bedb84600e916de3784e764eeb9400555c8f11118dc27787ef7f642f15e927a6e304e96e118eb8c1f3317c57613c1bd395fc6330d2b59ad36d014c653c
-  data.tar.gz: c225c4584ee248a86cd88e5f888618745d6275fdd27582a47fbedf405095d521c16a7d8484c6866b1c4ce2e618d921a772b0d45335253f4b50d3bc4c1a2d385a
+  metadata.gz: 33f76d7869d6a1e8a9cae954b074fa93cb89ffa3fcee9bc170d3e23b5ee2fcb39164a7e9de0b0f1570588bd7919d88b288bb35bc9c965cb32b77e3e9c6b5928a
+  data.tar.gz: e38977cfbdb6136aed4042060e130bc260f6e33c8db9c876f05f832d65037ba504fe7119a5b338c62e9a17391b2d1472ab2e2de5df5ae2c90b72772bd0599cd8

data/.travis.yml

@@ -1,5 +1,5 @@
 sudo: false
 rvm:
-  - '2.4.5'
-  - '2.5.3'
-  - '2.6.1'
+  - '2.5'
+  - '2.6'
+  - '2.7'

data/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
+gem 'benchmark-ips'
+gem 'byebug'
 gemspec

data/README.md

@@ -50,7 +50,7 @@ but this option can be changed per model:
 
 ```ruby
 class Country < FrozenRecord::Base
-  self.backend = FrozenRecord::Backends::Yaml
+  self.backend = FrozenRecord::Backends::Json
 end
 ```
 
@@ -60,7 +60,7 @@ A custom backend must implement the methods `filename` and `load` as follows:
 
 ```ruby
 module MyCustomBackend
-  extend  self
+  extend self
 
   def filename(model_name)
     # Returns the file name as a String
@@ -95,10 +95,12 @@ Country.
 
 ### Scopes
 
-While the `scope :symbol, lambda` syntax is not supported, the class methods way is:
+Basic `scope :symbol, lambda` syntax is now supported in addition to class method syntax.
 
 ```ruby
 class Country
+  scope :european, -> { where(continent: 'Europe' ) }
+
   def self.republics
     where(king: nil)
   end
@@ -108,7 +110,7 @@ class Country
   end
 end
 
-Country.republics.part_of_nato.order(id: :desc)
+Country.european.republics.part_of_nato.order(id: :desc)
 ```
 
 ### Supported query methods
@@ -181,7 +183,7 @@ class CountryTest < ActiveSupport::TestCase
   teardown do
     FrozenRecord::TestHelper.unload_fixtures
   end
-  
+
   test "countries have a valid name" do
   # ...
 ```

data/benchmark/attribute-read

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative 'setup'
+
+regular = Country.first
+compact = Compact::Country.first
+
+
+puts "=== record.attribute ==="
+Benchmark.ips do |x|
+  x.report('regular') { regular.name }
+  x.report('compact') { compact.name }
+  x.compare!
+end
+
+puts "=== record[:attribute] ==="
+Benchmark.ips do |x|
+  x.report('regular') { regular[:name] }
+  x.report('compact') { compact[:name] }
+  x.compare!
+end

data/benchmark/memory-usage

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative 'setup'
+
+puts "regular: #{Country.memsize} bytes"
+puts "compact: #{Compact::Country.memsize} bytes"
+
+diff = (Compact::Country.memsize - Country.memsize).to_f / Country.memsize
+puts "diff: #{(diff * 100).round(2)}%"

data/benchmark/setup.rb

@@ -0,0 +1,6 @@
+require 'bundler/setup'
+require 'benchmark/ips'
+
+require 'frozen_record'
+require_relative '../spec/support/country'
+FrozenRecord::Base.base_path = File.expand_path('../spec/fixtures', __dir__)

data/frozen_record.gemspec

@@ -17,6 +17,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
+  spec.required_ruby_version = '>= 2.5'
+
   spec.add_runtime_dependency 'activemodel'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'

data/lib/frozen_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'set'
 require 'active_support/all'
@@ -6,13 +8,21 @@ require 'active_model'
 require 'frozen_record/version'
 require 'frozen_record/scope'
 require 'frozen_record/base'
+require 'frozen_record/compact'
+require 'frozen_record/deduplication'
 
 module FrozenRecord
   RecordNotFound = Class.new(StandardError)
 
   class << self
+    attr_accessor :deprecated_yaml_erb_backend
+
     def eager_load!
       Base.descendants.each(&:eager_load!)
     end
   end
+
+  self.deprecated_yaml_erb_backend = true
 end
+
+require 'frozen_record/railtie' if defined?(Rails)

data/lib/frozen_record/backends.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module FrozenRecord
+  module Backends
+    autoload :Json, 'frozen_record/backends/json'
+    autoload :Yaml, 'frozen_record/backends/yaml'
+  end
+end

data/lib/frozen_record/backends/json.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module FrozenRecord
+  module Backends
+    module Json
+      extend self
+
+      def filename(model_name)
+        "#{model_name.underscore.pluralize}.json"
+      end
+
+      def load(file_path)
+        json_data = File.read(file_path)
+        JSON.parse(json_data) || []
+      end
+    end
+  end
+end

data/lib/frozen_record/backends/yaml.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FrozenRecord
   module Backends
     module Yaml
@@ -17,10 +19,29 @@ module FrozenRecord
       # @param format [String] the file path
       # @return [Array] an Array of Hash objects with keys being attributes.
       def load(file_path)
-        yml_erb_data = File.read(file_path)
-        yml_data = ERB.new(yml_erb_data).result
+        if !File.exist?(file_path) && File.exist?("#{file_path}.erb")
+          file_path = "#{file_path}.erb"
+        end
+
+        if FrozenRecord.deprecated_yaml_erb_backend
+          yml_erb_data = File.read(file_path)
+          yml_data = ERB.new(yml_erb_data).result
+
+          unless file_path.end_with?('.erb')
+            if yml_data != yml_erb_data
+              basename = File.basename(file_path)
+              raise "[FrozenRecord] Deprecated: `#{basename}` contains ERB tags and should be renamed `#{basename}.erb`.\nSet FrozenRecord.deprecated_yaml_erb_backend = false to enable the future behavior"
+            end
+          end
 
-        YAML.load(yml_data) || []
+          YAML.load(yml_data) || []
+        else
+          if file_path.end_with?('.erb')
+            YAML.load(ERB.new(File.read(file_path)).result) || []
+          else
+            YAML.load_file(file_path) || []
+          end
+        end
       end
     end
   end

data/lib/frozen_record/base.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require 'set'
 require 'active_support/descendants_tracker'
-require 'frozen_record/backends/yaml'
+require 'frozen_record/backends'
+require 'objspace'
 
 module FrozenRecord
   class Base
@@ -15,19 +18,15 @@ module FrozenRecord
     end
 
     FIND_BY_PATTERN = /\Afind_by_(\w+)(!?)/
-    FALSY_VALUES = [false, nil, 0, ''].to_set
+    FALSY_VALUES = [false, nil, 0, -''].to_set
 
-    class_attribute :base_path
+    class_attribute :base_path, :primary_key, :backend, :auto_reloading, :default_attributes, instance_accessor: false
 
-    class_attribute :primary_key
-    self.primary_key = :id
+    self.primary_key = 'id'
 
-    class_attribute :backend
     self.backend = FrozenRecord::Backends::Yaml
 
-    class_attribute :auto_reloading
-
-    attribute_method_suffix '?'
+    attribute_method_suffix -'?'
 
     class ThreadSafeStorage
 
@@ -48,8 +47,34 @@ module FrozenRecord
     end
 
     class << self
+      alias_method :set_default_attributes, :default_attributes=
+      private :set_default_attributes
+      def default_attributes=(default_attributes)
+        set_default_attributes(Deduplication.deep_deduplicate!(default_attributes.stringify_keys))
+      end
+
+      alias_method :set_primary_key, :primary_key=
+      private :set_primary_key
+      def primary_key=(primary_key)
+        set_primary_key(-primary_key.to_s)
+      end
+
+      alias_method :set_base_path, :base_path=
+      private :set_base_path
+      def base_path=(base_path)
+       @file_path = nil
+       set_base_path(base_path)
+      end
+
       attr_accessor :abstract_class
 
+      def attributes
+        @attributes ||= begin
+          load_records
+          @attributes
+        end
+      end
+
       def abstract_class?
         defined?(@abstract_class) && @abstract_class
       end
@@ -68,11 +93,33 @@ module FrozenRecord
 
       def file_path
         raise ArgumentError, "You must define `#{name}.base_path`" unless base_path
-        File.join(base_path, backend.filename(name))
+        @file_path ||= begin
+          file_path = File.join(base_path, backend.filename(name))
+          if !File.exist?(file_path) && File.exist?("#{file_path}.erb")
+            "#{file_path}.erb"
+          else
+            file_path
+          end
+        end
+      end
+
+      def memsize(object = self, seen = Set.new.compare_by_identity)
+        return 0 unless seen.add?(object)
+
+        size = ObjectSpace.memsize_of(object)
+        object.instance_variables.each { |v| size += memsize(object.instance_variable_get(v), seen) }
+
+        case object
+        when Hash
+          object.each { |k, v| size += memsize(k, seen) + memsize(v, seen) }
+        when Array
+          object.each { |i| size += memsize(i, seen) }
+        end
+        size
       end
 
       def respond_to_missing?(name, *)
-        if name =~ FIND_BY_PATTERN
+        if name.to_s =~ FIND_BY_PATTERN
           load_records # ensure attribute methods are defined
           return true if $1.split('_and_').all? { |attr| instance_method_already_implemented?(attr) }
         end
@@ -92,12 +139,26 @@ module FrozenRecord
 
         @records ||= begin
           records = backend.load(file_path)
-          define_attribute_methods(list_attributes(records))
-          records.map do |attributes|
-            attributes.symbolize_keys!
-            new(attributes)
-          end.freeze
+          records.each { |r| assign_defaults!(r) }
+          records = Deduplication.deep_deduplicate!(records)
+          @attributes = list_attributes(records).freeze
+          define_attribute_methods(@attributes.to_a)
+          records.map { |r| load(r) }.freeze
+        end
+      end
+
+      def scope(name, body)
+        unless body.respond_to?(:call)
+          raise ArgumentError, "The scope body needs to be callable."
         end
+        singleton_class.send(:define_method, name) { |*args| body.call(*args) }
+      end
+
+      alias_method :load, :new
+      private :load
+
+      def new(attrs = {})
+        load(assign_defaults!(attrs.stringify_keys))
       end
 
       private
@@ -112,45 +173,54 @@ module FrozenRecord
         @store ||= ThreadSafeStorage.new(name)
       end
 
+      def assign_defaults!(record)
+        if default_attributes
+          default_attributes.each do |key, value|
+            unless record.key?(key)
+              record[key] = value
+            end
+          end
+        end
+
+        record
+      end
+
       def method_missing(name, *args)
-        if name =~ FIND_BY_PATTERN
+        if name.to_s =~ FIND_BY_PATTERN
           return dynamic_match($1, args, $2.present?)
         end
         super
       end
 
       def dynamic_match(expression, values, bang)
-        results = where(expression.split('_and_').zip(values))
+        results = where(expression.split('_and_'.freeze).zip(values))
         bang ? results.first! : results.first
       end
 
       def list_attributes(records)
         attributes = Set.new
         records.each do |record|
-          record.keys.each do |key|
-            attributes.add(key.to_sym)
-          end
+          attributes.merge(record.keys)
         end
-        attributes.to_a
+        attributes
       end
 
     end
 
     def initialize(attrs = {})
-      @attributes = attrs
+      @attributes = attrs.freeze
     end
 
     def attributes
-      # We have to return a hash with string keys for backward compatibity reasons
-      @attributes.stringify_keys
+      @attributes.dup
     end
 
     def id
-      self[primary_key]
+      self[self.class.primary_key]
     end
 
     def [](attr)
-      @attributes[attr.to_sym]
+      @attributes[attr.to_s]
     end
     alias_method :attribute, :[]
 
@@ -169,9 +239,11 @@ module FrozenRecord
     private
 
     def attribute?(attribute_name)
-      value = self[attribute_name]
-      FALSY_VALUES.exclude?(value) && value.present?
+      FALSY_VALUES.exclude?(self[attribute_name]) && self[attribute_name].present?
     end
 
+    def attribute_method?(attribute_name)
+      respond_to_without_attributes?(:attributes) && self.class.attributes.include?(attribute_name)
+    end
   end
 end

data/lib/frozen_record/compact.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module FrozenRecord
+  module Compact
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def load_records(force: false)
+        if force || (auto_reloading && file_changed?)
+          @records = nil
+          undefine_attribute_methods
+        end
+
+        @records ||= begin
+          records = backend.load(file_path)
+          records.each { |r| assign_defaults!(r) }
+          records = Deduplication.deep_deduplicate!(records)
+          @attributes = list_attributes(records).freeze
+          build_attributes_cache
+          define_attribute_methods(@attributes.to_a)
+          records.map { |r| load(r) }.freeze
+        end
+      end
+
+      if ActiveModel.gem_version >= Gem::Version.new('6.1.0.alpha')
+        def define_method_attribute(attr, owner:)
+          owner << "attr_reader #{attr.inspect}"
+        end
+      else
+        def define_method_attribute(attr)
+          generated_attribute_methods.attr_reader(attr)
+        end
+      end
+
+      attr_reader :_attributes_cache
+
+      private
+
+      def build_attributes_cache
+        @_attributes_cache = @attributes.each_with_object({}) do |attr, cache|
+          var = :"@#{attr}"
+          cache[attr.to_s] = var
+          cache[attr.to_sym] = var
+        end
+      end
+    end
+
+    def initialize(attrs = {})
+      self.attributes = attrs
+    end
+
+    def attributes
+      self.class.attributes.each_with_object({}) do |attr, hash|
+        hash[attr] = self[attr]
+      end
+    end
+
+    def [](attr)
+      if var = self.class._attributes_cache[attr]
+        instance_variable_get(var)
+      end
+    end
+
+    private
+
+    def attributes=(attributes)
+      self.class.attributes.each do |attr|
+        instance_variable_set(self.class._attributes_cache[attr], Deduplication.deep_deduplicate!(attributes[attr]))
+      end
+    end
+
+    def attribute?(attribute_name)
+      val = self[attribute_name]
+      Base::FALSY_VALUES.exclude?(val) && val.present?
+    end
+  end
+end

data/lib/frozen_record/deduplication.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/duplicable'
+
+module FrozenRecord
+  module Deduplication
+    extend self
+
+    # We deduplicate data in place because it is assumed it directly
+    # comes from the parser, and won't be held by anyone.
+    #
+    # Frozen Hashes and Arrays are ignored because they are likely
+    # the result of the use of YAML anchor. Meaning we already deduplicated
+    # them.
+    if RUBY_VERSION >= '2.7'
+      def deep_deduplicate!(data)
+        case data
+        when Hash
+          return data if data.frozen?
+          data.transform_keys! { |k| deep_deduplicate!(k) }
+          data.transform_values! { |v| deep_deduplicate!(v) }
+          data.freeze
+        when Array
+          return data if data.frozen?
+          data.map! { |d| deep_deduplicate!(d) }.freeze
+        when String
+          -data
+        else
+          data.duplicable? ? data.freeze : data
+        end
+      end
+    else
+      def deep_deduplicate!(data)
+        case data
+        when Hash
+          return data if data.frozen?
+          data.transform_keys! { |k| deep_deduplicate!(k) }
+          data.transform_values! { |v| deep_deduplicate!(v) }
+          data.freeze
+        when Array
+          return data if data.frozen?
+          data.map! { |d| deep_deduplicate!(d) }.freeze
+        when String
+          # String#-@ doesn't deduplicate the string if it's tainted.
+          # So in such case we need to untaint it first.
+          if data.tainted?
+            -(+data).untaint
+          else
+            -data
+          end
+        else
+          data.duplicable? ? data.freeze : data
+        end
+      end
+    end
+  end
+end

data/lib/frozen_record/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module FrozenRecord
+  class Railtie < Rails::Railtie
+    initializer "frozen_record.setup" do |app|
+      app.config.eager_load_namespaces << FrozenRecord
+    end
+  end
+end

data/lib/frozen_record/scope.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FrozenRecord
   class Scope
     BLACKLISTED_ARRAY_METHODS = [
@@ -62,7 +64,7 @@ module FrozenRecord
     def pluck(*attributes)
       case attributes.length
       when 1
-        to_a.map(&attributes.first)
+        to_a.map(&attributes.first.to_sym)
       when 0
         raise NotImplementedError, '`.pluck` without arguments is not supported yet'
       else
@@ -122,8 +124,28 @@ module FrozenRecord
       array_delegable?(method_name) || @klass.respond_to?(method_name) || super
     end
 
+    def hash
+      comparable_attributes.hash
+    end
+
+    def ==(other)
+      self.class === other &&
+      comparable_attributes == other.comparable_attributes
+    end
+
     protected
 
+    def comparable_attributes
+      @comparable_attributes ||= {
+        klass: @klass,
+        where_values: @where_values.uniq.sort,
+        where_not_values: @where_not_values.uniq.sort,
+        order_values: @order_values.uniq,
+        limit: @limit,
+        offset: @offset,
+      }
+    end
+
     def scoping
       previous, @klass.current_scope = @klass.current_scope, self
       yield
@@ -136,6 +158,7 @@ module FrozenRecord
     end
 
     def clear_cache!
+      @comparable_attributes = nil
       @results = nil
       @matches = nil
       self
@@ -230,6 +253,7 @@ module FrozenRecord
     end
 
     private
+
     def compare_value(actual, requested)
       return actual == requested unless requested.is_a?(Array) || requested.is_a?(Range)
       requested.include?(actual)

data/lib/frozen_record/test_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FrozenRecord
   module TestHelper
     NoFixturesLoaded = Class.new(StandardError)

data/lib/frozen_record/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FrozenRecord
-  VERSION = '0.13.0'
+  VERSION = '0.18.0'
 end

data/spec/deduplication_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe 'deduplication' do
+
+  it 'deduplicate string values' do
+    pending("Strings can't be deduplicated before Ruby 2.5") if RUBY_VERSION < '2.5'
+
+    records = [
+      { 'name' => 'George'.dup },
+    ]
+
+    expect(records[0]['name']).to_not equal 'George'.freeze
+    FrozenRecord::Deduplication.deep_deduplicate!(records)
+    expect(records[0]['name']).to equal 'George'.freeze
+  end
+
+  it 'handles duplicated references' do
+    # This simulates the YAML anchor behavior
+    tags = { 'foo' => 'bar' }
+    records = [
+      { 'name' => 'George', 'tags' => tags },
+      { 'name' => 'Peter', 'tags' => tags },
+    ]
+
+    expect(records[0]['tags']).to_not be_frozen
+    FrozenRecord::Deduplication.deep_deduplicate!(records)
+    expect(records[0]['tags']).to be_frozen
+    expect(records[0]['tags']).to equal records[1]['tags']
+  end
+
+end

data/spec/fixtures/{countries.yml → countries.yml.erb}

@@ -8,6 +8,7 @@
   updated_at: 2014-02-24T19:08:06-05:00
   nato: true
   king: Elisabeth II
+  continent: North America
 
 - id: 2
   name: France
@@ -16,6 +17,8 @@
   population: 65.7
   founded_on: 486-01-01
   updated_at: 2014-02-12T19:02:03-02:00
+  nato: true
+  continent: Europe
 
 - id: 3
   name: Austria
@@ -24,3 +27,5 @@
   population: 8.462
   founded_on: 1156-01-01
   updated_at: 2014-02-12T19:02:03-02:00
+  continent: Europe
+  available: false

data/spec/frozen_record_spec.rb

@@ -1,14 +1,21 @@
 require 'spec_helper'
 
-describe FrozenRecord::Base do
+RSpec.shared_examples 'main' do
 
-  describe '.base_path' do
+  describe '.primary_key' do
 
-    it 'raise a RuntimeError on first query attempt if not set' do
-      allow(Country).to receive_message_chain(:base_path).and_return(nil)
-      expect {
-        Country.file_path
-      }.to raise_error(ArgumentError)
+    around do |example|
+      previous_primary_key = country_model.primary_key
+      begin
+        example.run
+      ensure
+        country_model.primary_key = previous_primary_key
+      end
+    end
+
+    it 'is coerced to string' do
+      country_model.primary_key = :foobar
+      expect(country_model.primary_key).to be == 'foobar'
     end
 
   end
@@ -18,24 +25,24 @@ describe FrozenRecord::Base do
     context 'when enabled' do
 
       around do |example|
-        previous_auto_reloading = Country.auto_reloading
-        Country.auto_reloading = true
+        previous_auto_reloading = country_model.auto_reloading
+        country_model.auto_reloading = true
         begin
           example.run
         ensure
-          Country.auto_reloading = previous_auto_reloading
+          country_model.auto_reloading = previous_auto_reloading
         end
       end
 
       it 'reloads the records if the file mtime changed' do
-        mtime = File.mtime(Country.file_path)
+        mtime = File.mtime(country_model.file_path)
         expect {
-          File.utime(mtime + 1, mtime + 1, Country.file_path)
-        }.to change { Country.first.object_id }
+          File.utime(mtime + 1, mtime + 1, country_model.file_path)
+        }.to change { country_model.first.object_id }
       end
 
       it 'does not reload if the file has not changed' do
-        expect(Country.first.object_id).to be == Country.first.object_id
+        expect(country_model.first.object_id).to be == country_model.first.object_id
       end
 
     end
@@ -43,25 +50,65 @@ describe FrozenRecord::Base do
     context 'when disabled' do
 
       it 'does not reloads the records if the file mtime changed' do
-        mtime = File.mtime(Country.file_path)
+        mtime = File.mtime(country_model.file_path)
         expect {
-          File.utime(mtime + 1, mtime + 1, Country.file_path)
-        }.to_not change { Country.first.object_id }
+          File.utime(mtime + 1, mtime + 1, country_model.file_path)
+        }.to_not change { country_model.first.object_id }
       end
 
     end
 
   end
 
+  describe '.default_attributes' do
+
+    it 'define the attribute' do
+      expect(country_model.new).to respond_to :contemporary
+    end
+
+    it 'sets the value as default' do
+      expect(country_model.find_by(name: 'Austria').contemporary).to be == true
+    end
+
+    it 'gives precedence to the data file' do
+      expect(country_model.find_by(name: 'Austria').available).to be == false
+    end
+
+    it 'is also set in the initializer' do
+      expect(country_model.new.contemporary).to be == true
+    end
+
+  end
+
+  describe '.scope' do
+
+    it 'defines a scope method' do
+      country_model.scope :north_american, -> { country_model.where(continent: 'North America') }
+      expect(country_model).to respond_to(:north_american)
+      expect(country_model.north_american.first.name).to be == 'Canada'
+    end
+
+  end
+
+  describe '.memsize' do
+
+    it 'retuns the records memory footprint' do
+      # Memory footprint is very dependent on the Ruby implementation and version
+      expect(country_model.memsize).to be > 0
+      expect(car_model.memsize).to be > 0
+    end
+
+  end
+
   describe '#load_records' do
 
     it 'processes erb by default' do
-      country = Country.first
+      country = country_model.first
       expect(country.capital).to be == 'Ottawa'
     end
 
     it 'loads records with a custom backend' do
-      animal = Animal.first
+      animal = animal_model.first
       expect(animal.name).to be == 'cat'
     end
 
@@ -70,22 +117,22 @@ describe FrozenRecord::Base do
   describe '#==' do
 
     it 'returns true if both instances are from the same class and have the same id' do
-      country = Country.first
+      country = country_model.first
       second_country = country.dup
 
       expect(country).to be == second_country
     end
 
     it 'returns false if both instances are not from the same class' do
-      country = Country.first
-      car = Car.new(id: country.id)
+      country = country_model.first
+      car = car_model.new(id: country.id)
 
       expect(country).to_not be == car
     end
 
     it 'returns false if both instances do not have the same id' do
-      country = Country.first
-      second_country = Country.last
+      country = country_model.first
+      second_country = country_model.last
 
       expect(country).to_not be == second_country
     end
@@ -95,7 +142,7 @@ describe FrozenRecord::Base do
   describe '#attributes' do
 
     it 'returns a Hash of the record attributes' do
-      attributes = Country.first.attributes
+      attributes = country_model.first.attributes
       expect(attributes).to be == {
         'id' => 1,
         'name' => 'Canada',
@@ -106,6 +153,9 @@ describe FrozenRecord::Base do
         'updated_at' => Time.parse('2014-02-24T19:08:06-05:00'),
         'king' => 'Elisabeth II',
         'nato' => true,
+        'continent' => 'North America',
+        'available' => true,
+        'contemporary' => true,
       }
     end
 
@@ -113,9 +163,9 @@ describe FrozenRecord::Base do
 
   describe '`attribute`?' do
 
-    let(:blank) { Country.new(id: 0, name: '', nato: false, king: nil) }
+    let(:blank) { country_model.new(id: 0, name: '', nato: false, king: nil) }
 
-    let(:present) { Country.new(id: 42, name: 'Groland', nato: true, king: Object.new) }
+    let(:present) { country_model.new(id: 42, name: 'Groland', nato: true, king: Object.new) }
 
     it 'considers `0` as missing' do
       expect(blank.id?).to be false
@@ -151,15 +201,50 @@ describe FrozenRecord::Base do
 
   end
 
+  describe '#present?' do
+
+    it 'returns true' do
+      expect(country_model.first).to be_present
+    end
+
+  end
+
   describe '#count' do
 
     it 'can count objects with no records' do
-      expect(Car.count).to be 0
+      expect(car_model.count).to be 0
     end
 
     it 'can count objects with records' do
-      expect(Country.count).to be 3
+      expect(country_model.count).to be 3
     end
 
   end
 end
+
+describe FrozenRecord::Base do
+  let(:country_model) { Country }
+  let(:car_model) { Car }
+  let(:animal_model) { Animal }
+
+  it_behaves_like 'main'
+
+  describe '.base_path' do
+
+    it 'raise a RuntimeError on first query attempt if not set' do
+      allow(country_model).to receive_message_chain(:base_path).and_return(nil)
+      expect {
+        country_model.file_path
+      }.to raise_error(ArgumentError)
+    end
+
+  end
+end
+
+describe FrozenRecord::Compact do
+  let(:country_model) { Compact::Country }
+  let(:car_model) { Compact::Car }
+  let(:animal_model) { Compact::Animal }
+
+  it_behaves_like 'main'
+end

data/spec/scope_spec.rb

@@ -417,6 +417,23 @@ describe 'querying' do
 
   end
 
+  describe '#==' do
+    it 'returns true when two scopes share the same hashed attributes' do
+      scope_a = Country.republics.nato
+      scope_b = Country.republics.nato
+      expect(scope_a.object_id).not_to be == scope_b.object_id
+      expect(scope_a).to be == scope_b
+    end
+
+    it 'returns true when the same scope has be rechained' do
+      scope_a = Country.nato.republics.nato.republics
+      scope_b = Country.republics.nato
+      expect(scope_a.instance_variable_get(:@where_values)).to be == [[:nato, true ], [:king, nil ], [:nato, true], [:king, nil]]
+      expect(scope_b.instance_variable_get(:@where_values)).to be == [[:king, nil ], [:nato, true]]
+      expect(scope_a).to be == scope_b
+    end
+  end
+
   describe 'class methods delegation' do
 
     it 'can be called from a scope' do

data/spec/support/animal.rb

@@ -1,16 +1,12 @@
-module JsonBackend
-  extend self
-
-  def filename(model_name)
-    "#{model_name.underscore.pluralize}.json"
-  end
-
-  def load(file_path)
-    json_data = File.read(file_path)
-    JSON.parse(json_data) || []
-  end
+class Animal < FrozenRecord::Base
+  self.backend = FrozenRecord::Backends::Json
 end
 
-class Animal < FrozenRecord::Base
-  self.backend = JsonBackend
+module Compact
+  class Animal < ::Animal
+    include FrozenRecord::Compact
+    def self.file_path
+      superclass.file_path
+    end
+  end
 end

data/spec/support/car.rb

@@ -1,2 +1,12 @@
 class Car < FrozenRecord::Base
 end
+
+module Compact
+  class Car < ::Car
+    include FrozenRecord::Compact
+
+    def self.file_path
+      superclass.file_path
+    end
+  end
+end

data/spec/support/country.rb

@@ -1,10 +1,24 @@
 class Country < FrozenRecord::Base
+  self.default_attributes = { contemporary: true, available: true }
 
   def self.republics
     where(king: nil)
   end
 
+  def self.nato
+    where(nato: true)
+  end
+
   def reverse_name
     name.reverse
   end
 end
+
+module Compact
+  class Country < ::Country
+    include FrozenRecord::Compact
+    def self.file_path
+      superclass.file_path
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: frozen_record
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Jean Boussier
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-03-26 00:00:00.000000000 Z
+date: 2020-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -94,7 +94,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - jean.boussier@gmail.com
 executables: []
@@ -108,17 +108,26 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmark/attribute-read
+- benchmark/memory-usage
+- benchmark/setup.rb
 - frozen_record.gemspec
 - lib/frozen_record.rb
+- lib/frozen_record/backends.rb
+- lib/frozen_record/backends/json.rb
 - lib/frozen_record/backends/yaml.rb
 - lib/frozen_record/base.rb
+- lib/frozen_record/compact.rb
+- lib/frozen_record/deduplication.rb
+- lib/frozen_record/railtie.rb
 - lib/frozen_record/scope.rb
 - lib/frozen_record/test_helper.rb
 - lib/frozen_record/version.rb
+- spec/deduplication_spec.rb
 - spec/fixtures/animals.json
 - spec/fixtures/cars.yml
-- spec/fixtures/countries.yml
-- spec/fixtures/test_helper/countries.yml
+- spec/fixtures/countries.yml.erb
+- spec/fixtures/test_helper/countries.yml.erb
 - spec/frozen_record_spec.rb
 - spec/scope_spec.rb
 - spec/spec_helper.rb
@@ -131,7 +140,7 @@ homepage: https://github.com/byroot/frozen_record
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -139,23 +148,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: ActiveRecord like interface to read only access and query static YAML files
 test_files:
+- spec/deduplication_spec.rb
 - spec/fixtures/animals.json
 - spec/fixtures/cars.yml
-- spec/fixtures/countries.yml
-- spec/fixtures/test_helper/countries.yml
+- spec/fixtures/countries.yml.erb
+- spec/fixtures/test_helper/countries.yml.erb
 - spec/frozen_record_spec.rb
 - spec/scope_spec.rb
 - spec/spec_helper.rb