frozen_record 0.15.0 → 0.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce0b59f2960394e86f2278a1c574680bfc27491bead98f9991ba70aa9a90766e
-  data.tar.gz: c194c8fa251cc4b9e6be6a41869ad383e4aa0ebd54021ddb36b2b285257dc347
+  metadata.gz: d75dfc07a86429e4dcc6a17c076aa87081a19e812b3d9b8d9722281d8a14aba9
+  data.tar.gz: a445c878d8cddaa87cb59db1213cf4099e3cbf10fa854d92fbd28669867dad4a
 SHA512:
-  metadata.gz: 6bf7ce5df1f3a4c2dd67e4b391fd26bb3499ec572bf4de600bdf50728292959cef2330844d19e3deebec714183da7931802bb735fd5c2d0281541235f07fcb3d
-  data.tar.gz: 18b96a420a7f74e12c57362b856609b685e60923e4eb39c83d1d0623321f8dade128d53f6435008431589d22f218200c9d3c42a497ead3406013714208a09cdb
+  metadata.gz: 54b3c787e7c0f028c8c58a2a1fb214a5b3ac0c4b8b06ac4a42d4a35526baa0c50573967a7aa7faad0921c028d19d985dda831257f2244b1ba5af56960187ced1
+  data.tar.gz: 8159f7e45d32256ab9565bbf5ff81c6685e912c57603f97b335f8c5dbb2529b4153bb0e2937e4c709da9a78d0f303f485e33daf4933aa129be9599313964ec8d

data/.gitignore

@@ -16,3 +16,4 @@ test/tmp
 test/version_tmp
 tmp
 vendor
+.byebug_history

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
@@ -140,6 +140,22 @@ Country.european.republics.part_of_nato.order(id: :desc)
   - average
 
 
+## Indexing
+
+Querying is implemented as a simple linear search (`O(n)`). However if you are using Frozen Record with larger datasets, or are querying
+a collection repetedly, you can define indices for faster access.
+
+```ruby
+class Country < FrozenRecord::Base
+  add_index :name, unique: true
+  add_index :continent
+end
+```
+
+Composite index keys are not supported.
+
+The primary key isn't indexed by default.
+
 ## Configuration
 
 ### Reloading

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'
@@ -5,14 +7,23 @@ require 'active_model'
 
 require 'frozen_record/version'
 require 'frozen_record/scope'
+require 'frozen_record/index'
 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
@@ -17,25 +20,13 @@ module FrozenRecord
     FIND_BY_PATTERN = /\Afind_by_(\w+)(!?)/
     FALSY_VALUES = [false, nil, 0, -''].to_set
 
-    class_attribute :base_path
-
-    class_attribute :primary_key
-
-    class << self
-      alias_method :original_primary_key=, :primary_key=
-
-      def primary_key=(primary_key)
-        self.original_primary_key = -primary_key.to_s
-      end
-    end
+    class_attribute :base_path, :primary_key, :backend, :auto_reloading, :default_attributes, instance_accessor: false
+    class_attribute :index_definitions, instance_accessor: false, default: {}.freeze
 
     self.primary_key = 'id'
 
-    class_attribute :backend
     self.backend = FrozenRecord::Backends::Yaml
 
-    class_attribute :auto_reloading
-
     attribute_method_suffix -'?'
 
     class ThreadSafeStorage
@@ -57,8 +48,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
@@ -77,7 +94,34 @@ 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 add_index(attribute, unique: false)
+        index = unique ? UniqueIndex.new(self, attribute) : Index.new(self, attribute)
+        self.index_definitions = index_definitions.merge(index.attribute => index).freeze
+      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, *)
@@ -101,16 +145,25 @@ module FrozenRecord
 
         @records ||= begin
           records = backend.load(file_path)
-          define_attribute_methods(list_attributes(records))
-          records.map(&method(:new)).freeze
+          records.each { |r| assign_defaults!(r) }
+          records = Deduplication.deep_deduplicate!(records)
+          @attributes = list_attributes(records).freeze
+          define_attribute_methods(@attributes.to_a)
+          records = records.map { |r| load(r) }.freeze
+          index_definitions.values.each { |index| index.build(records) }
+          records
         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) }
+        singleton_class.send(:define_method, name, &body)
+      end
+
+      alias_method :load, :new
+      private :load
+
+      def new(attrs = {})
+        load(assign_defaults!(attrs.stringify_keys))
       end
 
       private
@@ -125,6 +178,18 @@ 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.to_s =~ FIND_BY_PATTERN
           return dynamic_match($1, args, $2.present?)
@@ -140,17 +205,15 @@ module FrozenRecord
       def list_attributes(records)
         attributes = Set.new
         records.each do |record|
-          record.keys.each do |key|
-            attributes.add(key.to_s)
-          end
+          attributes.merge(record.keys)
         end
-        attributes.to_a
+        attributes
       end
 
     end
 
     def initialize(attrs = {})
-      @attributes = attrs.stringify_keys.freeze
+      @attributes = attrs.freeze
     end
 
     def attributes
@@ -158,7 +221,7 @@ module FrozenRecord
     end
 
     def id
-      self[primary_key.to_s]
+      self[self.class.primary_key]
     end
 
     def [](attr)
@@ -184,5 +247,8 @@ module FrozenRecord
       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/index.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module FrozenRecord
+  class Index
+    EMPTY_ARRAY = [].freeze
+    private_constant :EMPTY_ARRAY
+
+    AttributeNonUnique = Class.new(StandardError)
+
+    attr_reader :attribute, :model
+
+    def initialize(model, attribute, unique: false)
+      @model = model
+      @attribute = -attribute.to_s
+      @index = nil
+    end
+
+    def unique?
+      false
+    end
+
+    def query(value)
+      case value
+      when Array, Range
+        lookup_multi(value)
+      else
+        lookup(value)
+      end
+    end
+
+    def lookup_multi(values)
+      values.flat_map { |v| lookup(v) }
+    end
+
+    def lookup(value)
+      @index.fetch(value, EMPTY_ARRAY)
+    end
+
+    def reset
+      @index = nil
+    end
+
+    def build(records)
+      @index = records.each_with_object({}) do |record, index|
+        entry = (index[record[attribute]] ||= [])
+        entry << record
+      end
+      @index.values.each(&:freeze)
+      @index.freeze
+    end
+  end
+
+  class UniqueIndex < Index
+    def unique?
+      true
+    end
+
+    def lookup_multi(values)
+      results = @index.values_at(*values)
+      results.compact!
+      results
+    end
+
+    def lookup(value)
+      record = @index[value]
+      record ? [record] : EMPTY_ARRAY
+    end
+
+    def build(records)
+      @index = records.to_h { |r| [r[attribute], r] }
+      if @index.size != records.size
+        raise AttributeNonUnique, "#{model}##{attribute.inspect} is not unique."
+      end
+      @index.freeze
+    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 = [
@@ -173,9 +175,20 @@ module FrozenRecord
     def select_records(records)
       return records if @where_values.empty? && @where_not_values.empty?
 
+      indices = @klass.index_definitions
+      indexed_where_values, unindexed_where_values = @where_values.partition { |criteria| indices.key?(criteria.first) }
+
+      unless indexed_where_values.empty?
+        attribute, value = indexed_where_values.shift
+        records = indices[attribute].query(value)
+        indexed_where_values.each do |(attribute, value)|
+          records &= indices[attribute].query(value)
+        end
+      end
+
       records.select do |record|
-        @where_values.all? { |attr, value| compare_value(record[attr], value) } &&
-        @where_not_values.all? { |attr, value| !compare_value(record[attr], value) }
+        unindexed_where_values.all? { |attr, value| compare_value(record[attr], value) } &&
+        !@where_not_values.any? { |attr, value| compare_value(record[attr], value) }
       end
     end
 
@@ -224,12 +237,12 @@ module FrozenRecord
     end
 
     def where!(criterias)
-      @where_values += criterias.to_a
+      @where_values += criterias.map { |k, v| [k.to_s, v] }
       self
     end
 
     def where_not!(criterias)
-      @where_not_values += criterias.to_a
+      @where_not_values += criterias.map { |k, v| [k.to_s, v] }
       self
     end
 

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.15.0'
+  VERSION = '0.19.1'
 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}

@@ -20,7 +20,6 @@
   nato: true
   continent: Europe
 
-
 - id: 3
   name: Austria
   capital: <%= 'Vienna' %>
@@ -29,3 +28,4 @@
   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,32 +1,21 @@
 require 'spec_helper'
 
-describe FrozenRecord::Base do
-
-  describe '.base_path' 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)
-    end
-
-  end
+RSpec.shared_examples 'main' do
 
   describe '.primary_key' do
 
     around do |example|
-      previous_primary_key = Country.primary_key
+      previous_primary_key = country_model.primary_key
       begin
         example.run
       ensure
-        Country.primary_key = previous_primary_key
+        country_model.primary_key = previous_primary_key
       end
     end
 
     it 'is coerced to string' do
-      Country.primary_key = :foobar
-      expect(Country.primary_key).to be == 'foobar'
+      country_model.primary_key = :foobar
+      expect(country_model.primary_key).to be == 'foobar'
     end
 
   end
@@ -36,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
@@ -61,34 +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, -> { 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
 
-      Country.scope :north_american, -> { Country.where(continent: 'North America') }
-      expect(Country).to respond_to(:north_american)
-      expect(Country.north_american.first.name).to be == 'Canada'
+    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
 
@@ -97,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
@@ -122,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',
@@ -134,6 +154,8 @@ describe FrozenRecord::Base do
         'king' => 'Elisabeth II',
         'nato' => true,
         'continent' => 'North America',
+        'available' => true,
+        'contemporary' => true,
       }
     end
 
@@ -141,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
@@ -179,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

@@ -203,6 +203,18 @@ describe 'querying' do
       expect(countries.length).to be == 2
     end
 
+    it 'can combine indices' do
+      countries = Country.where(name: 'France', continent: 'Europe')
+      expect(countries.length).to be == 1
+    end
+
+    it 'can use indices with inclusion query' do
+      countries = Country.where(continent: ['Europe', 'North America'])
+      expect(countries.length).to be == 3
+
+      countries = Country.where(name: ['France', 'Canada'])
+      expect(countries.length).to be == 2
+    end
   end
 
   describe '.where.not' do
@@ -428,8 +440,8 @@ describe 'querying' do
     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.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

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,4 +1,8 @@
 class Country < FrozenRecord::Base
+  self.default_attributes = { contemporary: true, available: true }
+
+  add_index :name, unique: true
+  add_index :continent
 
   def self.republics
     where(king: nil)
@@ -12,3 +16,12 @@ class Country < FrozenRecord::Base
     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.15.0
+  version: 0.19.1
 platform: ruby
 authors:
 - Jean Boussier
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-08-27 00:00:00.000000000 Z
+date: 2020-07-16 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,27 @@ 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/index.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 +141,7 @@ homepage: https://github.com/byroot/frozen_record
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -139,22 +149,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: []
-rubygems_version: 3.0.4
-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