frozen_record 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c5d9ab606f1d5e70f62c490272bcee441f11d8b6
+  data.tar.gz: 96fed4747f8ae0a80c3944defdf9bb69548db474
+SHA512:
+  metadata.gz: 1a6a86f8a6d46490ccbb0d685f79e1393589609bdfaebcbae59963023b22c21e46cd3011b4dd9baab729b45f16aa4421b19de091f788c8d0a28db5b31b182a42
+  data.tar.gz: 4b49087f3cf1f2c763d5c79fb533814a18560b1c173f54bd6a5cd9c4cfb1d9b7da82a062d513c3c8b9f692895313a63c0b3e0b76c410ba47dfabcdd1dd5680d5

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jean Boussier
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,123 @@
+# FrozenRecord
+
+[![Build Status](https://secure.travis-ci.org/byroot/frozen_record.png)](http://travis-ci.org/byroot/frozen_record)
+[![Code Climate](https://codeclimate.com/github/byroot/frozen_record.png)](https://codeclimate.com/github/byroot/frozen_record)
+[![Coverage Status](https://coveralls.io/repos/byroot/frozen_record/badge.png)](https://coveralls.io/r/byroot/frozen_record)
+[![Gem Version](https://badge.fury.io/rb/frozen_record.png)](http://badge.fury.io/rb/frozen_record)
+
+ActiveRecord-like interface for **read only** access to YAML static data.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'frozen_record'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install frozen_record
+
+## Models definition
+
+Just like with ActiveRecord, your models need to inherits from `FrozenRecord::Base`:
+
+```ruby
+class Country < FrozenRecord::Base
+end
+```
+
+But you also have to specify in which directory your data files are located.
+You can either do it globaly
+
+```ruby
+FrozenRecord::Base.base_path = '/path/to/some/directory'
+```
+
+Or per model:
+```ruby
+class Country < FrozenRecord::Base
+  self.base_path = '/path/to/some/directory'
+end
+```
+
+## Query interface
+
+FrozenRecord aim to replicate only modern ActiveRecord querying interface, and only the non "string typed" ones.
+
+e.g
+```ruby
+# Supported query interfaces
+Country.
+  where(region: 'Europe').
+  where.not(language: 'English').
+  order(id: :desc).
+  limit(10).
+  offset(2).
+  pluck(:name)
+
+# Non supported query interfaces
+Country.
+  where('region = "Europe" AND language != "English"').
+  order('id DESC')
+```
+
+### Scopes
+
+While the `scope :symbol, lambda` syntax is not supported, the class methods way is:
+
+```ruby
+class Country
+  def self.republics
+    where(king: nil)
+  end
+
+  def self.part_of_nato
+    where(nato: true)
+  end
+end
+
+Country.republics.part_of_nato.order(id: :desc)
+```
+
+### Supported query methods
+
+  - where
+  - where.not
+  - order
+  - limit
+  - offset
+
+### Supported finder methods
+
+  - find
+  - first
+  - last
+  - to_a
+  - exists?
+
+### Supported calculation methods
+
+  - count
+  - pluck
+  - minimum
+  - minimum
+  - sum
+  - average
+
+
+## Contributors
+
+FrozenRecord is a from scratch reimplementation of a [Shopify](https://github.com/Shopify) project from 2007 named `YamlRecord`.
+So thanks to:
+
+  - John Duff - [@jduff](https://github.com/jduff)
+  - Dennis O'Connor - [@dennisoconnor](https://github.com/dennisoconnor)
+  - Christopher Saunders - [@csaunders](https://github.com/csaunders)
+  - Jonathan Rudenberg - [@titanous](https://github.com/titanous)
+  - Jesse Storimer - [@jstorimer](https://github.com/jstorimer)
+  - Cody Fauser - [@codyfauser](https://github.com/codyfauser)
+  - Tobias Lütke - [@tobi](https://github.com/tobi)

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/frozen_record.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'frozen_record/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'frozen_record'
+  spec.version       = FrozenRecord::VERSION
+  spec.authors       = ['Jean Boussier']
+  spec.email         = ['jean.boussier@gmail.com']
+  spec.summary       = %q{ActiveRecord like interface to read only access and query static YAML files}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'activemodel'
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'coveralls'
+end

data/lib/frozen_record/base.rb

@@ -0,0 +1,120 @@
+require 'set'
+
+module FrozenRecord
+  class Base
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+
+    FIND_BY_PATTERN = /\Afind_by_(\w+)(!?)/
+    FALSY_VALUES = [false, nil, 0, ''].to_set
+
+    class_attribute :base_path
+
+    class_attribute :primary_key
+    self.primary_key = :id
+
+    attribute_method_suffix '?'
+
+    class << self
+
+      def current_scope
+        @current_scope ||= Scope.new(self, load_records)
+      end
+      alias_method :all, :current_scope
+
+      def current_scope=(scope)
+        @current_scope = scope
+      end
+
+      delegate :find, :find_by_id, :where, :first, :first!, :last, :last!, :pluck, :order, :limit, :offset,
+               :minimum, :maximum, :average, :sum, to: :current_scope
+
+      def file_path
+        raise "You must define `#{name}.base_path`" unless base_path
+        File.join(base_path, "#{name.underscore.pluralize}.yml")
+      end
+
+      def respond_to_missing?(name, *)
+        if name.to_s =~ FIND_BY_PATTERN
+          return true if $1.split('_and_').all? { |attr| public_method_defined?(attr) }
+        end
+      end
+
+      private
+
+      def method_missing(name, *args)
+        if name.to_s =~ FIND_BY_PATTERN
+          return dynamic_match($1, args, $2.present?)
+        end
+        super
+      end
+
+      def dynamic_match(expression, values, bang)
+        results = where(expression.split('_and_').zip(values))
+        bang ? results.first! : results.first
+      end
+
+      def load_records
+        @records ||= begin
+          records = YAML.load_file(file_path) || []
+          define_attributes!(list_attributes(records))
+          records.map(&method(:new)).freeze
+        end
+      end
+
+      def list_attributes(records)
+        attributes = Set.new
+        records.each do |record|
+          record.keys.each do |key|
+            attributes.add(key.to_s)
+          end
+        end
+        attributes
+      end
+
+      def define_attributes!(attributes)
+        attributes.each do |attr|
+          define_attribute_method(attr)
+        end
+      end
+
+    end
+
+    attr_reader :attributes
+
+    def initialize(attrs = {})
+      @attributes = attrs.stringify_keys
+    end
+
+    def id
+      self[primary_key]
+    end
+
+    def [](attr)
+      @attributes[attr.to_s]
+    end
+    alias_method :attribute, :[]
+
+    def ==(other)
+      super || other.is_a?(self.class) && other.id == id
+    end
+
+    def persisted?
+      true
+    end
+
+    def to_key
+      [id]
+    end
+
+    private
+
+    def attribute?(attribute_name)
+      FALSY_VALUES.exclude?(self[attribute_name]) && self[attribute_name].present?
+    end
+
+  end
+end

data/lib/frozen_record/scope.rb

@@ -0,0 +1,219 @@
+module FrozenRecord
+  class Scope
+    BLACKLISTED_ARRAY_METHODS = [
+      :compact!, :flatten!, :reject!, :reverse!, :rotate!, :map!,
+      :shuffle!, :slice!, :sort!, :sort_by!, :delete_if,
+      :keep_if, :pop, :shift, :delete_at, :compact
+    ].to_set
+
+    delegate :first, :last, :length, :collect, :map, :each, :all?, :include?, :to_ary, :to_json, :to_xml, :as_json, to: :to_a
+
+    class WhereChain
+      def initialize(scope)
+        @scope = scope
+      end
+
+      def not(criterias)
+        @scope.where_not(criterias)
+      end
+    end
+
+    def initialize(klass, records)
+      @klass = klass
+      @records = records
+      @where_values = []
+      @where_not_values = []
+      @order_values = []
+      @limit = nil
+      @offset = nil
+    end
+
+    def find_by_id(id)
+      matching_records.find { |r| r.id == id }
+    end
+
+    def find(id)
+      raise RecordNotFound, "Can't lookup record without ID" unless id
+      find_by_id(id) or raise RecordNotFound, "Couldn't find a record with ID = #{id.inspect}"
+    end
+
+    def first!
+      first or raise RecordNotFound, "No record matched"
+    end
+
+    def last!
+      last or raise RecordNotFound, "No record matched"
+    end
+
+    def to_a
+      @results ||= query_results
+    end
+
+    def pluck(*attributes)
+      case attributes.length
+      when 1
+        to_a.map(&attributes.first)
+      when 0
+        raise NotImplementedError, '`.pluck` without arguments is not supported yet'
+      else
+        to_a.map { |r| attributes.map { |a| r[a] }}
+      end
+    end
+
+    def sum(attribute)
+      pluck(attribute).sum
+    end
+
+    def average(attribute)
+      pluck(attribute).sum.to_f / count
+    end
+
+    def minimum(attribute)
+      pluck(attribute).min
+    end
+
+    def maximum(attribute)
+      pluck(attribute).max
+    end
+
+    def exists?
+      !empty?
+    end
+
+    def where(criterias = :chain)
+      if criterias == :chain
+        WhereChain.new(self)
+      else
+        spawn.where!(criterias)
+      end
+    end
+
+    def where_not(criterias)
+      spawn.where_not!(criterias)
+    end
+
+    def order(*ordering)
+      spawn.order!(*ordering)
+    end
+
+    def limit(amount)
+      spawn.limit!(amount)
+    end
+
+    def offset(amount)
+      spawn.offset!(amount)
+    end
+
+    def respond_to_missing(method_name, *)
+      array_delegable?(method_name) || super
+    end
+
+    protected
+
+    def scoping
+      previous, @klass.current_scope = @klass.current_scope, self
+      yield
+    ensure
+      @klass.current_scope = previous
+    end
+
+    def spawn
+      clone.clear_cache!
+    end
+
+    def clear_cache!
+      @results = nil
+      @matches = nil
+      self
+    end
+
+    def query_results
+      @results ||= slice_records(matching_records)
+    end
+
+    def matching_records
+      @matches ||= sort_records(select_records(@records))
+    end
+
+    def select_records(records)
+      return records if @where_values.empty? && @where_not_values.empty?
+
+      records.select do |record|
+        @where_values.all? { |attr, value| record[attr] == value } &&
+        @where_not_values.all? { |attr, value| record[attr] != value }
+      end
+    end
+
+    def sort_records(records)
+      return records if @order_values.empty?
+
+      records.sort do |a, b|
+        compare(a, b)
+      end
+    end
+
+    def slice_records(records)
+      return records unless @limit || @offset
+
+      first = @offset || 0
+      last = first + (@limit || records.length)
+      records[first...last] || []
+    end
+
+    def compare(a, b)
+      @order_values.each do |attr, order|
+        a_value, b_value = a[attr], b[attr]
+        cmp = a_value <=> b_value
+        next if cmp == 0
+        return order == :asc ? cmp : -cmp
+      end
+      0
+    end
+
+    def method_missing(method_name, *args, &block)
+      if array_delegable?(method_name)
+        to_a.public_send(method_name, *args, &block) 
+      elsif @klass.respond_to?(method_name)
+        delegate_to_class(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def delegate_to_class(*args, &block)
+      scoping { @klass.public_send(*args, &block) }
+    end
+
+    def array_delegable?(method)
+      Array.method_defined?(method) && BLACKLISTED_ARRAY_METHODS.exclude?(method)
+    end
+
+    def where!(criterias)
+      @where_values += criterias.to_a
+      self
+    end
+
+    def where_not!(criterias)
+      @where_not_values += criterias.to_a
+      self
+    end
+
+    def order!(*ordering)
+      @order_values += ordering.map do |order|
+        order.respond_to?(:to_a) ? order.to_a : [[order, :asc]]
+      end.flatten(1)
+      self
+    end
+
+    def limit!(amount)
+      @limit = amount
+      self
+    end
+
+    def offset!(amount)
+      @offset = amount
+      self
+    end
+
+  end
+end

data/lib/frozen_record/version.rb

@@ -0,0 +1,3 @@
+module FrozenRecord
+  VERSION = '0.1.0'
+end

data/lib/frozen_record.rb

@@ -0,0 +1,11 @@
+require 'set'
+require 'active_support/all'
+require 'active_model'
+
+require 'frozen_record/version'
+require 'frozen_record/scope'
+require 'frozen_record/base'
+
+module FrozenRecord
+  RecordNotFound = Class.new(StandardError)
+end

data/spec/fixtures/countries.yml

@@ -0,0 +1,26 @@
+---
+- id: 1
+  name: Canada
+  capital: Ottawa
+  density: 3.5
+  population: 33.88
+  founded_on: 1867-07-01
+  updated_at: 2014-02-24T19:08:06-05:00
+  nato: true
+  king: Elisabeth II
+
+- id: 2
+  name: France
+  capital: Paris
+  density: 116
+  population: 65.7
+  founded_on: 486-01-01
+  updated_at: 2014-02-12T19:02:03-02:00
+
+- id: 3
+  name: Austria
+  capital: Vienna
+  density: 100.3
+  population: 8.462
+  founded_on: 1156-01-01
+  updated_at: 2014-02-12T19:02:03-02:00

data/spec/frozen_record_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe FrozenRecord::Base do
+
+  describe '.base_path' do
+
+    it 'raise a RuntimeError  on first query attempt if not set' do
+      Country.stub(:base_path).and_return(nil)
+      expect {
+        Country.file_path
+      }.to raise_error
+    end
+
+  end
+
+  describe '#==' do
+
+    it 'returns true if both instances are from the same class and have the same id' do
+      country = Country.first
+      second_country = country.dup
+
+      expect(country).to be == second_country
+    end
+
+    it 'returns false if both instances are not from the same class' do
+      country = Country.first
+      car = Car.new(id: country.id)
+
+      expect(country).to_not be == car
+    end
+
+    it 'returns false if both instances do not have the same id' do
+      country = Country.first
+      second_country = Country.last
+
+      expect(country).to_not be == second_country
+    end
+
+  end
+
+  describe '#attributes' do
+
+    it 'returns a Hash of the record attributes' do
+      attributes = Country.first.attributes
+      expect(attributes).to be == {
+        'id' => 1,
+        'name' => 'Canada',
+        'capital' => 'Ottawa', 
+        'density' => 3.5,
+        'population' => 33.88,
+        'founded_on' => Date.parse('1867-07-01'),
+        'updated_at' => Time.parse('2014-02-24T19:08:06-05:00'),
+        'king' => 'Elisabeth II',
+        'nato' => true,
+      }
+    end
+
+  end
+
+  describe '`attribute`?' do
+
+    let(:blank) { Country.new(id: 0, name: '', nato: false, king: nil) }
+
+    let(:present) { Country.new(id: 42, name: 'Groland', nato: true, king: Object.new) }
+
+    it 'considers `0` as missing' do
+      expect(blank.id?).to be_false
+    end
+
+    it 'considers `""` as missing' do
+      expect(blank.name?).to be_false
+    end
+
+    it 'considers `false` as missing' do
+      expect(blank.nato?).to be_false
+    end
+
+    it 'considers `nil` as missing' do
+      expect(blank.king?).to be_false
+    end
+
+    it 'considers other numbers than `0` as present' do
+      expect(present.id?).to be_true
+    end
+
+    it 'considers other strings than `""` as present' do
+      expect(present.name?).to be_true
+    end
+
+    it 'considers `true` as present' do
+      expect(present.nato?).to be_true
+    end
+
+    it 'considers not `nil` objects as present' do
+      expect(present.king?).to be_true
+    end
+
+  end
+
+end

data/spec/scope_spec.rb

@@ -0,0 +1,358 @@
+require 'spec_helper'
+
+describe 'querying' do
+
+  describe '.first' do
+
+    it 'returns the first country' do
+      country = Country.first
+      expect(country.id).to be == 1
+    end
+
+    it 'can be called on any scope' do
+      country = Country.where(name: 'France').first
+      expect(country.id).to be == 2
+    end
+
+  end
+
+  describe '.first!' do
+
+    it 'raises if no record found' do
+      expect {
+        Country.where(name: 'not existing').first!
+      }.to raise_error(FrozenRecord::RecordNotFound)
+    end
+
+    it 'doesn\'t raise if record found' do
+      expect {
+        Country.first!
+      }.to_not raise_error
+    end
+
+  end
+
+  describe '.last' do
+
+    it 'returns the last country' do
+      country = Country.last
+      expect(country.id).to be == 3
+    end
+
+    it 'can be called on any scope' do
+      country = Country.where(name: 'Canada').last
+      expect(country.id).to be == 1
+    end
+
+  end
+
+  describe '.last!' do
+
+    it 'raises if no record found' do
+      expect {
+        Country.where(name: 'not existing').last!
+      }.to raise_error(FrozenRecord::RecordNotFound)
+    end
+
+    it 'doesn\'t raise if record found' do
+      expect {
+        Country.last!
+      }.to_not raise_error
+    end
+
+  end
+
+  describe '.find' do
+
+    it 'allow to find records by id' do
+      country = Country.find(1)
+      expect(country.id).to be == 1
+      expect(country.name).to be == 'Canada'
+    end
+
+    it 'raises a FrozenRecord::RecordNotFound error if the id do not exist' do
+      expect {
+        Country.find(42)
+      }.to raise_error(FrozenRecord::RecordNotFound)
+    end
+
+    it 'raises a FrozenRecord::RecordNotFound error if the id exist but do not match criterias' do
+      expect {
+        Country.where.not(id: 1).find(1)
+      }.to raise_error(FrozenRecord::RecordNotFound)
+    end
+
+    it 'is not restricted by :limit and :offset' do
+      country = Country.offset(100).limit(1).find(1)
+      expect(country).to be == Country.first
+    end
+
+  end
+
+  describe '.find_by_id' do
+
+    it 'allow to find records by id' do
+      country = Country.find_by_id(1)
+      expect(country.id).to be == 1
+      expect(country.name).to be == 'Canada'
+    end
+
+    it 'returns nil if the id do not exist' do
+      country = Country.find_by_id(42)
+      expect(country).to be_nil
+    end
+
+  end
+
+  describe 'dynamic_matchers' do
+
+    it 'returns the first matching record' do
+      country = Country.find_by_name_and_density('France', 116)
+      expect(country.name).to be == 'France'
+    end
+
+    it 'returns nil if no records match' do
+      country = Country.find_by_name_and_density('England', 116)
+      expect(country).to be_nil
+    end
+
+    it 'hook into respond_to?' do
+      expect(Country).to respond_to :find_by_name_and_density
+    end
+
+    it 'do not respond to unknown attributes' do
+      expect(Country).to_not respond_to :find_by_name_and_unknown_attribute
+    end
+
+  end
+
+  describe 'dynamic_matchers!' do
+
+    it 'returns the first matching record' do
+      country = Country.find_by_name_and_density!('France', 116)
+      expect(country.name).to be == 'France'
+    end
+
+    it 'returns nil if no records match' do
+      expect {
+        Country.find_by_name_and_density!('England', 116)
+      }.to raise_error(FrozenRecord::RecordNotFound)
+    end
+
+  end
+
+  describe '.where' do
+
+    it 'returns the records that match given criterias' do
+      countries = Country.where(name: 'France')
+      expect(countries.length).to be == 1
+      expect(countries.first.name).to be == 'France'
+    end
+
+    it 'is chainable' do
+      countries = Country.where(name: 'France').where(id: 1)
+      expect(countries).to be_empty
+    end
+
+  end
+
+  describe '.where.not' do
+
+    it 'returns the records that do not mach given criterias' do
+      countries = Country.where.not(name: 'France')
+      expect(countries.length).to be == 2
+      expect(countries.map(&:name)).to be == %w(Canada Austria)
+    end
+
+    it 'is chainable' do
+      countries = Country.where.not(name: 'France').where(id: 1)
+      expect(countries.length).to be == 1
+      expect(countries.map(&:name)).to be == %w(Canada)
+    end
+
+  end
+
+  describe '.order' do
+
+    context 'when pased one argument' do
+
+      it 'reorder records by given attribute in ascending order' do
+        countries = Country.order(:name).pluck(:name)
+        expect(countries).to be == %w(Austria Canada France)
+      end
+
+    end
+
+    context 'when passed multiple arguments' do
+
+      it 'reorder records by given attributes in ascending order' do
+        countries = Country.order(:updated_at, :name).pluck(:name)
+        expect(countries).to be == %w(Austria France Canada)
+      end
+
+    end
+
+    context 'when passed a hash' do
+
+      it 'records records by given attribute and specified order' do
+        countries = Country.order(name: :desc).pluck(:name)
+        expect(countries).to be == %w(France Canada Austria)
+      end
+
+    end
+
+  end
+
+  describe '.limit' do
+
+    it 'retuns only the amount of required records' do
+      countries = Country.limit(1)
+      expect(countries.length).to be == 1
+      expect(countries.to_a).to be == [Country.first]
+    end
+
+  end
+
+  describe '.offset' do
+
+    it 'skip the amount of required records' do
+      countries = Country.offset(1)
+      expect(countries.length).to be == 2
+      expect(countries.to_a).to be == [Country.find(2), Country.find(3)]
+    end
+
+  end
+
+  describe '.pluck' do
+
+    context 'when called with a single argument' do
+
+      it 'returns an array of values' do
+        names = Country.pluck(:name)
+        expect(names).to be == %w(Canada France Austria)
+      end
+
+    end
+
+    context 'when called with multiple arguments' do
+
+      it 'returns an array of arrays' do
+        names = Country.pluck(:id, :name)
+        expect(names).to be == [[1, 'Canada'], [2, 'France'], [3, 'Austria']]
+      end
+
+    end
+
+    context 'when called with multiple arguments' do
+
+      it 'returns an array of arrays' do
+        names = Country.pluck(:id, :name)
+        expect(names).to be == [[1, 'Canada'], [2, 'France'], [3, 'Austria']]
+      end
+
+    end
+
+    context 'when called without arguments' do
+
+      pending 'returns an array of arrays containing all attributes in order'
+
+    end
+
+    context 'when called on a scope' do
+
+      it 'returns only the attributes of matching records' do
+        names = Country.where(id: 1).pluck(:name)
+        expect(names).to be == %w(Canada)
+      end
+
+    end
+
+  end
+
+  describe '.exists?' do
+
+    it 'returns true if query match at least one record' do
+      scope = Country.where(name: 'France')
+      expect(scope).to exist
+    end
+
+    it 'returns true if query match no records' do
+      scope = Country.where(name: 'France', id: 42)
+      expect(scope).to_not exist
+    end
+
+  end
+
+  describe '.sum' do
+
+    it 'returns the sum of the column argument' do
+      sum = Country.sum(:population)
+      expect(sum).to be == 108.04200000000002
+    end
+
+  end
+
+  describe '.average' do
+
+    it 'returns the average of the column argument' do
+      average = Country.average(:density)
+      expect(average).to be == 73.26666666666667
+    end
+
+  end
+
+  describe '.minimum' do
+
+    it 'returns the average of the column argument' do
+      minimum = Country.minimum(:density)
+      expect(minimum).to be == 3.5
+    end
+
+  end
+
+  describe '.maximum' do
+
+    it 'returns the average of the column argument' do
+      maximum = Country.maximum(:density)
+      expect(maximum).to be == 116
+    end
+
+  end
+
+  describe '.to_json' do
+
+    it 'serialize the results' do
+      json = Country.all.to_json
+      expect(json).to be == Country.all.to_a.to_json
+    end
+
+  end
+
+  describe '.as_json' do
+
+    it 'serialize the results' do
+      json = Country.all.as_json
+      expect(json).to be == Country.all.to_a.as_json
+    end
+
+  end
+
+  describe '.to_xml' do
+
+    it 'serialize the results' do
+      json = Country.all.to_json
+      expect(json).to be == Country.all.to_a.to_json
+    end
+
+  end
+
+  describe 'class methods delegation' do
+
+    it 'can be called from a scope' do
+      ids = Country.where(name: 'France').republics.pluck(:id)
+      expect(ids).to be == [2]
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'simplecov'
+require 'coveralls'
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start
+
+require 'frozen_record'
+
+FrozenRecord::Base.base_path = File.join(File.dirname(__FILE__), 'fixtures')
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__), 'support', '**', '*.rb'))].each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+end

data/spec/support/car.rb

@@ -0,0 +1,2 @@
+class Car < FrozenRecord::Base
+end

data/spec/support/country.rb

@@ -0,0 +1,7 @@
+class Country < FrozenRecord::Base
+
+  def self.republics
+    where(king: nil)
+  end
+
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: frozen_record
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jean Boussier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  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: 
+email:
+- jean.boussier@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- frozen_record.gemspec
+- lib/frozen_record.rb
+- lib/frozen_record/base.rb
+- lib/frozen_record/scope.rb
+- lib/frozen_record/version.rb
+- spec/fixtures/cars.yml
+- spec/fixtures/countries.yml
+- spec/frozen_record_spec.rb
+- spec/scope_spec.rb
+- spec/spec_helper.rb
+- spec/support/car.rb
+- spec/support/country.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: ActiveRecord like interface to read only access and query static YAML files
+test_files:
+- spec/fixtures/cars.yml
+- spec/fixtures/countries.yml
+- spec/frozen_record_spec.rb
+- spec/scope_spec.rb
+- spec/spec_helper.rb
+- spec/support/car.rb
+- spec/support/country.rb