active_hash 3.1.1 → 3.2.0

data/lib/active_hash/condition.rb

@@ -0,0 +1,44 @@
+class ActiveHash::Relation::Condition
+  attr_reader :constraints, :inverted
+
+  def initialize(constraints)
+    @constraints = constraints
+    @inverted = false
+  end
+
+  def invert!
+    @inverted = !inverted
+
+    self
+  end
+
+  def matches?(record)
+    match = begin
+      return true unless constraints
+
+      expectation_method = inverted ? :any? : :all?
+
+      constraints.send(expectation_method) do |attribute, expected|
+        value = record.public_send(attribute)
+
+        matches_value?(value, expected)
+      end
+    end
+
+    inverted ? !match : match
+  end
+
+  private
+
+  def matches_value?(value, comparison)
+    return comparison.any? { |v| matches_value?(value, v) } if comparison.is_a?(Array)
+    return comparison.cover?(value) if comparison.is_a?(Range)
+    return comparison.match?(value) if comparison.is_a?(Regexp)
+
+    normalize(value) == normalize(comparison)
+  end
+
+  def normalize(value)
+    value.respond_to?(:to_s) ? value.to_s : value
+  end
+end

data/lib/active_hash/conditions.rb

@@ -0,0 +1,21 @@
+class ActiveHash::Relation::Conditions
+  attr_reader :conditions
+
+  delegate :<<, :map, to: :conditions
+
+  def initialize(conditions = [])
+    @conditions = conditions
+  end
+
+  def matches?(record)
+    conditions.all? do |condition|
+      condition.matches?(record)
+    end
+  end
+
+  def self.wrap(conditions)
+    return conditions if conditions.is_a?(self)
+
+    new(conditions)
+  end
+end

data/lib/active_hash/relation.rb

@@ -7,24 +7,89 @@ module ActiveHash
     delegate :empty?, :length, :first, :second, :third, :last, to: :records
     delegate :sample, to: :records
 
-    def initialize(klass, all_records, query_hash = nil)
+    attr_reader :conditions, :order_values, :klass, :all_records
+
+    def initialize(klass, all_records, conditions = nil, order_values = nil)
       self.klass = klass
       self.all_records = all_records
-      self.query_hash = query_hash
-      self.records_dirty = false
+      self.conditions = Conditions.wrap(conditions || [])
+      self.order_values = order_values || []
+    end
+
+    def where(conditions_hash = :chain)
+      return WhereChain.new(self) if conditions_hash == :chain
+
+      spawn.where!(conditions_hash)
+    end
+
+    class WhereChain
+      attr_reader :relation
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def not(conditions_hash)
+        relation.conditions << Condition.new(conditions_hash).invert!
+        relation
+      end
+    end
+
+    def order(*options)
+      spawn.order!(*options)
+    end
+
+    def reorder(*options)
+      spawn.reorder!(*options)
+    end
+
+    def where!(conditions_hash, inverted = false)
+      self.conditions << Condition.new(conditions_hash)
+      self
+    end
+
+    def invert_where
+      spawn.invert_where!
+    end
+
+    def invert_where!
+      conditions.map(&:invert!)
+      self
+    end
+
+    def spawn
+      self.class.new(klass, all_records, conditions, order_values)
+    end
+
+    def order!(*options)
+      check_if_method_has_arguments!(:order, options)
+      self.order_values += preprocess_order_args(options)
       self
     end
 
-    def where(query_hash = :chain)
-      return ActiveHash::Base::WhereChain.new(self) if query_hash == :chain
+    def reorder!(*options)
+      check_if_method_has_arguments!(:order, options)
 
-      self.records_dirty = true unless query_hash.nil? || query_hash.keys.empty?
-      self.query_hash.merge!(query_hash || {})
+      self.order_values = preprocess_order_args(options)
+      @records = apply_order_values(records, order_values)
+
+      self
+    end
+
+    def records
+      @records ||= begin
+        filtered_records = apply_conditions(all_records, conditions)
+        ordered_records = apply_order_values(filtered_records, order_values) # rubocop:disable Lint/UselessAssignment
+      end
+    end
+
+    def reload
+      @records = nil # Reset records
       self
     end
 
     def all(options = {})
-      if options.has_key?(:conditions)
+      if options.key?(:conditions)
         where(options[:conditions])
       else
         where({})
@@ -58,10 +123,11 @@ module ActiveHash
     end
 
     def find_by_id(id)
-      return where(id: id).first if query_hash.present?
-
       index = klass.send(:record_index)[id.to_s] # TODO: Make index in Base publicly readable instead of using send?
-      index and records[index]
+      return unless index
+
+      record = all_records[index]
+      record if conditions.matches?(record)
     end
 
     def count
@@ -73,7 +139,16 @@ module ActiveHash
     end
 
     def pluck(*column_names)
-      column_names.map { |column_name| all.map(&column_name.to_sym) }.inject(&:zip)
+      symbolized_column_names = column_names.map(&:to_sym)
+
+      if symbolized_column_names.length == 1
+        column_name = symbolized_column_names.first
+        all.map { |record| record[column_name] }
+      else
+        all.map do |record|
+          symbolized_column_names.map { |column_name| record[column_name] }
+        end
+      end
     end
 
     def ids
@@ -84,86 +159,32 @@ module ActiveHash
       pluck(*column_names).first
     end
 
-    def reload
-      @records = filter_all_records_by_query_hash
-    end
-
-    def order(*options)
-      check_if_method_has_arguments!(:order, options)
-      relation = where({})
-      return relation if options.blank?
-
-      processed_args = preprocess_order_args(options)
-      candidates = relation.dup
-
-      order_by_args!(candidates, processed_args)
-
-      candidates
-    end
-
     def to_ary
       records.dup
     end
 
     def method_missing(method_name, *args)
-      return super unless self.klass.scopes.key?(method_name)
+      return super unless klass.scopes.key?(method_name)
 
-      instance_exec(*args, &self.klass.scopes[method_name])
+      instance_exec(*args, &klass.scopes[method_name])
     end
 
-    attr_reader :query_hash, :klass, :all_records, :records_dirty
-
-    private
-
-    attr_writer :query_hash, :klass, :all_records, :records_dirty
-
-    def records
-      if !defined?(@records) || @records.nil? || records_dirty
-        reload
-      else
-        @records
-      end
+    def respond_to_missing?(method_name, include_private = false)
+      klass.scopes.key?(method_name) || super
     end
 
-    def filter_all_records_by_query_hash
-      self.records_dirty = false
-      return all_records if query_hash.blank?
-
-      # use index if searching by id
-      if query_hash.key?(:id) || query_hash.key?("id")
-        ids = (query_hash.delete(:id) || query_hash.delete("id"))
-        ids = range_to_array(ids) if ids.is_a?(Range)
-        candidates = Array.wrap(ids).map { |id| klass.find_by_id(id) }.compact
-      end
+    private
 
-      return candidates if query_hash.blank?
+    attr_writer :conditions, :order_values, :klass, :all_records
 
-      (candidates || all_records || []).select do |record|
-        match_options?(record, query_hash)
-      end
-    end
+    def apply_conditions(records, conditions)
+      return records if conditions.blank?
 
-    def match_options?(record, options)
-      options.all? do |col, match|
-        if match.kind_of?(Array)
-          match.any? { |v| normalize(v) == normalize(record[col]) }
-        else
-          normalize(match) === normalize(record[col])
-        end
+      records.select do |record|
+        conditions.matches?(record)
       end
     end
 
-    def normalize(v)
-      v.respond_to?(:to_sym) ? v.to_sym : v
-    end
-
-    def range_to_array(range)
-      return range.to_a unless range.end.nil?
-
-      e = records.last[:id]
-      (range.begin..e).to_a
-    end
-
     def check_if_method_has_arguments!(method_name, args)
       return unless args.blank?
 
@@ -179,7 +200,9 @@ module ActiveHash
       ary.map! { |e| e.split(/\W+/) }.reverse!
     end
 
-    def order_by_args!(candidates, args)
+    def apply_order_values(records, args)
+      ordered_records = records.dup
+
       args.each do |arg|
         field, dir = if arg.is_a?(Hash)
                        arg.to_a.flatten.map(&:to_sym)
@@ -189,7 +212,7 @@ module ActiveHash
                        arg.to_sym
                      end
 
-        candidates.sort! do |a, b|
+        ordered_records.sort! do |a, b|
           if dir.present? && dir.to_sym.upcase.equal?(:DESC)
             b[field] <=> a[field]
           else
@@ -197,6 +220,8 @@ module ActiveHash
           end
         end
       end
+
+      ordered_records
     end
   end
 end

data/lib/active_hash/version.rb

@@ -1,5 +1,5 @@
 module ActiveHash
   module Gem
-    VERSION = "3.1.1"
+    VERSION = "3.2.0"
   end
 end

data/lib/active_hash.rb

@@ -13,6 +13,8 @@ end
 
 require 'active_hash/base'
 require 'active_hash/relation'
+require 'active_hash/condition'
+require 'active_hash/conditions'
 require 'active_file/multiple_files'
 require 'active_file/hash_and_array_files'
 require 'active_file/base'

data/lib/active_yaml/base.rb

@@ -4,6 +4,10 @@ module ActiveYaml
 
   class Base < ActiveFile::Base
     extend ActiveFile::HashAndArrayFiles
+
+    cattr_accessor :process_erb, instance_accessor: false
+    @@process_erb = true
+
     class << self
       def load_file
         if (data = raw_data).is_a?(Array)
@@ -20,11 +24,15 @@ module ActiveYaml
       private
 if Psych::VERSION >= "4.0.0"
       def load_path(path)
-        YAML.unsafe_load(ERB.new(File.read(path)).result)
+        result = File.read(path)
+        result = ERB.new(result).result if process_erb
+        YAML.unsafe_load(result)
       end
 else
       def load_path(path)
-        YAML.load(ERB.new(File.read(path)).result)
+        result = File.read(path)
+        result = ERB.new(result).result if process_erb
+        YAML.load(result)
       end
 end
     end

data/lib/associations/associations.rb

@@ -4,19 +4,19 @@ module ActiveHash
     module ActiveRecordExtensions
 
       def belongs_to(name, scope = nil, **options)
-        options = {:class_name => name.to_s.camelize }.merge(options)
+        klass_name = options.key?(:class_name) ? options[:class_name] : name.to_s.camelize
         klass =
           begin
-            options[:class_name].constantize
-          rescue
-            nil
-          rescue LoadError
+            klass_name.constantize
+          rescue StandardError, LoadError
             nil
           end
+
         if klass && klass < ActiveHash::Base
+          options = { class_name: klass_name }.merge(options)
           belongs_to_active_hash(name, options)
         else
-          super(name, **options)
+          super
         end
       end
 
@@ -49,13 +49,20 @@ module ActiveHash
         end
 
         if ActiveRecord::Reflection.respond_to?(:create)
-          reflection = ActiveRecord::Reflection.create(
-            :belongs_to,
-            association_id.to_sym,
-            nil,
-            options,
-            self
-          )
+          if defined?(ActiveHash::Reflection::BelongsToReflection)
+            reflection = ActiveHash::Reflection::BelongsToReflection.new(association_id.to_sym, nil, options, self)
+            if options[:through]
+              reflection = ActiveRecord::ThroughReflection.new(reflection)
+            end
+          else
+            reflection = ActiveRecord::Reflection.create(
+              :belongs_to,
+              association_id.to_sym,
+              nil,
+              options,
+              self
+            )
+          end
 
           ActiveRecord::Reflection.add_reflection(
             self,
@@ -85,12 +92,12 @@ module ActiveHash
     end
 
     def self.included(base)
+      require_relative "reflection_extensions"
       base.extend Methods
     end
 
     module Methods
       def has_many(association_id, options = {})
-
         define_method(association_id) do
           options = {
             :class_name => association_id.to_s.classify,
@@ -110,6 +117,9 @@ module ActiveHash
             klass.where(foreign_key => primary_key_value)
           end
         end
+        define_method("#{association_id.to_s.underscore.singularize}_ids") do
+          public_send(association_id).map(&:id)
+        end
       end
 
       def has_one(association_id, options = {})

data/lib/associations/reflection_extensions.rb

@@ -0,0 +1,25 @@
+module ActiveHash
+  module Reflection
+    class BelongsToReflection < ActiveRecord::Reflection::BelongsToReflection
+      def compute_class(name)
+        if polymorphic?
+          raise ArgumentError, "Polymorphic associations do not support computing the class."
+        end
+        
+        begin
+          klass = active_record.send(:compute_type, name)
+        rescue NameError => error
+          if error.name.match?(/(?:\A|::)#{name}\z/)
+            message = "Missing model class #{name} for the #{active_record}##{self.name} association."
+            message += " You can specify a different model class with the :class_name option." unless options[:class_name]
+            raise NameError.new(message, name)
+          else
+            raise
+          end
+        end
+
+        klass
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_hash
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.0
 platform: ruby
 authors:
 - Jeff Dean
@@ -29,7 +29,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-14 00:00:00.000000000 Z
+date: 2023-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -66,7 +66,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG
+- CHANGELOG.md
 - LICENSE
 - README.md
 - active_hash.gemspec
@@ -75,17 +75,24 @@ files:
 - lib/active_file/multiple_files.rb
 - lib/active_hash.rb
 - lib/active_hash/base.rb
+- lib/active_hash/condition.rb
+- lib/active_hash/conditions.rb
 - lib/active_hash/relation.rb
 - lib/active_hash/version.rb
 - lib/active_json/base.rb
 - lib/active_yaml/aliases.rb
 - lib/active_yaml/base.rb
 - lib/associations/associations.rb
+- lib/associations/reflection_extensions.rb
 - lib/enum/enum.rb
 homepage: http://github.com/active-hash/active_hash
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: http://github.com/active-hash/active_hash
+  changelog_uri: https://github.com/active-hash/active_hash/blob/master/CHANGELOG.md
+  source_code_uri: http://github.com/active-hash/active_hash
+  bug_tracker_uri: https://github.com/active-hash/active_hash/issues
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -101,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: An ActiveRecord-like model that uses a hash or file as a datasource