active_row 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 32981502f001b4782992312dde3995a47b7580ff
+  data.tar.gz: 36c08097e9719a92263b35fca67a23863edccf26
+SHA512:
+  metadata.gz: 1a0ce23f41c880696ee84167010c3a482ce4220a46cc69fd4d5f46f3b68a7c6951420a5a225806fa6693c601a0d6e45aa6c1db84f3269ab1507b3779f6803fa7
+  data.tar.gz: 928e0520767b60002914c3d903cff1e87f1b106fc888a376c6450000a1af0f2130c753bf6c9ef9412dc12cdf1ee6aabfc44a82a7062f014eb542dc3f87975780

data/lib/active_row.rb

@@ -0,0 +1,139 @@
+require 'csv'
+require_relative 'active_row/class_attribute'
+
+class ActiveRow
+
+  CONVERTERS = :all
+
+  class_attribute :table_name, :table_directory, :table_path
+
+  def self.table_name
+    "#{self.name.downcase}s"
+  end
+
+  def self.table_directory
+    "./tables/"
+  end
+
+  def self.table_path
+    "#{self.table_directory}#{self.table_name}.csv"
+  end
+
+  # Accepts a value for the id field.
+  #
+  # Returns self if a row is found and returns nil if no row is found
+  def self.find(id = nil)
+    csv_table = CSV.table(table_path, converters: CONVERTERS)
+    csv_row = csv_table.find { |row| row.field(:id) == id }
+    csv_row ? self.new(csv_row.to_hash) : nil
+  end
+
+  # Accepts a hash. By convention, keys should be the names of attributes
+  # as defined in the CSV headers and the atrributes of the subclass.
+  # However, attributes names are not validated by this method.
+  #
+  # Returns self if a row is found and returns nil if no row is found.
+  def self.find_by(attr_hash)
+    csv_table = CSV.table(table_path, converters: CONVERTERS)
+    # Find the row where values in the CSV::Row are
+    # equal to the values of the attributes that were provided
+    csv_row = csv_table.find { |row| row.values_at(*attr_hash.keys) == attr_hash.values}
+    csv_row ? self.new(csv_row.to_hash) : nil
+  end
+
+  # Returns true if the row is successfully saved. (Otherwise, an error will have occurred).
+  def save
+    attr_hash = self.attributes
+    if self.class.find_by(attr_hash)
+      return false
+    else
+      self.class.create(attr_hash)
+      return true
+    end
+  end
+
+  # Accepts a hash. By convention, keys should be the names of attributes
+  # as defined in the CSV headers and the atrributes of the subclass.
+  # However, attributes names are not validated by this method.
+  #
+  # Returns self if a row is successfully created.
+  def self.create(attr_hash)
+    CSV.open(table_path, 'a+') do |csv| # a+ => append to document
+      # concatenate an array of values [1, 'text', 'username']
+      csv << CSV::Row.new(attr_hash.keys, attr_hash.values).fields
+    end
+    self.new(attr_hash)
+  end
+
+  # Accepts a hash. By convention, keys should be the names of attributes
+  # as defined in the CSV headers and the atrributes of the subclass.
+  # However, attributes names are not validated by this method.
+  #
+  # Returns new_row as an instance of the subclass, or returns false.
+  def update(attr_hash)
+    # Prevent update of id field
+    attr_hash.reject! { |k, v| k == :id || k == "id" }
+    csv_table = CSV.table(table_path, converters: CONVERTERS)
+    old_row = csv_table.find { |row| row.field(:id) == id }
+    new_row = CSV::Row.new(old_row.headers, old_row.fields)
+
+    # Assign new values to the row by param name (which should be a field name)
+    attr_hash.each { |k, v| new_row[k] = v }
+    # Delete the old_row
+    csv_table = CSV.table(table_path, converters: CONVERTERS)
+    csv_table.delete_if do |row|
+      row == old_row
+    end
+    csv_table << new_row
+    # Write the csv_table to a file, replacing the original
+    File.open(table_path, 'w') do |f| # w => write-only
+      f.write(csv_table.to_csv)
+    end
+    # Note: AR returns true if successful, false if not.
+    # If AR is successful, it updates the receiving instance's attributes.
+    # This returns a new instance with the variables on success.
+    new_row ? self.class.new(new_row.to_hash) : false
+  end
+
+  def destroy
+    csv_table = CSV.table(table_path, converters: CONVERTERS)
+    # Delete the row from the table if it is equivalent to the receiving instance.
+    csv_table.delete_if do |row|
+      row == CSV::Row.new(attributes.keys, attributes.values)
+    end
+
+    # Write the csv_table to a file, replacing the original
+    File.open(table_path, 'w') do |f| # w => write-only
+      f.write(csv_table.to_csv)
+    end
+
+    # Get the file's contents and close it
+    file = File.open(table_path, 'rb')
+    contents = file.read
+    file.close
+
+    # If all rows but the header have been deleted...
+    if contents.lines.count < 2
+       # then ensure the headers are still there.
+       File.open(table_path, 'w') do |f| # w => write-only
+        f.write(attributes.keys.map(&:to_s).join(','))
+      end
+    end
+    self.freeze
+  end
+
+  # Returns a hash of the receiving's instance variables.
+  def attributes
+    attrs = {}
+    instance_variables.each { |instance_variable|
+      # Convert the instariable to a string, removing the @ (instance notation), and convert back to a symbol
+      attrs[instance_variable.to_s[1..-1].to_sym] = instance_variable_get(instance_variable)
+    }
+    attrs
+  end
+
+  def attributes=(new_attributes)
+    new_attributes.each { |key, value| instance_variable_set(key, value) }
+    attributes
+  end
+end

data/lib/active_row/class_attribute.rb

@@ -0,0 +1,178 @@
+# This file contains the source of the Class#class_attribute method from ActiveSupport.
+# It also contains the dependencies of this method, which are defined in ActiveSupport.
+# Reference: http://api.rubyonrails.org/classes/Class.html#method-i-class_attribute
+# Source: https://github.com/rails/rails/blob/v4.2.5/activesupport/lib/active_support/core_ext/class/attribute.rb
+
+module Kernel
+  # class_eval on an object acts like singleton_class.class_eval.
+  def class_eval(*args, &block)
+    singleton_class.class_eval(*args, &block)
+  end
+end
+
+class Module
+  def remove_possible_method(method)
+    if method_defined?(method) || private_method_defined?(method)
+      undef_method(method)
+    end
+  end
+
+  def redefine_method(method, &block)
+    remove_possible_method(method)
+    define_method(method, &block)
+  end
+end
+
+class Hash
+  # By default, only instances of Hash itself are extractable.
+  # Subclasses of Hash may implement this method and return
+  # true to declare themselves as extractable. If a Hash
+  # is extractable, Array#extract_options! pops it from
+  # the Array when it is the last element of the Array.
+  def extractable_options?
+    instance_of?(Hash)
+  end
+end
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)        # => {}
+  #   options(1, 2, a: :b) # => {:a=>:b}
+  def extract_options!
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end
+
+class Class
+  # Declare a class-level attribute whose value is inheritable by subclasses.
+  # Subclasses can change their own value and it will not impact parent class.
+  #
+  #   class Base
+  #     class_attribute :setting
+  #   end
+  #
+  #   class Subclass < Base
+  #   end
+  #
+  #   Base.setting = true
+  #   Subclass.setting            # => true
+  #   Subclass.setting = false
+  #   Subclass.setting            # => false
+  #   Base.setting                # => true
+  #
+  # In the above case as long as Subclass does not assign a value to setting
+  # by performing <tt>Subclass.setting = _something_ </tt>, <tt>Subclass.setting</tt>
+  # would read value assigned to parent class. Once Subclass assigns a value then
+  # the value assigned by Subclass would be returned.
+  #
+  # This matches normal Ruby method inheritance: think of writing an attribute
+  # on a subclass as overriding the reader method. However, you need to be aware
+  # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
+  # In such cases, you don't want to do changes in places but use setters:
+  #
+  #   Base.setting = []
+  #   Base.setting                # => []
+  #   Subclass.setting            # => []
+  #
+  #   # Appending in child changes both parent and child because it is the same object:
+  #   Subclass.setting << :foo
+  #   Base.setting               # => [:foo]
+  #   Subclass.setting           # => [:foo]
+  #
+  #   # Use setters to not propagate changes:
+  #   Base.setting = []
+  #   Subclass.setting += [:foo]
+  #   Base.setting               # => []
+  #   Subclass.setting           # => [:foo]
+  #
+  # For convenience, an instance predicate method is defined as well.
+  # To skip it, pass <tt>instance_predicate: false</tt>.
+  #
+  #   Subclass.setting?       # => false
+  #
+  # Instances may overwrite the class value in the same way:
+  #
+  #   Base.setting = true
+  #   object = Base.new
+  #   object.setting          # => true
+  #   object.setting = false
+  #   object.setting          # => false
+  #   Base.setting            # => true
+  #
+  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  #
+  #   object.setting          # => NoMethodError
+  #   object.setting?         # => NoMethodError
+  #
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
+  #
+  #   object.setting = false  # => NoMethodError
+  #
+  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
+  def class_attribute(*attrs)
+    options = attrs.extract_options!
+    instance_reader = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
+    instance_writer = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
+    instance_predicate = options.fetch(:instance_predicate, true)
+
+    attrs.each do |name|
+      define_singleton_method(name) { nil }
+      define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
+
+      ivar = "@#{name}"
+
+      define_singleton_method("#{name}=") do |val|
+        singleton_class.class_eval do
+          remove_possible_method(name)
+          define_method(name) { val }
+        end
+
+        if singleton_class?
+          class_eval do
+            remove_possible_method(name)
+            define_method(name) do
+              if instance_variable_defined? ivar
+                instance_variable_get ivar
+              else
+                singleton_class.send name
+              end
+            end
+          end
+        end
+        val
+      end
+
+      if instance_reader
+        remove_possible_method name
+        define_method(name) do
+          if instance_variable_defined?(ivar)
+            instance_variable_get ivar
+          else
+            self.class.public_send name
+          end
+        end
+        define_method("#{name}?") { !!public_send(name) } if instance_predicate
+      end
+
+      attr_writer name if instance_writer
+    end
+  end
+
+  private
+
+    unless respond_to?(:singleton_class?)
+      def singleton_class?
+        ancestors.first != self
+      end
+    end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: active_row
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nick Quaranto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-11 00:00:00.000000000 Z
+dependencies: []
+description: Provides behavior similar to ActiveRecord, but stores records in a CSV.
+email: local.mat@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_row.rb
+- lib/active_row/class_attribute.rb
+homepage: https://github.com/sealocal/active_row
+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.4.6
+signing_key: 
+specification_version: 4
+summary: active_row
+test_files: []