active_hash 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07f278485648e475f69c32f40ae5f647a7e275c5
-  data.tar.gz: 04811d2113fdf923916200ebfe3966f6f6d3e4be
+  metadata.gz: 652802c90d3e70506b8997f124021284e8b073be
+  data.tar.gz: a4b876f9bc3c7316c6d12f3945e2b74b20b8a11f
 SHA512:
-  metadata.gz: 76e9b4d4d67e4863473388961024dd66af1b2b81771798f1fb24417060ffd93b93887dadea24dce45cde7d13ccf0759c93775710987281ed18a05009bb083bb1
-  data.tar.gz: c29c149a4db09945d9c616d616223b629771d74316d43465d6b412b7b02b0146fe09f37270734579bc11b77b71315cde671387ea1cace714f39eb9c1bff92b8c
+  metadata.gz: 53e0ad1f1e45a7adb6cd51ea367102ec959a21c19245d52ec9534c6976754fdf888efe3da463818ff1c14c9c0048fa2c0e51a9b4164857ee811076eb6af11612
+  data.tar.gz: cb66a911b00f3b9b4c25de6485fc0e7b9fff3b66efeabd5e70a5dcf52134afba7d990951cc232beaec45dc4ed12b1760c3fe79e1a818b7d317bd8f6a15692d67

data/CHANGELOG

@@ -1,3 +1,7 @@
+2015-09-13 (v1.4.1)
+  - fix bug where `#attributes` didn't contain default values #107
+  - add support for `.find_by` and `#_read_attribute`. Thanks, @andrewfader!
+
 2014-09-03 (v1.4.0)
   - support Rails 4.2 (agraves, al2o3cr)
 

data/README.md

@@ -18,38 +18,38 @@ ActiveHash also ships with:
 ## Installation
 
 Bundler:
-
-    gem 'active_hash'
-
+```ruby
+gem 'active_hash'
+```
 Other:
-
-    gem install active_hash
-
+```ruby
+gem install active_hash
+```
 ## Reason for being
 
 We wrote ActiveHash so that we could use simple, in-memory, ActiveRecord-like data structures that play well with Rails forms, like:
-
-    # in app/models/country.rb
-    class Country < ActiveHash::Base
-      self.data = [
-        {:id => 1, :name => "US"},
-        {:id => 2, :name => "Canada"}
-      ]
-    end
-
-    # in some view
-    <%= collection_select :person, :country_id, Country.all, :id, :name %>
-
+```ruby
+# in app/models/country.rb
+class Country < ActiveHash::Base
+  self.data = [
+    {:id => 1, :name => "US"},
+    {:id => 2, :name => "Canada"}
+  ]
+end
+
+# in some view
+<%= collection_select :person, :country_id, Country.all, :id, :name %>
+```
 Before ActiveHash, we did things like:
-
-    # in app/models/person.rb
-    class Person < ActiveRecord::Base
-      COUNTRIES = ["US", "Canada"]
-    end
-
-    # in some view
-    <%= collection_select :person, :country_id, Person::COUNTRIES, :to_s, :to_s %>
-
+```ruby
+# in app/models/person.rb
+class Person < ActiveRecord::Base
+  COUNTRIES = ["US", "Canada"]
+end
+
+# in some view
+<%= collection_select :person, :country_id, Person::COUNTRIES, :to_s, :to_s %>
+```
 The majority of ActiveHash uses involve setting up some data at boot time, and never modifying that data at runtime.
 
 ## Usage
@@ -61,261 +61,261 @@ To use ActiveHash, you need to:
  * Define your fields and/or default values
 
 A quick example would be:
-
-    class Country < ActiveHash::Base
-      self.data = [
-        {:id => 1, :name => "US"},
-        {:id => 2, :name => "Canada"}
-      ]
-    end
-
-    country = Country.new(:name => "Mexico")
-    country.name  # => "Mexico"
-    country.name? # => true
-
+```ruby
+class Country < ActiveHash::Base
+  self.data = [
+    {:id => 1, :name => "US"},
+    {:id => 2, :name => "Canada"}
+  ]
+end
+
+country = Country.new(:name => "Mexico")
+country.name  # => "Mexico"
+country.name? # => true
+```
 You can also use _create_:
-
-    class Country < ActiveHash::Base
-      field :name
-      create :id => 1, :name => "US"
-      create :id => 2, :name => "Canada"
-    end
-
+```ruby
+class Country < ActiveHash::Base
+  field :name
+  create :id => 1, :name => "US"
+  create :id => 2, :name => "Canada"
+end
+```
 You can also use _add_:
-
-    class Country < ActiveHash::Base
-      field :name
-      add :id => 1, :name => "US"
-      add :id => 2, :name => "Canada"
-    end
-
+```ruby
+class Country < ActiveHash::Base
+  field :name
+  add :id => 1, :name => "US"
+  add :id => 2, :name => "Canada"
+end
+```
 ## Auto-Defined fields
 
 ActiveHash will auto-define all fields for you when you load the hash.  For example, if you have the following class:
-
-    class CustomField < ActiveHash::Base
-      self.data = [
-        {:custom_field_1 => "foo"},
-        {:custom_field_2 => "foo"},
-        {:custom_field_3 => "foo"}
-      ]
-    end
-
+```ruby
+class CustomField < ActiveHash::Base
+  self.data = [
+    {:custom_field_1 => "foo"},
+    {:custom_field_2 => "foo"},
+    {:custom_field_3 => "foo"}
+  ]
+end
+```
 Once you call CustomField.all it will define methods for :custom_field_1, :custom_field_2 etc...
 
 If you need the fields at load time, as opposed to after .all is called, you can also define them manually, like so:
-
-    class CustomField < ActiveHash::Base
-      fields :custom_field_1, :custom_field_2, :custom_field_3
-    end
-
+```ruby
+class CustomField < ActiveHash::Base
+  fields :custom_field_1, :custom_field_2, :custom_field_3
+end
+```
 NOTE: auto-defined fields will _not_ override fields you've defined, either on the class or on the instance.
 
 ## Defining Fields with default values
 
 If some of your hash values contain nil, and you want to provide a default, you can specify defaults with the :field method:
-
-    class Country < ActiveHash::Base
-      field   :is_axis_of_evil, :default => false
-    end
-
+```ruby
+class Country < ActiveHash::Base
+  field   :is_axis_of_evil, :default => false
+end
+```
 ## Defining Data
 
 You can define data inside your class or outside.  For example, you might have a class like this:
-
-    # app/models/country.rb
-    class Country < ActiveHash::Base
-    end
-
-    # config/initializers/data.rb
-    Rails.application.config.to_prepare do
-      Country.data = [
-          {:id => 1, :name => "US"},
-          {:id => 2, :name => "Canada"}
-      ]
-    end
-
+```ruby
+# app/models/country.rb
+class Country < ActiveHash::Base
+end
+
+# config/initializers/data.rb
+Rails.application.config.to_prepare do
+  Country.data = [
+      {:id => 1, :name => "US"},
+      {:id => 2, :name => "Canada"}
+  ]
+end
+```
 If you prefer to store your data in YAML, see below.
 
 ## Class Methods
 
 ActiveHash gives you ActiveRecord-esque methods like:
-
-    Country.all             # => returns all Country objects
-    Country.count           # => returns the length of the .data array
-    Country.first           # => returns the first country object
-    Country.last            # => returns the last country object
-    Country.find 1          # => returns the first country object with that id
-    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_by_id 1    # => find the first object that matches the id
-
+```ruby
+Country.all             # => returns all Country objects
+Country.count           # => returns the length of the .data array
+Country.first           # => returns the first country object
+Country.last            # => returns the last country object
+Country.find 1          # => returns the first country object with that id
+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_by_id 1    # => find the first object that matches the id
+```
 It also gives you a few dynamic finder methods.  For example, if you defined :name as a field, you'd get:
-
-    Country.find_by_name "foo"                    # => returns the first object matching that name
-    Country.find_all_by_name "foo"                # => returns an array of the objects with matching names
-    Country.find_by_id_and_name 1, "Germany"      # => returns the first object matching that id and name
-    Country.find_all_by_id_and_name 1, "Germany"  # => returns an array of objects matching that name and id
-
+```ruby
+Country.find_by_name "foo"                    # => returns the first object matching that name
+Country.find_all_by_name "foo"                # => returns an array of the objects with matching names
+Country.find_by_id_and_name 1, "Germany"      # => returns the first object matching that id and name
+Country.find_all_by_id_and_name 1, "Germany"  # => returns an array of objects matching that name and id
+```
 ## Instance Methods
 
 ActiveHash objects implement enough of the ActiveRecord api to satisfy most common needs.  For example:
-
-    Country#id          # => returns the id or nil
-    Country#id=         # => sets the id attribute
-    Country#quoted_id   # => returns the numeric id
-    Country#to_param    # => returns the id as a string
-    Country#new_record? # => returns true if is not part of Country.all, false otherwise
-    Country#readonly?   # => true
-    Country#hash        # => the hash of the id (or the hash of nil)
-    Country#eql?        # => compares type and id, returns false if id is nil
-
+```
+Country#id          # => returns the id or nil
+Country#id=         # => sets the id attribute
+Country#quoted_id   # => returns the numeric id
+Country#to_param    # => returns the id as a string
+Country#new_record? # => returns true if is not part of Country.all, false otherwise
+Country#readonly?   # => true
+Country#hash        # => the hash of the id (or the hash of nil)
+Country#eql?        # => compares type and id, returns false if id is nil
+```
 ActiveHash also gives you methods related to the fields you defined.  For example, if you defined :name as a field, you'd get:
-
-    Country#name        # => returns the passed in name
-    Country#name?       # => returns true if the name is not blank
-    Country#name=       # => sets the name
-
+```
+Country#name        # => returns the passed in name
+Country#name?       # => returns true if the name is not blank
+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:
-
-    Country.all             # => []
-    Country.create
-    Country.all             # [ <Country :id => 1> ]
-    country = Country.new
-    country.new_record?     # => true
-    country.save
-    country.new_record?     # => false
-    Country.all             # [ <Country :id => 1>, <Country :id => 2>  ]
-
+```ruby
+Country.all             # => []
+Country.create
+Country.all             # [ <Country :id => 1> ]
+country = Country.new
+country.new_record?     # => true
+country.save
+country.new_record?     # => false
+Country.all             # [ <Country :id => 1>, <Country :id => 2>  ]
+```
 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:
-
-    Country.insert( record )
-    Country#save
-    Country#save!
-    Country.create
-    Country.create!
-
+```
+Country.insert( record )
+Country#save
+Country#save!
+Country.create
+Country.create!
+```
 As such, ActiveHash::Base and its descendants should work with Fixjour or FactoryGirl, so you can treat ActiveHash records the same way you would any other ActiveRecord model in tests.
 
 To clear all records from the in-memory array, call delete_all:
-
-    Country.delete_all  # => does not affect the yaml files in any way - just clears the in-memory array which can be useful for testing
-
+```ruby
+Country.delete_all  # => does not affect the yaml files in any way - just clears the in-memory array which can be useful for testing
+```
 ## Referencing ActiveHash objects from ActiveRecord Associations
 
 One common use case for ActiveHash is to have top-level objects in memory that ActiveRecord objects belong to.
 
 In versions of ActiveRecord previous to 3.1, you should be able to do the following:
-
-    class Country < ActiveHash::Base
-    end
-
-    class Person < ActiveRecord::Base
-      belongs_to :country
-    end
-
+```ruby
+class Country < ActiveHash::Base
+end
+
+class Person < ActiveRecord::Base
+  belongs_to :country
+end
+```
 However, as of ActiveRecord 3.1 support for ActiveRecord's `belong_to` is broken.  Instead, you must extend ActiveHash::Associations::ActiveRecordExtensions method:
-
-    class Country < ActiveHash::Base
-    end
-
-    class Person < ActiveRecord::Base
-      extend ActiveHash::Associations::ActiveRecordExtensions
-      belongs_to :country
-    end
-
+```ruby
+class Country < ActiveHash::Base
+end
+
+class Person < ActiveRecord::Base
+  extend ActiveHash::Associations::ActiveRecordExtensions
+  belongs_to :country
+end
+```
 NOTE: this needs to be called on a subclass of ActiveRecord::Base.  If you extend ActiveRecord::Base, it will not work.
 If you want to extend ActiveRecord::Base so all your AR models can belong to ActiveHash::Base objects, you can use the
 `belongs_to_active_hash` method:
+```ruby
+ActiveRecord::Base.extend ActiveHash::Associations::ActiveRecordExtensions
 
-    ActiveRecord::Base.extend ActiveHash::Associations::ActiveRecordExtensions
-
-    class Country < ActiveHash::Base
-    end
-
-    class Person < ActiveRecord::Base
-      belongs_to_active_hash :country
-    end
+class Country < ActiveHash::Base
+end
 
+class Person < ActiveRecord::Base
+  belongs_to_active_hash :country
+end
+```
 With ActiveRecord versions < 3.1, ActiveHash will also work as a polymorphic parent:
-
-    class Country < ActiveHash::Base
-    end
-
-    class Person < ActiveRecord::Base
-      belongs_to :location, :polymorphic => true
-    end
-
-    person = Person.new
-    person.location = Country.first
-    person.save
-    person.location # => Country.first
-
+```ruby
+class Country < ActiveHash::Base
+end
+
+class Person < ActiveRecord::Base
+  belongs_to :location, :polymorphic => true
+end
+
+person = Person.new
+person.location = Country.first
+person.save
+person.location # => Country.first
+```
 However, as of ActiveRecord 3.1 this will not work.  If you need support for that, please open an issue.
 
 ### Using shortcuts
 
 Since ActiveHashes usually are static, we can use shortcuts to assign via an easy to remember string instead of an obscure ID number.
-
-    # app/models/country.rb
-    class Country < ActiveHash::Base
-    end
-
-    # app/models/person.rb
-    class Person < ActiveRecord::Base
-      extend ActiveHash::Associations::ActiveRecordExtensions
-      belongs_to_active_hash :country, :shortcuts => [:name]
-    end
-
-    # config/initializers/data.rb
-    Rails.application.config.to_prepare do
-      Country.data = [
-          {:id => 1, :name => "US"},
-          {:id => 2, :name => "Canada"}
-      ]
-    end
-
-    # Using `rails console`
-    john = Person.new
-    john.country_name = "US"
-    # Is the same as doing `john.country = Country.find_by_name("US")`
-    john.country_name
-    # Will return "US", and is the same as doing `john.country.try(:name)`
-
+```ruby
+# app/models/country.rb
+class Country < ActiveHash::Base
+end
+
+# app/models/person.rb
+class Person < ActiveRecord::Base
+  extend ActiveHash::Associations::ActiveRecordExtensions
+  belongs_to_active_hash :country, :shortcuts => [:name]
+end
+
+# config/initializers/data.rb
+Rails.application.config.to_prepare do
+  Country.data = [
+      {:id => 1, :name => "US"},
+      {:id => 2, :name => "Canada"}
+  ]
+end
+
+# Using `rails console`
+john = Person.new
+john.country_name = "US"
+# Is the same as doing `john.country = Country.find_by_name("US")`
+john.country_name
+# Will return "US", and is the same as doing `john.country.try(:name)`
+```
 You can have multiple shortcuts, so settings `:shortcuts => [:name, :friendly_name]` will enable you to use `#country_name=` and `#country_friendly_name=`.
 
 ## Referencing ActiveRecord objects from ActiveHash
 
 If you include the ActiveHash::Associations module, you can also create associations from your ActiveHash classes, like so:
-
-    class Country < ActiveHash::Base
-      include ActiveHash::Associations
-      has_many :people
-    end
-
-    class Person < ActiveHash::Base
-      include ActiveHash::Associations
-      belongs_to :country
-      has_many :pets
-    end
-
-    class Pet < ActiveRecord::Base
-    end
-
+```ruby
+class Country < ActiveHash::Base
+  include ActiveHash::Associations
+  has_many :people
+end
+
+class Person < ActiveHash::Base
+  include ActiveHash::Associations
+  belongs_to :country
+  has_many :pets
+end
+
+class Pet < ActiveRecord::Base
+end
+```
 Once you define a belongs to, you also get the setter method:
-
-    class City < ActiveHash::Base
-      include ActiveHash::Associations
-      belongs_to :state
-    end
-
-    city = City.new
-    city.state = State.first
-    city.state_id             # is State.first.id
-
+```ruby
+class City < ActiveHash::Base
+  include ActiveHash::Associations
+  belongs_to :state
+end
+
+city = City.new
+city.state = State.first
+city.state_id             # is State.first.id
+```
 NOTE:  You cannot use ActiveHash objects as children of ActiveRecord and I don't plan on adding support for that.  It doesn't really make any sense, since you'd have to hard-code your database ids in your class or yaml files, which is a dependency inversion.
 
 Thanks to baldwindavid for the ideas and code on that one.
@@ -323,138 +323,138 @@ Thanks to baldwindavid for the ideas and code on that one.
 ## ActiveYaml
 
 If you want to store your data in YAML files, just inherit from ActiveYaml and specify your path information:
-
-    class Country < ActiveYaml::Base
-    end
-
+```ruby
+class Country < ActiveYaml::Base
+end
+```
 By default, this class will look for a yml file named "countries.yml" in the same directory as the file.  You can either change the directory it looks in, the filename it looks for, or both:
-
-    class Country < ActiveYaml::Base
-      set_root_path "/u/data"
-      set_filename "sample"
-    end
-
+```ruby
+class Country < ActiveYaml::Base
+  set_root_path "/u/data"
+  set_filename "sample"
+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:
-
-    # array style
-    - id: 1
-      name: US
-    - id: 2
-      name: Canada
-    - id: 3
-      name: Mexico
-
-    # hash style
-    us:
-      id: 1
-      name: US
-    canada:
-      id: 2
-      name: Canada
-    mexico:
-      id: 3
-      name: Mexico
-
+```
+# array style
+- id: 1
+  name: US
+- id: 2
+  name: Canada
+- id: 3
+  name: Mexico
+
+# hash style
+us:
+  id: 1
+  name: US
+canada:
+  id: 2
+  name: Canada
+mexico:
+  id: 3
+  name: Mexico
+```
 ### 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.
-
-    class Country < ActiveYaml::Base
-      use_mutliple_files
-      set_filenames "europe", "america", "asia", "africa"
-    end
-
+```ruby
+class Country < ActiveYaml::Base
+  use_mutliple_files
+  set_filenames "europe", "america", "asia", "africa"
+end
+```
 ### Using aliases in YAML
 
 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:
-
-    # Array Style
-    - /aliases:
-      soda_flavor: &soda_flavor
-        sweet
-      soda_price: &soda_price
-        1.0
-
-    - id: 1
-      name: Coke
-      flavor: *soda_flavor
-      price: *soda_price
-
-
-     # Key style
-    /aliases:
-      soda_flavor: &soda_flavor
-        sweet
-      soda_price: &soda_price
-        1.0
-
-    coke:
-      id: 1
-      name: Coke
-      flavor: *soda_flavor
-      price: *soda_price
-
-    class Soda < ActiveYaml::Base
-      include ActiveYaml::Aliases
-    end
-
-    Soda.length # => 1
-    Soda.first.flavor # => sweet
-    Soda.first.price # => 1.0
-
+```
+# Array Style
+- /aliases:
+  soda_flavor: &soda_flavor
+    sweet
+  soda_price: &soda_price
+    1.0
+
+- id: 1
+  name: Coke
+  flavor: *soda_flavor
+  price: *soda_price
+
+
+ # Key style
+/aliases:
+  soda_flavor: &soda_flavor
+    sweet
+  soda_price: &soda_price
+    1.0
+
+coke:
+  id: 1
+  name: Coke
+  flavor: *soda_flavor
+  price: *soda_price
+
+class Soda < ActiveYaml::Base
+  include ActiveYaml::Aliases
+end
+
+Soda.length # => 1
+Soda.first.flavor # => sweet
+Soda.first.price # => 1.0
+```
 ## ActiveJSON
 
 If you want to store your data in JSON files, just inherit from ActiveJSON and specify your path information:
-
-    class Country < ActiveJSON::Base
-    end
-
+```ruby
+class Country < ActiveJSON::Base
+end
+```
 By default, this class will look for a json file named "countries.json" in the same directory as the file.  You can either change the directory it looks in, the filename it looks for, or both:
-
-    class Country < ActiveJSON::Base
-      set_root_path "/u/data"
-      set_filename "sample"
-    end
-
+```ruby
+class Country < ActiveJSON::Base
+  set_root_path "/u/data"
+  set_filename "sample"
+end
+```
 The above example will look for the file "/u/data/sample.json".
 
 Since ActiveJSON just creates a hash from the JSON file, you will have all fields specified in JSON auto-defined for you.  You can format your JSON as an array, or as a hash:
-
-    # array style
-    [
-      {
-        "id": 1,
-        "name": "US",
-        "custom_field_1": "value1"
-      },
-      {
-        "id": 2,
-        "name": "Canada",
-        "custom_field_2": "value2"
-      }
-    ]
-
-    # hash style
-     {
-      { "us":
-        {
-          "id": 1,
-          "name": "US",
-          "custom_field_1": "value1"
-        }
-      },
-      { "canada":
-        {
-          "id": 2,
-          "name": "Canada",
-          "custom_field_2": "value2"
-        }
-      }
+```ruby
+# array style
+[
+  {
+    "id": 1,
+    "name": "US",
+    "custom_field_1": "value1"
+  },
+  {
+    "id": 2,
+    "name": "Canada",
+    "custom_field_2": "value2"
+  }
+]
+
+# hash style
+ {
+  { "us":
+    {
+      "id": 1,
+      "name": "US",
+      "custom_field_1": "value1"
     }
-
+  },
+  { "canada":
+    {
+      "id": 2,
+      "name": "Canada",
+      "custom_field_2": "value2"
+    }
+  }
+}
+```
 ### Multiple files per model
 
   This works as it does for `ActiveYaml`
@@ -462,29 +462,29 @@ Since ActiveJSON just creates a hash from the JSON file, you will have all field
 ## ActiveFile
 
 If you store encrypted data, or you'd like to store your flat files as CSV or XML or any other format, you can easily include ActiveHash to parse and load your file.  Just add a custom ::load_file method, and define the extension you want the file to use:
+```ruby
+class Country < ActiveFile::Base
+  set_root_path "/u/data"
+  set_filename "sample"
 
-    class Country < ActiveFile::Base
-      set_root_path "/u/data"
-      set_filename "sample"
-
-      class << self
-        def extension
-          ".super_secret"
-        end
-
-        def load_file
-          MyAwesomeDecoder.load_file(full_path)
-        end
-      end
+  class << self
+    def extension
+      ".super_secret"
     end
 
+    def load_file
+      MyAwesomeDecoder.load_file(full_path)
+    end
+  end
+end
+```
 The two methods you need to implement are load_file, which needs to return an array of hashes, and .extension, which returns the file extension you are using.  You have full_path available to you if you wish, or you can provide your own path.
 
 Setting the default file location in Rails:
-
-    # config/initializers/active_file.rb
-    ActiveFile::Base.set_root_path "config/activefiles"
-
+```ruby
+# config/initializers/active_file.rb
+ActiveFile::Base.set_root_path "config/activefiles"
+```
 In Rails, in development mode, it reloads the entire class, which reloads the file.  In production, the data cached in memory.
 
 NOTE:  By default, .full_path refers to the current working directory.  In a rails app, this will be RAILS_ROOT.
@@ -494,17 +494,17 @@ NOTE:  By default, .full_path refers to the current working directory.  In a rai
 ActiveHash can expose its data in an Enumeration by setting constants for each record. This allows records to be accessed in code through a constant set in the ActiveHash class.
 
 The field to be used as the constant is set using _enum_accessor_ which takes the name of a field as an argument.
-
-    class Country < ActiveHash::Base
-      include ActiveHash::Enum
-      self.data = [
-          {:id => 1, :name => "US", :capital => "Washington, DC"},
-          {:id => 2, :name => "Canada", :capital => "Ottawa"},
-          {:id => 3, :name => "Mexico", :capital => "Mexico City"}
-      ]
-      enum_accessor :name
-    end
-
+```ruby
+class Country < ActiveHash::Base
+  include ActiveHash::Enum
+  self.data = [
+      {:id => 1, :name => "US", :capital => "Washington, DC"},
+      {:id => 2, :name => "Canada", :capital => "Ottawa"},
+      {:id => 3, :name => "Mexico", :capital => "Mexico City"}
+  ]
+  enum_accessor :name
+end
+```
 Records can be accessed by looking up the field constant:
 
     >> Country::US.capital
@@ -515,19 +515,19 @@ Records can be accessed by looking up the field constant:
     => #<Country:0x10229fb28 @attributes={:name=>"Canada", :id=>2}
 
 You may also use multiple attributes to generate the constant, like so:
-
-    class Town < ActiveHash::Base
-      include ActiveHash::Enum
-      self.data = [
-          {:id => 1, :name => "Columbus", :state => "NY"},
-          {:id => 2, :name => "Columbus", :state => "OH"}
-      ]
-      enum_accessor :name, :state
-    end
-
-    >> Town::COLUMBUS_NY
-    >> Town::COLUMBUS_OH
-
+```ruby
+class Town < ActiveHash::Base
+  include ActiveHash::Enum
+  self.data = [
+      {:id => 1, :name => "Columbus", :state => "NY"},
+      {:id => 2, :name => "Columbus", :state => "OH"}
+  ]
+  enum_accessor :name, :state
+end
+
+>> Town::COLUMBUS_NY
+>> Town::COLUMBUS_OH
+```
 Constants are formed by first stripping all non-word characters and then upcasing the result. This means strings like "Blazing Saddles", "ReBar", "Mike & Ike" and "Ho! Ho! Ho!" become BLAZING_SADDLES, REBAR, MIKE_IKE and HO_HO_HO.
 
 The field specified as the _enum_accessor_ must contain unique data values.

data/lib/active_hash/base.rb

@@ -15,9 +15,9 @@ module ActiveHash
   class Base
 
     if respond_to?(:class_attribute)
-      class_attribute :_data, :dirty
+      class_attribute :_data, :dirty, :default_attributes
     else
-      class_inheritable_accessor :_data, :dirty
+      class_inheritable_accessor :_data, :dirty, :default_attributes
     end
 
     if Object.const_defined?(:ActiveModel)
@@ -35,7 +35,7 @@ module ActiveHash
         if Object.const_defined?(:ActiveModel)
           model_name.cache_key
         else
-          ActiveSupport::Inflector.tableize(self)
+          ActiveSupport::Inflector.tableize(self).downcase
         end
       end
 
@@ -61,6 +61,10 @@ module ActiveHash
         true
       end
 
+      def empty?
+        false
+      end
+
       def data
         _data
       end
@@ -157,6 +161,10 @@ module ActiveHash
         end
       end
 
+      def find_by(options)
+        where(options).first
+      end
+
       def count
         all.length
       end
@@ -210,6 +218,7 @@ module ActiveHash
         validate_field(field_name)
         field_names << field_name
 
+        add_default_value(field_name, options[:default]) if options[:default]
         define_getter_method(field_name, options[:default])
         define_setter_method(field_name)
         define_interrogator_method(field_name)
@@ -266,6 +275,11 @@ module ActiveHash
 
       private :configuration_for_custom_finder
 
+      def add_default_value field_name, default_value
+        self.default_attributes ||= {}
+        self.default_attributes[field_name] = default_value
+      end
+
       def define_getter_method(field, default_value)
         unless has_instance_method?(field)
           define_method(field) do
@@ -385,8 +399,6 @@ module ActiveHash
 
     end
 
-    attr_reader :attributes
-
     def initialize(attributes = {})
       attributes.symbolize_keys!
       @attributes = attributes
@@ -395,10 +407,22 @@ module ActiveHash
       end
     end
 
+    def attributes
+      if self.class.default_attributes
+        self.class.default_attributes.merge @attributes
+      else
+        @attributes
+      end
+    end
+
     def [](key)
       attributes[key]
     end
 
+    def _read_attribute(key)
+      attributes[key]
+    end
+
     def []=(key, val)
       attributes[key] = val
     end

data/lib/active_hash/version.rb

@@ -1,5 +1,5 @@
 module ActiveHash
   module Gem
-    VERSION = "1.4.0"
+    VERSION = "1.4.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_hash
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Jeff Dean
@@ -28,7 +28,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-04 00:00:00.000000000 Z
+date: 2015-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -86,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: An ActiveRecord-like model that uses a hash or file as a datasource