frozen_record 0.17.0 → 0.19.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2012cdafeeed41657b76dbe5b5489a47f5e38d863335d0e2db87609d2030974
-  data.tar.gz: 636ea1f081a595230c27a2a4abb40978b977d1e3b541d23e039aa790d5bdb62d
+  metadata.gz: b9976300538ac81378c16689a47f03994e79b65a6cbbf755fa986528d4324533
+  data.tar.gz: 5e9b6c08770cd5186025041b0c6244eff2360c5b096a532802d953527abd3d1c
 SHA512:
-  metadata.gz: ae134c3c39dca424590880b06190656c2d03aa0516fa387a5742ecf2dc1943e33f4c6eee30cc7fa600e63bd3c14186c69dc348ed20783256e563657bf9058874
-  data.tar.gz: bad575675f9a764c2e84f67b9c550beee1506ef763907d32a87d5eaf967eedeb3521ec28d6d9e6dd4ebc790ce0400bf579fb1764af3d13e46f14e5a6343a1a44
+  metadata.gz: a00f10f827cd7e046d1f12433e913c39b9442dca95986cb395f81d28a685f3e7f4625814de1aeaf31654f4d2b8decab71938fe9999ccf5cb8c2fe3d3fbebe6ca
+  data.tar.gz: 070fa00130a5577cdb7441c14cb76d76f7290245f60b7b927081d169b4e86871f936716c6bfecb9859113df71791611f57546139ab80dcf1f4078a79e1e279a0

data/.gitignore

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

data/.travis.yml

@@ -1,6 +1,5 @@
 sudo: false
 rvm:
-  - '2.4'
   - '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

@@ -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

@@ -7,7 +7,9 @@ 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

data/lib/frozen_record/base.rb

@@ -3,6 +3,7 @@
 require 'set'
 require 'active_support/descendants_tracker'
 require 'frozen_record/backends'
+require 'objspace'
 
 module FrozenRecord
   class Base
@@ -20,6 +21,8 @@ module FrozenRecord
     FALSY_VALUES = [false, nil, 0, -''].to_set
 
     class_attribute :base_path, :primary_key, :backend, :auto_reloading, :default_attributes, instance_accessor: false
+    class_attribute :index_definitions, instance_accessor: false
+    self.index_definitions = {}.freeze
 
     self.primary_key = 'id'
 
@@ -102,6 +105,26 @@ module FrozenRecord
         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, *)
         if name.to_s =~ FIND_BY_PATTERN
           load_records # ensure attribute methods are defined
@@ -127,15 +150,14 @@ module FrozenRecord
           records = Deduplication.deep_deduplicate!(records)
           @attributes = list_attributes(records).freeze
           define_attribute_methods(@attributes.to_a)
-          records.map { |r| load(r) }.freeze
+          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

data/lib/frozen_record/compact.rb

@@ -0,0 +1,78 @@
+# 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)
+          index_definitions.values.each { |index| index.build(records) }
+          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/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.each_with_object({}) { |r, index| index[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/scope.rb

@@ -175,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
 
@@ -226,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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FrozenRecord
-  VERSION = '0.17.0'
+  VERSION = '0.19.3'
 end

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,10 +50,10 @@ 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
@@ -74,40 +63,52 @@ describe FrozenRecord::Base do
   describe '.default_attributes' do
 
     it 'define the attribute' do
-      expect(Country.new).to respond_to :contemporary
+      expect(country_model.new).to respond_to :contemporary
     end
 
     it 'sets the value as default' do
-      expect(Country.find_by(name: 'Austria').contemporary).to be == true
+      expect(country_model.find_by(name: 'Austria').contemporary).to be == true
     end
 
     it 'gives precedence to the data file' do
-      expect(Country.find_by(name: 'Austria').available).to be == false
+      expect(country_model.find_by(name: 'Austria').available).to be == false
     end
 
     it 'is also set in the initializer' do
-      expect(Country.new.contemporary).to be == true
+      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
 
-      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'
+  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
 
@@ -116,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
@@ -141,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',
@@ -162,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
@@ -203,7 +204,7 @@ describe FrozenRecord::Base do
   describe '#present?' do
 
     it 'returns true' do
-      expect(Country.first).to be_present
+      expect(country_model.first).to be_present
     end
 
   end
@@ -211,12 +212,39 @@ describe FrozenRecord::Base do
   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,3 +1,12 @@
 class Animal < FrozenRecord::Base
   self.backend = FrozenRecord::Backends::Json
 end
+
+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,6 +1,9 @@
 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)
   end
@@ -13,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.17.0
+  version: 0.19.3
 platform: ruby
 authors:
 - Jean Boussier
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-16 00:00:00.000000000 Z
+date: 2020-08-18 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,13 +108,18 @@ 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
@@ -136,7 +141,7 @@ homepage: https://github.com/byroot/frozen_record
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -144,15 +149,15 @@ 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: