active_hash 2.3.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e84505bccf077a25c58e6e57c7fe5ed5e626a0990bf7018711936d4d40374d8a
-  data.tar.gz: c4da9c5f5c3af7b5eb55747a91ee292052cef9cb7cfb134337a91d901534dceb
+  metadata.gz: 819c44015340a15c0fbdd202345818e8fd8a056672e09fe196cf90789fb53f59
+  data.tar.gz: bafc27b0aff5c96b068b3dd58216fdd054fda429c332febeb47b0e9c538a0d2d
 SHA512:
-  metadata.gz: b03cc2c6bf1826e6e95a4277434127bed837808bcfdf1f82bbd8ad888b05f9d11e248eff8577cd0e9d51c6d2ace1d1e7688be1ddf3e09dcb38bc161b622c81a8
-  data.tar.gz: fe93b20edaa8152c0448ce071c9d782edb3ded08b716708309678aba1a33b513c9bb9505693a9751a7497e3cd08f44fb18ec3f314c1d040a2b08262479eb1748
+  metadata.gz: f729484d6e9cd6c5c20a6a8682a6b6c0a52ae71dbee77c9279c5c88c5206a1504d14bf6a46b795a77e7a982ed13f7e03370f5decc1672ed0f0651781ddc04953
+  data.tar.gz: 59bbb5a4027531f1f5e18bba31ad7dd4723df0e47d1d8b9b9472fa8ccc8f3d765814d937e8651cdbccffc12ee43035efc567b946c00e463b8518d8e2892c3318

data/CHANGELOG

@@ -1,32 +1,58 @@
+2022-07-14 (v3.1.1)
+  - Make scopes chainable [#248](https://github.com/active-hash/active_hash/pull/248) @andreynering
+  - Set default key attributes [#251](https://github.com/active-hash/active_hash/pull/251/commits/68a0a121d110ac83f4bbf0024f027714fd24debf) @adampal
+  - Migrate from Travis to GitHub Actions for CI @kbrock
+  - Add primary_key support for has_one [#218](https://github.com/active-hash/active_hash/pull/218) @yujideveloper
+  - Return a chainable relation when using .not [#205](https://github.com/active-hash/active_hash/pull/205) @pfeiffer
+  - Correct fields with YAML aliases in array style [#226](https://github.com/active-hash/active_hash/pull/226) @stomk
+  - Add ActiveHash::Relation#size method for compatibily [#227](https://github.com/active-hash/active_hash/pull/227) @sluceno
+  - Implement ActiveRecord::RecordNotFound interface [#207](https://github.com/active-hash/active_hash/pull/207) @ChrisBr
+  - Fix find_by_id with filter chain [#210](https://github.com/active-hash/active_hash/pull/210) @ChrisBr
+  - Suppress Ruby 2.7 kwargs warnings [#206](https://github.com/active-hash/active_hash/pull/206) @yhirano55
+  - Call reload if @records is not defined [#208](https://github.com/active-hash/active_hash/pull/208) @jonmagic
+  - Switch to rspec3 (and update the Gemfile) [#209](https://github.com/active-hash/active_hash/pull/209) @djberg96
+  - Implement filter by RegEx [#211](https://github.com/active-hash/active_hash/pull/211) @ChrisBr
+  - Supports .pick method [#195](https://github.com/active-hash/active_hash/pull/195/files) @yhirano55
+  - Lots of other small performance improvements, documentation and testing. Thanks to everyone who contributed!
+
+2020-01-15 (v3.1.0)
+  - Add ActiveHash::Base.order method inspired by ActiveRecord [#177](https://github.com/active-hash/active_hash/pull/177)
+  - Add #to_ary to ActiveHash::Relation [#182](https://github.com/active-hash/active_hash/pull/182)
+  - Allow #find to behave like Enumerable#find if id is nil and a block is given [#183](https://github.com/active-hash/active_hash/pull/183)
+  - Delegate :sample to `records` [#189](https://github.com/active-hash/active_hash/pull/189)
+
+2019-09-28 (v3.0.0)
+  - Make #where chainable [#178](https://github.com/active-hash/active_hash/pull/178)
+
 2019-09-28 (v2.3.0)
-  - Add ::scope method (inspired by ActiveRecord) [#173](https://github.com/zilkey/active_hash/pull/173)
-  - Let `.find(nil)` raise ActiveHash::RecordNotFound (inspired by ActiveRecord) [#174](https://github.com/zilkey/active_hash/pull/174)
-  - `where` clause now works with range argument [#175](https://github.com/zilkey/active_hash/pull/175)
+  - Add ::scope method (inspired by ActiveRecord) [#173](https://github.com/active-hash/active_hash/pull/173)
+  - Let `.find(nil)` raise ActiveHash::RecordNotFound (inspired by ActiveRecord) [#174](https://github.com/active-hash/active_hash/pull/174)
+  - `where` clause now works with range argument [#175](https://github.com/active-hash/active_hash/pull/175)
 
 2019-03-06 (v2.2.1)
-  - Allow empty YAML [#171](https://github.com/zilkey/active_hash/pull/171) Thanks, @ppworks
+  - Allow empty YAML [#171](https://github.com/active-hash/active_hash/pull/171) Thanks, @ppworks
 
 2018-11-22 (v2.2.0)
-  - Support pluck method [#164](https://github.com/zilkey/active_hash/pull/164) Thanks, @ihatov08
-  - Support where.not method [#167](https://github.com/zilkey/active_hash/pull/167) Thanks, @DialBird
+  - Support pluck method [#164](https://github.com/active-hash/active_hash/pull/164) Thanks, @ihatov08
+  - Support where.not method [#167](https://github.com/active-hash/active_hash/pull/167) Thanks, @DialBird
 
 2018-04-05 (v2.1.0)
-  - Allow to use ERB (embedded ruby) in yml files [#160](https://github.com/zilkey/active_hash/pull/160) Thanks, @UgoMare
-  - Add `ActiveHash::Base.polymorphic_name` [#162](https://github.com/zilkey/active_hash/pull/162)
-  - Fix to be able to use enum accessor constant with same name as top-level constant[#161](https://github.com/zilkey/active_hash/pull/161) Thanks, @yujideveloper
+  - Allow to use ERB (embedded ruby) in yml files [#160](https://github.com/active-hash/active_hash/pull/160) Thanks, @UgoMare
+  - Add `ActiveHash::Base.polymorphic_name` [#162](https://github.com/active-hash/active_hash/pull/162)
+  - Fix to be able to use enum accessor constant with same name as top-level constant[#161](https://github.com/active-hash/active_hash/pull/161) Thanks, @yujideveloper
 
 2018-02-27 (v2.0.0)
-  - Drop old Ruby and Rails support [#157](https://github.com/zilkey/active_hash/pull/157)
-  - Don't generate instance accessors for class attributes [#136](https://github.com/zilkey/active_hash/pull/136) Thanks, @rainhead
+  - Drop old Ruby and Rails support [#157](https://github.com/active-hash/active_hash/pull/157)
+  - Don't generate instance accessors for class attributes [#136](https://github.com/active-hash/active_hash/pull/136) Thanks, @rainhead
 
 2017-06-14 (v1.5.3)
-  - Support symbol values in where and find_by [#156](https://github.com/zilkey/active_hash/pull/156) Thanks, @south37
+  - Support symbol values in where and find_by [#156](https://github.com/active-hash/active_hash/pull/156) Thanks, @south37
 
 2017-06-14 (v1.5.2)
-  - Fix find_by when passed an invalid id [#152](https://github.com/zilkey/active_hash/pull/152) Thanks, @davidstosik
+  - Fix find_by when passed an invalid id [#152](https://github.com/active-hash/active_hash/pull/152) Thanks, @davidstosik
 
 2017-04-20 (v1.5.1)
-  - Fix a bug on `.where` [#147](https://github.com/zilkey/active_hash/pull/147)
+  - Fix a bug on `.where` [#147](https://github.com/active-hash/active_hash/pull/147)
 
 2017-03-24 (v1.5.0)
   - add support for `.find_by!`(@syguer)
@@ -114,7 +140,7 @@
 
 2011-01-22
   - improved method_missing errors for dynamic finders
-  - prevent users from trying to overwrite :attributes (https://github.com/zilkey/active_hash/issues/#issue/33)
+  - prevent users from trying to overwrite :attributes (https://github.com/active-hash/active_hash/issues/#issue/33)
 
 2010-12-08
   - ruby 1.9.2 compatibility

data/README.md

@@ -1,6 +1,6 @@
 # ActiveHash
 
-[![Build Status](https://travis-ci.org/zilkey/active_hash.png?branch=master)](https://travis-ci.org/zilkey/active_hash)
+[![Build Status](https://github.com/active-hash/active_hash/actions/workflows/ruby.yml/badge.svg)](https://github.com/active-hash/active_hash/actions/workflows/ruby.yml)
 
 ActiveHash is a simple base class that allows you to use a ruby hash as a readonly datasource for an ActiveRecord-like model.
 
@@ -14,6 +14,14 @@ ActiveHash also ships with:
 
   * ActiveFile: a base class that you can use to create file data sources
   * ActiveYaml: a base class that will turn YAML into a hash and load the data into an ActiveHash object
+F
+## !!! Important notice !!!
+We have changed returned value to chainable by v3.0.0. It's not just an `Array` instance anymore.
+If it breaks your application, please report us on [issues](https://github.com/active-hash/active_hash/issues), and use v2.x.x as following..
+
+```ruby
+gem 'active_hash', '~> 2.3.0'
+```
 
 ## Installation
 
@@ -123,7 +131,7 @@ NOTE: auto-defined fields will _not_ override fields you've defined, either on t
 If some of your hash values contain nil, and you want to provide a default, you can specify defaults with the :field method:
 ```ruby
 class Country < ActiveHash::Base
-  field   :is_axis_of_evil, :default => false
+  field :is_axis_of_evil, :default => false
 end
 ```
 ## Defining Data
@@ -156,11 +164,13 @@ Country.find 1                 # => returns the first country object with that i
 Country.find [1,2]             # => returns all Country objects with ids in the array
 Country.find :all              # => same as .all
 Country.find :all, args        # => the second argument is totally ignored, but allows it to play nicely with AR
+Country.find { |country| country.name.start_with?('U') } # => returns the first country for which the block evaluates to true
 Country.find_by_id 1           # => find the first object that matches the id
 Country.find_by(name: 'US')    # => returns the first country object with specified argument
 Country.find_by!(name: 'US')   # => same as find_by, but raise exception when not found
 Country.where(name: 'US')      # => returns all records with name: 'US'
 Country.where.not(name: 'US')  # => returns all records without name: 'US'
+Country.order(name: :desc)     # => returns all records ordered by name attribute in DESC order
 ```
 It also gives you a few dynamic finder methods.  For example, if you defined :name as a field, you'd get:
 ```ruby
@@ -198,16 +208,24 @@ Country#name=       # => sets the name
 ```
 ## Saving in-memory records
 
-The ActiveHash::Base.all method functions like an in-memory data store.  You can save your records to the the .all array by using standard ActiveRecord create and save methods:
+The ActiveHash::Base.all method functions like an in-memory data store. You can save your records as ActiveHash::Relation object by using standard ActiveRecord create and save methods:
 ```ruby
-Country.all             # => []
+Country.all
+=> #<ActiveHash::Relation:0x00007f861e043bb0 @klass=Country, @all_records=[], @query_hash={}, @records_dirty=false>
 Country.create
-Country.all             # [ <Country :id => 1> ]
+=> #<Country:0x00007f861b7abce8 @attributes={:id=>1}>
+Country.all
+=> #<ActiveHash::Relation:0x00007f861b7b3628 @klass=Country, @all_records=[#<Country:0x00007f861b7abce8 @attributes={:id=>1}>], @query_hash={}, @records_dirty=false>
 country = Country.new
-country.new_record?     # => true
+=> #<Country:0x00007f861e059938 @attributes={}>
+country.new_record?
+=> true
 country.save
-country.new_record?     # => false
-Country.all             # [ <Country :id => 1>, <Country :id => 2>  ]
+=> true
+country.new_record?
+# => false
+Country.all
+=> #<ActiveHash::Relation:0x00007f861e0ca610 @klass=Country, @all_records=[#<Country:0x00007f861b7abce8 @attributes={:id=>1}>, #<Country:0x00007f861e059938 @attributes={:id=>2}>], @query_hash={}, @records_dirty=false>
 ```
 Notice that when adding records to the collection, it will auto-increment the id for you by default.  If you use string ids, it will not auto-increment the id.  Available methods are:
 ```
@@ -331,7 +349,7 @@ end
 The above example will look for the file "/u/data/sample.yml".
 
 Since ActiveYaml just creates a hash from the YAML file, you will have all fields specified in YAML auto-defined for you.  You can format your YAML as an array, or as a hash:
-```
+```yaml
 # array style
 - id: 1
   name: US
@@ -351,6 +369,35 @@ mexico:
   id: 3
   name: Mexico
 ```
+
+### Automatic Key Attribute
+
+When using the hash format for your YAML file, ActiveYaml will automatically add a `key` attribute with the name of the object.  You can overwrite this by setting the key attribute in the YAML file.
+For example:
+```
+au:
+  id: 1
+  name: Australia
+```
+
+When you access the object you can do `Country.find(1).key => 'au'`. Or `Country.find_by_key('au')`
+
+If you want a different key on only some objects you can mix and match:
+
+```
+au:
+  id: 1
+  key: aus
+  name: Australia
+nz:
+  id: 2
+  name: New Zealand
+```
+
+`Country.find(1).key => 'aus'`
+
+`Country.find(2).key => 'nz'`
+
 ### Multiple files per model
 
 You can use multiple files to store your data. You will have to choose between hash or array style as you cannot use both for one model.
@@ -364,7 +411,7 @@ end
 
 Aliases can be used in ActiveYaml using either array or hash style by including `ActiveYaml::Aliases`.
 With that module included, keys beginning with a '/' character can be safely added, and will be ignored, allowing you to add aliases anywhere in your code:
-```
+```yaml
 # Array Style
 - /aliases:
   soda_flavor: &soda_flavor
@@ -390,7 +437,8 @@ coke:
   name: Coke
   flavor: *soda_flavor
   price: *soda_price
-
+```
+```ruby
 class Soda < ActiveYaml::Base
   include ActiveYaml::Aliases
 end
@@ -402,9 +450,9 @@ Soda.first.price # => 1.0
 
 ### Using ERB ruby in YAML
 
-Embedded ruby can bu used in ActiveYaml using erb brackets `<% %>` and `<%= %>` to set the result of a ruby operation as a value in the yaml file.
+Embedded ruby can be used in ActiveYaml using erb brackets `<% %>` and `<%= %>` to set the result of a ruby operation as a value in the yaml file.
 
-```
+```yaml
 - id: 1
   email: <%= "user#{rand(100)}@email.com" %>
   password: <%= ENV['USER_PASSWORD'] %>
@@ -474,7 +522,7 @@ class Country < ActiveFile::Base
 
   class << self
     def extension
-      ".super_secret"
+      "super_secret"
     end
 
     def load_file

data/active_hash.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |s|
   s.email = %q{jeff@zilkey.com}
   s.summary = %q{An ActiveRecord-like model that uses a hash or file as a datasource}
   s.description = %q{Includes the ability to specify data using hashes, yml files or JSON files}
-  s.homepage = %q{http://github.com/zilkey/active_hash}
+  s.homepage = %q{http://github.com/active-hash/active_hash}
   s.license = "MIT"
 
   s.files = [
@@ -45,5 +45,6 @@ Gem::Specification.new do |s|
   ].flatten
   s.test_files = s.files.grep(%r{^(test|spec|features)/})
   s.add_runtime_dependency('activesupport', '>= 5.0.0')
+  s.add_development_dependency "pry"
   s.required_ruby_version = '>= 2.4.0'
 end

data/lib/active_file/base.rb

@@ -47,9 +47,9 @@ module ActiveFile
       protected :actual_root_path
 
       [:find, :find_by_id, :all, :where, :method_missing].each do |method|
-        define_method(method) do |*args|
+        define_method(method) do |*args, &block|
           reload unless data_loaded
-          return super(*args)
+          return super(*args, &block)
         end
       end
 

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
@@ -14,7 +22,7 @@ module ActiveHash
 
   class Base
 
-    class_attribute :_data, :dirty, :default_attributes
+    class_attribute :_data, :dirty, :default_attributes, :scopes
 
     class WhereChain
       def initialize(scope)
@@ -23,18 +31,19 @@ module ActiveHash
       end
 
       def not(options)
-        return @records if options.blank?
+        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?
 
-        (candidates || @records || []).reject do |record|
-          match_options?(record, options)
+        filtered_records = (candidates || @records || []).reject do |record|
+          options.present? && match_options?(record, options)
         end
+
+        ActiveHash::Relation.new(@scope.klass, filtered_records, {})
       end
 
       def match_options?(record, options)
@@ -182,76 +191,11 @@ module ActiveHash
         record
       end
 
-      def all(options={})
-        if options.has_key?(:conditions)
-          where(options[:conditions])
-        else
-          @records ||= []
-        end
-      end
-
-      def where(options = :chain)
-        if options == :chain
-          return WhereChain.new(self)
-        elsif options.blank?
-          return @records
-        end
-
-        # use index if searching by id
-        if options.key?(:id) || options.key?("id")
-          ids = (options.delete(:id) || options.delete("id"))
-          ids = range_to_array(ids) if ids.is_a?(Range)
-          candidates = Array.wrap(ids).map { |id| find_by_id(id) }.compact
-        end
-        return candidates if options.blank?
-
-        (candidates || @records || []).select do |record|
-          match_options?(record, options)
-        end
-      end
-
-      def find_by(options)
-        where(options).first
-      end
-
-      def find_by!(options)
-        find_by(options) || (raise RecordNotFound.new("Couldn't find #{name}"))
-      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
-
-      def range_to_array(range)
-        return range.to_a unless range.end.nil?
-
-        e = data.last[:id]
-        (range.begin..e).to_a
-      end
-
-      private :range_to_array
-
-      def count
-        all.length
+      def all(options = {})
+        ActiveHash::Relation.new(self, @records || [], options[:conditions] || {})
       end
 
-      def pluck(*column_names)
-        column_names.map { |column_name| all.map(&column_name.to_sym) }.inject(&:zip)
-      end
+      delegate :where, :find, :find_by, :find_by!, :find_by_id, :count, :pluck, :ids, :pick, :first, :last, :order, to: :all
 
       def transaction
         yield
@@ -269,30 +213,6 @@ module ActiveHash
         @records = []
       end
 
-      def find(id, * args)
-        case id
-          when :all
-            all
-          when :first
-            all(*args).first
-          when Array
-            id.map { |i| find(i) }
-          when nil
-            raise RecordNotFound.new("Couldn't find #{name} without an ID")
-          else
-            find_by_id(id) || begin
-              raise RecordNotFound.new("Couldn't find #{name} with ID=#{id}")
-            end
-        end
-      end
-
-      def find_by_id(id)
-        index = record_index[id.to_s]
-        index and @records[index]
-      end
-
-      delegate :first, :last, :to => :all
-
       def fields(*args)
         options = args.extract_options!
         args.each do |field|
@@ -475,10 +395,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)

data/lib/active_hash/relation.rb

@@ -0,0 +1,202 @@
+module ActiveHash
+  class Relation
+    include Enumerable
+
+    delegate :each, to: :records # Make Enumerable work
+    delegate :equal?, :==, :===, :eql?, :sort!, to: :records
+    delegate :empty?, :length, :first, :second, :third, :last, to: :records
+    delegate :sample, to: :records
+
+    def initialize(klass, all_records, query_hash = nil)
+      self.klass = klass
+      self.all_records = all_records
+      self.query_hash = query_hash
+      self.records_dirty = false
+      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 || {})
+      self
+    end
+
+    def all(options = {})
+      if options.has_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}", klass.name))
+    end
+
+    def find(id = nil, *args, &block)
+      case id
+        when :all
+          all
+        when :first
+          all(*args).first
+        when Array
+          id.map { |i| find(i) }
+        when nil
+          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}", klass.name, "id", id)
+          end
+      end
+    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]
+    end
+
+    def count
+      length
+    end
+
+    def size
+      length
+    end
+
+    def pluck(*column_names)
+      column_names.map { |column_name| all.map(&column_name.to_sym) }.inject(&:zip)
+    end
+
+    def ids
+      pluck(:id)
+    end
+
+    def pick(*column_names)
+      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)
+
+      instance_exec(*args, &self.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
+    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
+    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(match) === normalize(record[col])
+        end
+      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?
+
+      raise ArgumentError,
+            "The method .#{method_name}() must contain arguments."
+    end
+
+    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 order_by_args!(candidates, args)
+      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
+
+        candidates.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
+    end
+  end
+end

data/lib/active_hash/version.rb

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

data/lib/active_hash.rb

@@ -12,6 +12,7 @@ rescue LoadError
 end
 
 require 'active_hash/base'
+require 'active_hash/relation'
 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

@@ -9,7 +9,7 @@ module ActiveYaml
         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 +18,15 @@ module ActiveYaml
       end
 
       private
+if Psych::VERSION >= "4.0.0"
+      def load_path(path)
+        YAML.unsafe_load(ERB.new(File.read(path)).result)
+      end
+else
       def load_path(path)
         YAML.load(ERB.new(File.read(path)).result)
       end
+end
     end
   end
 end

data/lib/associations/associations.rb

@@ -3,10 +3,7 @@ module ActiveHash
 
     module ActiveRecordExtensions
 
-      def belongs_to(*args)
-        our_args = args.dup
-        options = our_args.extract_options!
-        name = our_args.shift
+      def belongs_to(name, scope = nil, **options)
         options = {:class_name => name.to_s.camelize }.merge(options)
         klass =
           begin
@@ -19,7 +16,7 @@ module ActiveHash
         if klass && klass < ActiveHash::Base
           belongs_to_active_hash(name, options)
         else
-          super
+          super(name, **options)
         end
       end
 
@@ -119,7 +116,8 @@ module ActiveHash
         define_method(association_id) do
           options = {
             :class_name => association_id.to_s.classify,
-            :foreign_key => self.class.to_s.foreign_key
+            :foreign_key => self.class.to_s.foreign_key,
+            :primary_key => self.class.primary_key
           }.merge(options)
 
           scope = options[:class_name].constantize
@@ -127,7 +125,7 @@ module ActiveHash
           if scope.respond_to?(:scoped) && options[:conditions]
             scope = scope.scoped(:conditions => options[:conditions])
           end
-          scope.send("find_by_#{options[:foreign_key]}", id)
+          scope.send("find_by_#{options[:foreign_key]}", send(options[:primary_key]))
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_hash
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Jeff Dean
@@ -26,10 +26,10 @@ authors:
 - Brett Richardson
 - Rachel Heaton
 - Keisuke Izumiya
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-09-28 00:00:00.000000000 Z
+date: 2022-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -45,6 +45,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Includes the ability to specify data using hashes, yml files or JSON
   files
 email: jeff@zilkey.com
@@ -61,17 +75,18 @@ files:
 - lib/active_file/multiple_files.rb
 - lib/active_hash.rb
 - lib/active_hash/base.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/enum/enum.rb
-homepage: http://github.com/zilkey/active_hash
+homepage: http://github.com/active-hash/active_hash
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -86,9 +101,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: An ActiveRecord-like model that uses a hash or file as a datasource
 test_files: []