fixed_record 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 517a804c21cbd7ebe17493341ae42ddef70193953f5d3a40026907f470088eeb
-  data.tar.gz: 8d7f1d298b25419ef38b457b0a6284dcf6c3b385dfa20b272d98a09f3281b607
+  metadata.gz: 0eea6e2937878d931df67a139cff38882002163f62f43e9f6b4e9440c84bbc60
+  data.tar.gz: 8d51b0834f97783271b77fd8762289efad419c463aa3a6f705affded0a07de2e
 SHA512:
-  metadata.gz: ac9c2c0ba7632aa0edf97a49f5a4e95377f99f5aa46ed28ec4de7a91560f0aa4e96e1edbbbaf203f9623711c5baaf57ce3ac4d7a99f8d55876a2435954dd091f
-  data.tar.gz: 4e76dc6a252b5e71c6932d423ab2c274bdb9d975004879d97409a421ea5baeabee15dc101cd321c754576bbef126eaa70f6017cd262d125a892d3c4735d31208
+  metadata.gz: 39687e91690bd8426119d2c41b77298dc3a48c2da4000a57bc6160f14ea2eb021d4495eac2ca27d50189fa5fcedbb2196c4c543bda44ff936aba2cf27d4f9b42
+  data.tar.gz: '0697f532ce75a0e808fefe5a94a9fa42b9fa00e346c7e6dda1288066aab857ab36d196a57473134d04d66ad4aa0b4b91a4db57a8197284a5c49ff9cfaf18b432'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fixed_record (0.1.0)
+    fixed_record (0.2.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -4,13 +4,11 @@ FixedRecord provides ActiveRecord-like read-only access to a set of records
 described in a YAML file.
 
 Why is this useful? Occasionally you have tabular data which hardly ever
-changes and can easily be edited by hand. Although this code could be placed in a database, it's not worth the overheads (loading a database, maintaining database code). 
-
-It's quicker and simpler to implement this as an array of objects in a YAML file. 
-
-See the Usage section below
+changes and can easily be edited by hand. Although this data could be placed in a database, it may not be worth the overhead involved (loading a database, maintaining database code, etc.). 
 
+It may be quicker and simpler to implement this as an array or hash of objects in a YAML file, and use this gem to provide access to the data. 
 
+See the Usage section below.
 
 ## Installation
 
@@ -30,6 +28,8 @@ Or install it yourself as:
 
 ## Usage
 
+### Array of Records
+
 Create a YAML file defining an array of records like this:
 
 ```yaml
@@ -45,7 +45,7 @@ Create a YAML file defining an array of records like this:
 Then to load these, create a class
 
 ```ruby
-require 'FixedRecord'
+require 'fixed_record'
 
 class MyFavoriteWebsite < FixedRecord
     data "#{Rails.root}/data/my_favorite_websites.yml"
@@ -68,19 +68,78 @@ end
 Or can be accessed as an array:
 
 ```ruby
-MyFavoriteWebiste.all
+MyFavoriteWebsite.all.is_a?(Array)  # true
+```
+A count of the number of records is available:
+
+```ruby
+puts MyFavoriteWebsite.count
+```
+
+The declared class will also include all the methods from the `Enumerable` module.
+
+### Hash of Records
+
+Create a YAML file `my_web_pages.yml` defining a hash of records like this:
+
+```yaml
+StaticPage#first:
+  title: First Page
+  description: Welcome to the First Page
+
+StaticPage#last:
+  title: Last Page 
+  description: Welcome to the Last Page
+
+```
+
+Then to load these, create a class
+
+```ruby
+require 'fixed_record'
+
+class MyWebPages < FixedRecord
+    data "#{Rails.root}/data/my_web_pages.yml"
+
+end
+```
+
+The collection can be accessed by index:
+
+```ruby
+MyWebPages['StaticPage#first'].title # First Page
+MyWebPages['StaticPage#last'].description # Welcome to he Last page
+MyWebPages['StaticPage#first'].key # StaticPage#fifst
+```
+
+The collection can then be enumerated as required:
+
+```ruby
+MyWebPages.each do |k,v| 
+    puts k
+    puts v.title
+end
+```
+Or can be accessed as an hash:
+
+```ruby
+MyWebPages.all.is_a?(Hash)  # true
 ```
 A count of the number of records is available:
 
 ```ruby
-puts MyFavoriteWebiste.count
+puts MyWebPages.count
 ```
 
-The class also includes the `Enumerable` module.
+The declared class will also include all the methods from the `Enumerable` module.
+
+
+
+## Error Checking
 
 Some basic sanity checks are performed on the YAML file to catch common errors:
 
-* It must define a non-empty array of records
+* It must define a non-empty array or hash of records
 * All records must have the same set of attributes
 
 An `ArgumentError` exception will be thrown if any errors are detected.
@@ -89,9 +148,6 @@ Additional validations can be performed by overriding the `validate_yaml` and
 `validate_item` class functions. 
 
 
-
-
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -100,4 +156,4 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/fixed_record.
+Bug reports and pull requests are welcome on GitHub at https://github.com/m-z-b/fixed_record.

data/lib/fixed_record.rb

@@ -2,7 +2,7 @@
 require 'yaml'
 
 class FixedRecord
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 
   # Lazy load data from given filename 
   # creating accessors for top level attributes
@@ -28,43 +28,96 @@ class FixedRecord
       end
 
       def self.count
-        all.count
+        all.length
       end
 
+      def self.[]( k )
+        if all.is_a?(Hash)
+          all[k]
+        else
+          nil
+        end
+      end
+
+      def self.has_key?( k )
+        if all.is_a?(Hash)
+          all.has_key?( k )
+        else
+          false
+        end
+      end 
+
       def self.load!
         if @@items.nil?
           y = YAML.load_file( filename )
           validate_yaml( y )
-          valid_keys = y.first.keys
-          valid_keys.each do |k|
-            define_method( k.to_sym) { @values[k] }
-          end
-
-          @@items = y.map.with_index do |values,i|
-            validate_item( valid_keys, values, i )
-            r = new
-            r.instance_variable_set( :@values, values )
-            r
+          valid_keys = nil
+          if y.is_a?(Array)
+            valid_keys = y.first.keys
+            @@items = y.map.with_index do |values,i|
+              validate_item( valid_keys, values, i )
+              r = new
+              r.instance_variable_set( :@values, values )
+              r
+            end
+          elsif y.is_a?(Hash)
+            @@items = Hash.new
+            add_key = true
+            y.each do |k,values|
+              if valid_keys.nil?
+                valid_keys = values.keys
+                add_key = !values.has_key?('key')
+              end
+              validate_item( valid_keys, values, k )
+              values['key'] = k if add_key
+              r = new
+              r.instance_variable_set( :@values, values )
+              @@items[k] = r   
+            end
+            valid_keys << 'key' if add_key
           end
+          create_methods( valid_keys )
         end
       end
     }
   end
 
+  # Create access methods for each of valid_keys
+  def self.create_methods( valid_keys )
+    valid_keys.each do |k|
+      define_method( k.to_sym) { @values[k] }
+    end
+  end
+
   # Validate the top level of the data structure returned 
   def self.validate_yaml( y )
-    unless y.is_a?(Array) && y.length > 0
-      throw ArgumentError.new "#{filename} does not contain an array of items"
+    if y.is_a?(Array)
+      if y.length <= 0
+        throw ArgumentError.new "#{filename} contain a zero length array"
+      end
+      if y.any?{ |i| !i.is_a?(Hash)}
+        throw ArgumentError.new "#{filename} does not contain an array of items (hashes)"
+      end
+    elsif y.is_a?(Hash)
+      if y.count <= 0
+         throw ArgumentError.new "#{filename} contain an empty hash"
+      end
+      if y.any?{ |k,v| !v.is_a?(Hash) }
+        throw ArgumentError.new "#{filename} does not contain an array of items (hashes)"
+      end
+    else
+      throw ArgumentError.new "#{filename} does not contain a hash of items or an array of items"
     end
+
   end
 
-  # Validate a hash of name -> value
-  def self.validate_item( keys, hash, index )
-    raise ArgumentError, "#{filename} item #{index+1} should be name value pairs" unless hash.is_a?(Hash)
-    raise ArgumentError, "#{filename} item #{index+1} has wrong number of values" if keys.count != hash.count
-    keys.each do |name|
-      unless hash.has_key? name
-        raise ArgumentError, "#{filename} item #{index+1}  is missing value for '#{name}'" 
+  # Validate a values of name -> value
+  def self.validate_item( valid_keys, values, index )
+    raise ArgumentError, "#{filename} item #{index} should be name value pairs" unless values.is_a?(Hash)
+    raise ArgumentError, "#{filename} item #{index} has wrong number of values" if valid_keys.length != values.length
+    valid_keys.each do |name|
+      unless values.has_key? name
+        raise ArgumentError, "#{filename} item #{index}  is missing value for '#{name}'" 
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fixed_record
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Mike Bell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-19 00:00:00.000000000 Z
+date: 2020-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -91,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Provide ActiveRecord like read-only access to a small dataset stored in a