csv_record 1.9.0 → 2.0.0

data/README.md

@@ -1,237 +1,29 @@
 # CsvRecord
 
-[![Build Status](https://secure.travis-ci.org/lukasalexandre/csv_record.png)](http://travis-ci.org/lukasalexandre/csv_record) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/lukasalexandre/csv_record) [![Dependency Status](https://gemnasium.com/lukasalexandre/csv_record.png)](https://gemnasium.com/lukasalexandre/csv_record)
+[[![Build Status](https://travis-ci.org/lukelex/csv_record.png?branch=2.0.0)](https://travis-ci.org/lukelex/csv_record) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/lukelex/csv_record) [![Dependency Status](https://gemnasium.com/lukasalexandre/csv_record.png)](https://gemnasium.com/lukasalexandre/csv_record) [![Gem Version](https://fury-badge.herokuapp.com/rb/csv_record.png)](http://badge.fury.io/rb/csv_record)
 
-CSV Record connects Ruby classes to CSV documents database to establish an almost zero-configuration persistence layer for applications.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'csv_record'
-```
-
-And then execute:
-
-```
-$ bundle
-```
-
-Or install it yourself as:
-
-```
-$ gem install csv_record
-```
-
-## Usage
-
-```ruby
-require 'csv_record'
-
-class Car
-  include CsvRecord::Document
-
-  attr_accessor :year, :make, :model, :description, :price
-end
-```
-
-##Persistance
-```ruby
-Car.create( # save the new record in the database
-  year: 2007,
-  make: 'Chevrolet',
-  model: 'F450',
-  description: 'ac, abs, moon',
-  price: 5000.00
-)
-
-car.save # save the record in the database (either creating or changing)
-
-car.update_attribute :year, 1999 # update a single field of an object
-car.update_attributes year: 1999, model: 'E762' # update multiple fields at the same time
-
-car.destroy # removes the record from the database
-
-car.new_record? # checks if the record is new
-```
-
-##Retrieving
-Records can be queried through the following methods:
-
-```ruby
-Car.all # retrieves all saved records
-
-Car.find car.id # find through its id
-Car.find car # find through the record
-
-Car.find_by_model 'F450' # find dynamically with a property
-Car.find_by_model_and_price 'F450', 5000.00 # find dynamically with multiple properties
-
-Car.where year: 2007, make: 'Chevrolet', model: 'F450' # find with a multiple parameters hash
-
-Car.count # returns the amount of records in the database
-
-Car.first # retrieves the first record in the database
-Car.last # retrieves the last record in the database
-```
-
-##Associations
-###Belongs To
-A Belongs To association can be declared through the following method:
-
-```ruby
-class Company
-  include CsvRecord::Document
-
-  attr_accessor :name
-end
-
-class Car
-  include CsvRecord::Document
-
-  belongs_to :company
-end
-
-company = Company.create :name => 'Chuts'
-
-car = Car.new :model => 'F450'
 
-car.company = company
-# or
-car.company_id = company.id
-
-car.save
-
-car.company # #<Company:0x007f9b249b24d8>
-```
-
-###Has Many
-Extending the previous example, you can use the `has_many` method to establish the inverse relationship:
-
-```ruby
-class Company
-  include CsvRecord::Document
-
-  attr_accessor :name
-
-  has_many :cars
-end
-
-company = Company.create :name => 'Chutz'
-
-car.company = company
-car.save
-
-company.cars # [#<Car:0x007f9b249b24d8>]
-```
-
-###Has One
-The same as has_many but limited to one associated record.
-
-```ruby
-class Company
-  include CsvRecord::Document
-
-  attr_accessor :name
-
-  has_one :car
-end
-
-company = Company.create :name => 'Chutz'
-
-car.save
-company.car = car
-
-company.car # #<Car:0x007f9b249b24d8>
-```
-
-##Callbacks
-###Overview
-Callbacks can be used to execute code on predetermined moments.
-
-####Usage
-```ruby
-after_create do
-  self.do_something
-end
-```
-`self` refers to the instance you are in
-
-###Avaiable Callbacks
-Here is a list with all the available callbacks, listed in the same order in which they will get called during the respective operations:
-
-####Finding an Object
-* after_initialize
-* after_find
-
-####Creating an Object
-* after_initialize
-* before_validation
-* after_validation
-* before_save
-* before_create
-* after_create
-* after_save
-
-####Updating an Object
-* before_validation
-* after_validation
-* before_save
-* before_update
-* after_update
-* after_save
-
-####Destroying an Object
-* before_destroy
-* after_destroy
-
-##Validations
-
-Helpers available:
-
-`validates_presence_of`: Ensures if the specified attribute(s) were filled
-
-`validates_uniqueness_of`: Ensures that the specified attribute(s) are unique within the database
+CSV Record connects Ruby classes to CSV documents database to establish an almost zero-configuration persistence layer for applications.
 
-`validate`: Uses custom method(s) to validate the model
+#Information
 
-```ruby
-class Company
-  include CsvRecord::Document
+##The CSV_Record wiki
 
-  attr_accessor :name
+The CSV_Record Wiki has lots of additional information about CSV_Record. Please browse the Wiki after finishing this README:
 
-  validates_presence_of :name
-  validates_uniqueness_of :name
+wiki.github.com/lukasalexandre/csv_record
 
-  validate :my_custom_validator_method
+##Bug reports
 
-  validate do
-    self.errors.add :attribute
-  end
+If you discover a problem with CSV_Record, we would like to know about it. However, we ask that you please review these guidelines before submitting a bug report:
 
-  def my_custom_validator_method
-    self.errors.add :attribute
-  end
-end
+##Contributing
 
-company = Company.create
-company.save # => false
+We hope that you will consider contributing to CSV_Record. Please read this short overview for some information about how to get started:
 
-company = Company.create
-company.valid? # => false
-company.invalid? # => true
+https://github.com/lukasalexandre/csv_record/wiki/Contributing
 
-```
+You will usually want to write tests for your changes. To run the test suite, go into CSV_Record's top-level directory and run "bundle install" and "rake". For the tests to pass.
 
 ##Precautions
-CsvRecord creates a `db` folder in the root of your application. Be sure that it has permission to do so.
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+CsvRecord creates a `db` folder in the root of your application. Be sure that it has permission to do so.

data/csv_record.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'pry'
   gem.add_development_dependency 'timecop'
   gem.add_development_dependency 'turn'
+  gem.add_development_dependency 'minitest'
 end

data/lib/csv_record/associations.rb

@@ -1,40 +1,38 @@
-module CsvRecord
-  module Associations
-    def belongs_to(klass)
-      klass_name = klass.to_s
+module CsvRecord::Associations
+  def belongs_to(klass)
+    klass_name = klass.to_s
 
-      self.class_eval do
-        self.send :attr_writer, "#{klass}_id"
+    self.class_eval do
+      self.send :attr_writer, "#{klass}_id"
 
-        define_method klass do
-          klass_name.to_class.find self.id
-        end
-        define_method "#{klass}=" do |value|
-          self.send "#{klass}_id=", value.to_param
-        end
-        define_method "#{klass}_id" do
-          eval("@#{klass}_id").to_i
-        end
+      define_method klass do
+        klass_name.to_class.find self.id
+      end
+      define_method "#{klass}=" do |value|
+        self.send "#{klass}_id=", value.to_param
+      end
+      define_method "#{klass}_id" do
+        eval("@#{klass}_id").to_i
       end
     end
+  end
 
-    def has_many(klass)
-      self.class_eval do
-        define_method klass do
-          klass.to_s.to_class.where :"#{self.underscored_class_name}_id" => self.id
-        end
+  def has_many(klass)
+    self.class_eval do
+      define_method klass do
+        klass.to_s.to_class.where :"#{self.underscored_class_name}_id" => self.id
       end
     end
+  end
 
-    def has_one(klass)
-      self.class_eval do
-        define_method "#{klass}=" do |obj|
-          obj.send "#{self.underscored_class_name}_id=", self.id
-          obj.save
-        end
-        define_method klass do
-          klass.to_s.to_class.where("#{self.underscored_class_name}_id" => self.id).first
-        end
+  def has_one(klass)
+    self.class_eval do
+      define_method "#{klass}=" do |obj|
+        obj.send "#{self.underscored_class_name}_id=", self.id
+        obj.save
+      end
+      define_method klass do
+        klass.to_s.to_class.where("#{self.underscored_class_name}_id" => self.id).first
       end
     end
   end

data/lib/csv_record/callback.rb

@@ -0,0 +1,12 @@
+class CsvRecord::Callback
+  attr_accessor :kind, :code
+
+  def initialize(kind, code)
+    self.kind = kind
+    self.code = code
+  end
+
+  def run_on(obj)
+    obj.instance_eval &self.code
+  end
+end

data/lib/csv_record/callbacks.rb

@@ -1,97 +1,99 @@
-module CsvRecord
-  module Callbacks
-    CALLBACKS = [
-      :after_initialize,
-      :after_find,
-      :before_validation,
-      :after_validation,
-      :before_save,
-      :after_save,
-      :after_destroy,
-      :before_destroy,
-      :before_create,
-      :after_create,
-      :before_update,
-      :after_update
-    ].freeze
+require 'csv_record/callback'
 
-    module ClassMethods
-      CALLBACKS.each do |callback|
-        define_method callback do |*args, &block|
-          const_variable = "#{callback}_callbacks".upcase
-          const_set(const_variable, []) unless const_defined? const_variable
-          const_get(const_variable) << block if block
+module CsvRecord::Callbacks
+  CALLBACK_TYPES = [
+    :after_initialize,
+    :after_find,
+    :before_validation,
+    :after_validation,
+    :before_save,
+    :after_save,
+    :after_destroy,
+    :before_destroy,
+    :before_create,
+    :after_create,
+    :before_update,
+    :after_update
+  ].freeze
+
+  module ClassMethods
+    CALLBACK_TYPES.each do |callback_type|
+      define_method callback_type do |*args, &block|
+        const_variable = "#{callback_type}_callbacks".upcase
+        const_set(const_variable, []) unless const_defined? const_variable
+        if block
+          const_get(const_variable) << (CsvRecord::Callback.new callback_type, block)
         end
       end
+    end
 
-      def __where__(*args)
-        results = super
-        results.each &:run_after_find_callbacks
-        results
-      end
+    def find(*args)
+      result = super
+      result.send :run_after_find_callbacks
+      result
     end
+  end
 
-    module InstanceMethods
-      CALLBACKS.each do |callback|
-        define_method "run_#{callback}_callbacks" do
-          const_variable = "#{callback}_callbacks".upcase
-          if self.class.const_defined? const_variable
-            callbacks_collection = self.class.const_get("#{callback}_callbacks".upcase)
-            callbacks_collection.each do |callback_proc|
-              self.instance_eval &callback_proc
-            end
+  module InstanceMethods
+    CALLBACK_TYPES.each do |callback|
+      define_method "run_#{callback}_callbacks" do
+        const_variable = "#{callback}_callbacks".upcase
+        if self.class.const_defined? const_variable
+          callbacks_collection = self.class.const_get(const_variable)
+          callbacks_collection.each do |callback|
+            callback.run_on(self)
           end
         end
       end
+    end
 
-      [:build, :initialize].each do |initialize_method|
-        define_method initialize_method do |*args|
-          result = super(*args)
-          self.run_after_initialize_callbacks
-          result
-        end
-      end
-
-      def valid?
-        self.run_before_validation_callbacks
-        is_valid = super
-        self.run_after_validation_callbacks if is_valid
-        is_valid
+    [:build, :initialize].each do |initialize_method|
+      define_method initialize_method do |*args|
+        result = super(*args)
+        self.run_after_initialize_callbacks
+        result
       end
+    end
 
-      def destroy
-        self.run_before_destroy_callbacks
-        is_destroyed = super
-        self.run_after_destroy_callbacks if is_destroyed
-        is_destroyed
-      end
+    def valid?
+      self.run_before_validation_callbacks
+      is_valid = super
+      self.run_after_validation_callbacks if is_valid
+      is_valid
+    end
 
-      def save(*args)
-        self.run_before_save_callbacks
-        is_saved = super
-        self.run_after_save_callbacks if is_saved
-        is_saved
-      end
+    def destroy
+      self.run_before_destroy_callbacks
+      is_destroyed = super
+      self.run_after_destroy_callbacks if is_destroyed
+      is_destroyed
+    end
 
-      def append_registry
-        self.run_before_create_callbacks
-        is_saved = super
-        self.run_after_create_callbacks if is_saved
-        is_saved
-      end
+    def save(*args)
+      self.run_before_save_callbacks
+      is_saved = super
+      self.run_after_save_callbacks if is_saved
+      is_saved
+    end
 
-      def update_registry
-        self.run_before_update_callbacks
-        saved = super
-        self.run_after_destroy_callbacks if saved
-        self.run_after_update_callbacks if saved
-        saved
-      end
+    def append_registry
+      self.run_before_create_callbacks
+      is_saved = super
+      self.run_after_create_callbacks if is_saved
+      is_saved
     end
 
-    def self.included(receiver)
-      receiver.extend ClassMethods
-      receiver.send :include, InstanceMethods
+    def update_registry
+      self.run_before_update_callbacks
+      saved = super
+      self.run_after_destroy_callbacks if saved
+      self.run_after_update_callbacks if saved
+      saved
     end
   end
+
+  def self.included(receiver)
+    receiver.extend ClassMethods
+    receiver.send :include, InstanceMethods
+  end
 end

data/lib/csv_record/connector.rb

@@ -1,61 +1,67 @@
-module CsvRecord
-  module Connector
-    DATABASE_FOLDER = 'db'.freeze
-    APPEND_MODE = 'a'.freeze
-    WRITE_MODE = 'wb'.freeze
-    READ_MODE = 'r'.freeze
-
-    def __initialize_db_directory__
-      unless Dir.exists? DATABASE_FOLDER
-        Dir.mkdir DATABASE_FOLDER
-      end
+module CsvRecord::Connector
+  DATABASE_FOLDER = 'db'.freeze
+  APPEND_MODE = 'a'.freeze
+  WRITE_MODE = 'wb'.freeze
+  READ_MODE = 'r'.freeze
+
+  # Checks wheter the database directory exists
+  def __initialize_db_directory__
+    unless Dir.exists? DATABASE_FOLDER
+      Dir.mkdir DATABASE_FOLDER
     end
+  end
 
-    def __initialize_db__
-      __initialize_db_directory__
-      unless db_initialized?
-        open_database_file WRITE_MODE do |csv|
-          csv << fields
-        end
+  # Initialize the database file with its headers
+  def __initialize_db__
+    __initialize_db_directory__
+    unless db_initialized?
+      open_database_file WRITE_MODE do |csv|
+        csv << fields
       end
     end
+  end
 
-    def db_initialized?
-      File.exist? self.const_get('DATABASE_LOCATION')
-    end
+  # Checks wheter the database file exists
+  def db_initialized?
+    File.exist? self.const_get('DATABASE_LOCATION')
+  end
 
-    def __open_database_file__(mode=READ_MODE)
-      __initialize_db__ if mode == READ_MODE # fix this later
-      CSV.open(self.const_get('DATABASE_LOCATION'), mode, headers: true) do |csv|
-        yield(csv)
-      end
+  # Open the database file
+  # Params:
+  # +mode+:: the operation mode (defaults to READ_MODE)
+  def __open_database_file__(mode=READ_MODE)
+    __initialize_db__ if mode == READ_MODE # fix this later
+    CSV.open(self.const_get('DATABASE_LOCATION'), mode, headers: true) do |csv|
+      yield(csv)
     end
+  end
 
-    def __parse_database_file__
-      open_database_file do |csv|
-        CSV.open(self.const_get('DATABASE_LOCATION_TMP'), WRITE_MODE, headers: true) do |copy|
-          copy << fields
-          csv.entries.each do |entry|
-            new_row = yield(entry)
-            copy << new_row if new_row
-          end
+  # Creates a modified copy of the database file with the new data and then replaces the original
+  def __parse_database_file__
+    open_database_file do |csv|
+      CSV.open(self.const_get('DATABASE_LOCATION_TMP'), WRITE_MODE, headers: true) do |copy|
+        copy << fields
+        csv.entries.each do |entry|
+          new_row = yield(entry)
+          copy << new_row if new_row
         end
       end
-      rename_database
     end
+    rename_database
+  end
 
-    protected
-
-    def rename_database
-      old_file = self.const_get('DATABASE_LOCATION')
-      tmp_file = self.const_get('DATABASE_LOCATION_TMP')
-      File.delete old_file
-      File.rename(tmp_file, old_file)
-    end
+  protected
 
-    alias :initialize_db_directory :__initialize_db_directory__
-    alias :initialize_db :__initialize_db__
-    alias :open_database_file :__open_database_file__
-    alias :parse_database_file :__parse_database_file__
+  # Rename the TMP database file to replace the original
+  def rename_database
+    old_file = self.const_get('DATABASE_LOCATION')
+    tmp_file = self.const_get('DATABASE_LOCATION_TMP')
+    File.delete old_file
+    File.rename(tmp_file, old_file)
   end
+
+  alias :initialize_db_directory :__initialize_db_directory__
+  alias :initialize_db :__initialize_db__
+  alias :open_database_file :__open_database_file__
+  alias :parse_database_file :__parse_database_file__
 end

data/lib/csv_record/csv_queries/condition.rb

@@ -0,0 +1,18 @@
+class CsvRecord::Condition
+  attr_reader :field, :value
+
+  def initialize(field, value)
+    @field = field
+    @value = value
+  end
+
+  def self.create_from_hashes(hashes)
+    hashes.map do |hash|
+      new *hash
+    end
+  end
+
+  def to_code
+    "attributes['#{@field}'] == '#{@value}'"
+  end
+end