active_hash 3.0.0 → 3.2.1

data/lib/active_hash/base.rb

@@ -1,6 +1,14 @@
 module ActiveHash
-
   class RecordNotFound < StandardError
+    attr_reader :model, :primary_key, :id
+
+    def initialize(message = nil, model = nil, primary_key = nil, id = nil)
+      @primary_key = primary_key
+      @model = model
+      @id = id
+
+      super(message)
+    end
   end
 
   class ReservedFieldError < StandardError
@@ -13,50 +21,7 @@ module ActiveHash
   end
 
   class Base
-
-    class_attribute :_data, :dirty, :default_attributes
-
-    class WhereChain
-      def initialize(scope)
-        @scope = scope
-        @records = @scope.all
-      end
-
-      def not(options)
-        return @scope if options.blank?
-
-        # use index if searching by id
-        if options.key?(:id) || options.key?("id")
-          ids = @scope.pluck(:id) - Array.wrap(options.delete(:id) || options.delete("id"))
-          candidates = ids.map { |id| @scope.find_by_id(id) }.compact
-        end
-        return candidates if options.blank?
-
-        filtered_records = (candidates || @records || []).reject do |record|
-          match_options?(record, options)
-        end
-        
-        ActiveHash::Relation.new(@scope.klass, filtered_records, {})
-      end
-
-      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(record[col]) == normalize(match)
-          end
-        end
-      end
-
-      private :match_options?
-
-      def normalize(v)
-        v.respond_to?(:to_sym) ? v.to_sym : v
-      end
-
-      private :normalize
-    end
+    class_attribute :_data, :dirty, :default_attributes, :scopes
 
     if Object.const_defined?(:ActiveModel)
       extend ActiveModel::Naming
@@ -120,9 +85,17 @@ module ActiveHash
         end
       end
 
-      def exists?(record)
-        if record.id.present?
-          record_index[record.id.to_s].present?
+      def exists?(args = nil)
+        if args.respond_to?(:id)
+          record_index[args.id.to_s].present?
+        elsif args == false
+          false
+        elsif args.nil?
+          all.present?
+        elsif args.is_a?(Hash)
+          all.where(args).present?
+        else
+          all.where(id: args.to_i).present?
         end
       end
 
@@ -137,7 +110,7 @@ module ActiveHash
       end
 
       def next_id
-        max_record = all.max { |a, b| a.id <=> b.id }
+        max_record = all_in_process.max { |a, b| a.id <=> b.id }
         if max_record.nil?
           1
         elsif max_record.id.is_a?(Numeric)
@@ -145,6 +118,11 @@ module ActiveHash
         end
       end
 
+      def all_in_process
+        all
+      end
+      private :all_in_process
+
       def record_index
         @record_index ||= {}
       end
@@ -185,10 +163,12 @@ module ActiveHash
       end
 
       def all(options = {})
-        ActiveHash::Relation.new(self, @records || [], options[:conditions] || {})
+        relation = ActiveHash::Relation.new(self, @records || [])
+        relation = relation.where!(options[:conditions]) if options[:conditions]
+        relation
       end
 
-      delegate :where, :find, :find_by, :find_by!, :find_by_id, :count, :pluck, :first, :last, to: :all
+      delegate :where, :find, :find_by, :find_by!, :find_by_id, :count, :pluck, :ids, :pick, :first, :last, :order, to: :all
 
       def transaction
         yield
@@ -217,7 +197,7 @@ module ActiveHash
         validate_field(field_name)
         field_names << field_name
 
-        add_default_value(field_name, options[:default]) if options[:default]
+        add_default_value(field_name, options[:default]) if options.key?(:default)
         define_getter_method(field_name, options[:default])
         define_setter_method(field_name)
         define_interrogator_method(field_name)
@@ -388,10 +368,13 @@ module ActiveHash
       end
 
       private :mark_clean
-      
+
       def scope(name, body)
         raise ArgumentError, 'body needs to be callable' unless body.respond_to?(:call)
-        
+
+        self.scopes ||= {}
+        self.scopes[name] = body
+
         the_meta_class.instance_eval do
           define_method(name) do |*args|
             instance_exec(*args, &body)
@@ -472,7 +455,11 @@ module ActiveHash
         when new_record?
           "#{self.class.cache_key}/new"
         when timestamp = self[:updated_at]
-          "#{self.class.cache_key}/#{id}-#{timestamp.to_s(:number)}"
+          if ActiveSupport::VERSION::MAJOR < 7
+            "#{self.class.cache_key}/#{id}-#{timestamp.to_s(:number)}"
+          else
+            "#{self.class.cache_key}/#{id}-#{timestamp.to_fs(:number)}"
+          end
         else
           "#{self.class.cache_key}/#{id}"
       end

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.read_attribute(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

@@ -1,44 +1,114 @@
 module ActiveHash
   class Relation
     include Enumerable
-    
+
     delegate :each, to: :records # Make Enumerable work
-    delegate :equal?, :==, :===, :eql?, to: :records
+    delegate :equal?, :==, :===, :eql?, :sort!, to: :records
     delegate :empty?, :length, :first, :second, :third, :last, to: :records
-        
-    def initialize(klass, all_records, query_hash = nil)
+    delegate :sample, to: :records
+
+    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
+
+    def pretty_print(pp)
+      pp.pp(entries.to_ary)
+    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 where(query_hash = :chain)
-      return ActiveHash::Base::WhereChain.new(self) if query_hash == :chain
-      
-      self.records_dirty = true unless query_hash.nil? || query_hash.keys.empty?
-      self.query_hash.merge!(query_hash || {})
+
+    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 reorder!(*options)
+      check_if_method_has_arguments!(:order, options)
+
+      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({})
       end
     end
-    
+
     def find_by(options)
       where(options).first
     end
 
     def find_by!(options)
-      find_by(options) || (raise RecordNotFound.new("Couldn't find #{klass.name}"))
+      find_by(options) || (raise RecordNotFound.new("Couldn't find #{klass.name}", klass.name))
     end
-    
-    def find(id, *args)
+
+    def find(id = nil, *args, &block)
       case id
         when :all
           all
@@ -47,82 +117,115 @@ module ActiveHash
         when Array
           id.map { |i| find(i) }
         when nil
-          raise RecordNotFound.new("Couldn't find #{klass.name} without an ID")
+          raise RecordNotFound.new("Couldn't find #{klass.name} without an ID", klass.name, "id") unless block_given?
+          records.find(&block) # delegate to Enumerable#find if a block is given
         else
           find_by_id(id) || begin
-            raise RecordNotFound.new("Couldn't find #{klass.name} with ID=#{id}")
+            raise RecordNotFound.new("Couldn't find #{klass.name} with ID=#{id}", klass.name, "id", id)
           end
       end
     end
-    
+
     def find_by_id(id)
       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
       length
     end
-    
-    def pluck(*column_names)
-      column_names.map { |column_name| all.map(&column_name.to_sym) }.inject(&:zip)
-    end
-    
-    def reload
-      @records = filter_all_records_by_query_hash
+
+    def size
+      length
     end
-    
-    attr_reader :query_hash, :klass, :all_records, :records_dirty
-    
-    private
-    
-    attr_writer :query_hash, :klass, :all_records, :records_dirty
-    
-    def records
-      if @records.nil? || records_dirty
-        reload
+
+    def pluck(*column_names)
+      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
-        @records
+        all.map do |record|
+          symbolized_column_names.map { |column_name| record[column_name] }
+        end
       end
     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
-      
-      return candidates if query_hash.blank?
 
-      (candidates || all_records || []).select do |record|
-        match_options?(record, query_hash)
-      end
+    def ids
+      pluck(:id)
     end
-    
-    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(record[col]) == normalize(match)
-        end
+
+    def pick(*column_names)
+      pluck(*column_names).first
+    end
+
+    def to_ary
+      records.dup
+    end
+
+    def method_missing(method_name, *args)
+      return super unless klass.scopes&.key?(method_name)
+
+      instance_exec(*args, &klass.scopes[method_name])
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      klass.scopes&.key?(method_name) || super
+    end
+
+    private
+
+    attr_writer :conditions, :order_values, :klass, :all_records
+
+    def apply_conditions(records, conditions)
+      return records if conditions.blank?
+
+      records.select do |record|
+        conditions.matches?(record)
       end
     end
 
-    def normalize(v)
-      v.respond_to?(:to_sym) ? v.to_sym : v
+    def check_if_method_has_arguments!(method_name, args)
+      return unless args.blank?
+
+      raise ArgumentError,
+            "The method .#{method_name}() must contain arguments."
     end
-    
-    def range_to_array(range)
-      return range.to_a unless range.end.nil?
 
-      e = records.last[:id]
-      (range.begin..e).to_a
+    def preprocess_order_args(order_args)
+      order_args.reject!(&:blank?)
+      return order_args.reverse! unless order_args.first.is_a?(String)
+
+      ary = order_args.first.split(', ')
+      ary.map! { |e| e.split(/\W+/) }.reverse!
+    end
+
+    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)
+                     elsif arg.is_a?(Array)
+                       arg.map(&:to_sym)
+                     else
+                       arg.to_sym
+                     end
+
+        ordered_records.sort! do |a, b|
+          if dir.present? && dir.to_sym.upcase.equal?(:DESC)
+            b[field] <=> a[field]
+          else
+            a[field] <=> b[field]
+          end
+        end
+      end
+
+      ordered_records
     end
   end
 end

data/lib/active_hash/version.rb

@@ -1,5 +1,5 @@
 module ActiveHash
   module Gem
-    VERSION = "3.0.0"
+    VERSION = "3.2.1"
   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/aliases.rb

@@ -5,6 +5,8 @@ module ActiveYaml
       base.extend(ClassMethods)
     end
 
+    ALIAS_KEY_REGEXP = /^\//.freeze
+
     module ClassMethods
 
       def insert(record)
@@ -12,16 +14,19 @@ module ActiveYaml
       end
 
       def raw_data
-        super.reject do |k, v|
-          v.kind_of? Hash and k.match(/^\//i)
+        d = super
+        if d.kind_of?(Array)
+          d.reject do |h|
+            h.keys.any? { |k| k.match(ALIAS_KEY_REGEXP) }
+          end
+        else
+          d.reject do |k, v|
+            v.kind_of?(Hash) && k.match(ALIAS_KEY_REGEXP)
+          end
         end
       end
 
     end
-
-    def initialize(attributes={})
-      super unless attributes.keys.index { |k| k.to_s.match(/^\//i) }
-    end
   end
 
 end

data/lib/active_yaml/base.rb

@@ -4,12 +4,16 @@ 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)
           data
         elsif data.respond_to?(:values)
-          data.values
+          data.map{ |key, value| {"key" => key}.merge(value) }
         end
       end
 
@@ -18,9 +22,19 @@ module ActiveYaml
       end
 
       private
+if Psych::VERSION >= "4.0.0"
       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.unsafe_load(result)
       end
+else
+      def load_path(path)
+        result = File.read(path)
+        result = ERB.new(result).result if process_erb
+        YAML.load(result)
+      end
+end
     end
   end
 end