if_it_werent_4_AR 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 917458a44b4cea7afbc9e7fc011a5b8295f38d87
+  data.tar.gz: 40c4d9a37128a215b8d2e06e0fcd29a63027ac87
+SHA512:
+  metadata.gz: 554f673f318bc4bb3e52d97a3fa0b831f1b9473c76fe93473c5d079cef65b01f87fcfaa1a95b4cb5878384e20c1b7b4588f7d6c90cdf11d84080c9fc567ba04d
+  data.tar.gz: 5fe46815e8a043edc6d22a893bcb6e6fbe175d3ce1e12edd2ca566e3b507ad92c48b470cdcf14e4cb737c963064c582bf3dab60c644a94b4c6b4349a7f80d204

data/README.md

@@ -0,0 +1,95 @@
+# If it were not for ActiveRecord
+
+A test task with minimum functionality to demonstrate basic knowledge and understanding of the AR pattern.
+
+  - Records are stored directly in filesystem
+  - Storage CRUD functionality and search capabilities
+  - Minimalistic error handler
+  - SerDes
+  - Generator for creating models
+  - Simple associations
+
+### Version
+0.0.3
+
+### Details
+ - Storage
+    - Common dataset schema is stored under `db/schema_IFWN4AR.yml`. Each first level key represents a model. The second level keys stand for attributes and their values are their types correspondingly. Convention has it that keys(table names) should be the singular of the entity that they store attributes of.
+    - Each dataset is stored under `'db/DATASET_NAME_storage.csv'` (CSVs' must have a header)
+    - id must be present in schema as the first attribute.
+    - Only integer and text types are supported.
+ - SerDes
+    - Object serializes in a string where attributes have tabulation symbol between. Be sure to not put tabulation in object attributes.
+ - Associations
+  - belongs_to, has_many associations supported. In order to use them you need to assign them in models as class instance variavles and restart server.
+```
+class User < IfItWerent4AR::Base
+  @has_many = [MobilePhone, Passport]
+end
+```
+
+### Installation
+
+Add to your gemfile:
+
+```
+gem 'if_it_werent_4_AR', '>=0.0.6'
+```
+
+Add schema file `db/schema_IFWN4AR.yml`
+
+```
+user:
+  id: integer
+  name: text
+mobile_phone:
+  id: integer
+  user_id: integer
+book:
+  id: integer
+  author_id: integer
+  content: text
+author:
+  id: integer
+  name: text
+```
+
+Run generator to create Model, storage if not exists with appropriate headers.
+
+```
+rails generate iitw4ar
+```
+
+### TODOs
+
+ - Don't hardcode serialization delimiter
+ - Add tests
+ - Optimize storage solution
+ - Add validations
+ - Add ability to change primary/foreign keys
+ - Add id auto incrementation
+ - Add callbacks
+ - A lot
+
+### Features
+
+ - When a record is being deleted in the storage an empty string remains.
+ - Objects with the same attributes are considered equal(same object).
+ - When trying to get associations for a record (class instance) with an id existing in storage, associations will be fetched for that record in storage.
+
+### By
+
+[Azat Gataoulline]
+
+### Source
+
+[https://github.com/Gataniel/if_it_werent_4_AR.git]
+
+License
+----
+MIT
+
+[//]: #
+
+   [Azat Gataoulline]: <https://github.com/gataniel>
+   [https://github.com/joemccann/dillinger.git]: <https://github.com/joemccann/dillinger.git>

data/lib/if_it_werent_4_AR.rb

@@ -0,0 +1,47 @@
+require 'if_it_werent_4_AR/associations'
+require 'if_it_werent_4_AR/initialization'
+require 'if_it_werent_4_AR/file_op'
+require 'if_it_werent_4_AR/storage_crud'
+require 'if_it_werent_4_AR/search'
+require 'if_it_werent_4_AR/serialization'
+require 'if_it_werent_4_AR/validations'
+
+module IfItWerent4AR
+  VALID_DATA_TYPES = %w(
+    integer
+    text
+  )
+
+  class Base
+    include StorageCRUD
+    include Serialization
+    extend Associations
+    extend Search
+
+    class << self
+      attr_accessor :attributes_with_types
+      attr_reader :belongs_to, :has_many
+
+      def attributes
+        attributes_with_types.keys
+      end
+
+      def primary_key
+        attributes.first
+      end
+    end
+
+    def initialize(attrs = {})
+      # if attrs.present?
+      attrs.stringify_keys!
+      uknown_attrs = attrs.keys - self.class.attributes
+      raise "Unknown attributes #{uknown_attrs}" if uknown_attrs.present?
+      # end
+      assign_attributes(attrs)
+    end
+
+    def assign_attributes(attrs)
+      self.class.attributes.each { |attr| public_send("#{attr}=", attrs[attr]) }
+    end
+  end
+end

data/lib/if_it_werent_4_AR/associations.rb

@@ -0,0 +1,27 @@
+module IfItWerent4AR
+  module Associations
+    def add_associations
+      IfItWerent4AR::Base.descendants.each do |descendant|
+        if descendant.has_many
+          descendant.has_many.each do |hm|
+            descendant.class_eval do
+              define_method(hm.to_s.underscore.pluralize.to_sym) do
+                hm.where("#{descendant.to_s.underscore}_id": self.id)
+              end
+            end
+          end
+        end
+
+        if descendant.belongs_to
+          descendant.belongs_to.each do |bt|
+            descendant.class_eval do
+              define_method(bt.to_s.underscore.to_sym) do
+                bt.find(self.public_send("#{bt.to_s.underscore}_id"))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/if_it_werent_4_AR/file_op.rb

@@ -0,0 +1,102 @@
+require 'csv'
+
+module IfItWerent4AR
+  module FileOp
+    # writes/updates/erase objects from storage file
+    DELIMITER = "\t"
+
+    module_function
+
+    def storage_path(klass)
+      "db/#{klass.name.underscore}_storage.csv"
+    end
+
+    def write_to_storage(object)
+      if find_in_storage(object)
+        raise "Record with given id already exists".inspect
+      else
+        write(object)
+      end
+    end
+
+    def update_in_storage(object)
+      found_object = find_in_storage(object)
+      return false unless found_object
+      found_object.serialize == object.serialize ? object : rewrite(object)
+    end
+
+    def find_in_storage(object)
+      IfItWerent4AR::Validations::validate_primary_key_presence(object.id)
+      found_object = nil
+      serialized   = nil
+      CSV.foreach(self.storage_path(object.class), col_sep: DELIMITER, headers: true) do |csv_row|
+        if csv_row['id'].to_i == object.id
+          serialized = csv_row.fields.to_s
+          break
+        end
+      end
+      serialized ? object.class.deserialize(serialized) : false
+    end
+
+    def find_in_storage_by(attrs = {}, klass)
+      attrs.stringify_keys!
+      found_records = []
+      CSV.foreach(self.storage_path(klass), col_sep: DELIMITER, headers: true) do |csv_row|
+        match = true
+        attrs.each_pair do |attr, value|
+          if value.to_s != csv_row[attr]
+            match = false
+            break
+          end
+        end
+        found_records << klass.deserialize(csv_row.fields.to_s) if match
+      end
+      found_records
+    end
+
+    def destroy_from_storage(object)
+      find_in_storage(object) ? erase(object) : false
+    end
+
+    private
+
+    module_function
+
+    def write(object)
+      CSV.open(self.storage_path(object.class), 'ab', col_sep: DELIMITER, headers: true) do |csv|
+        csv << eval(object.serialize)
+      end
+    end
+
+    def rewrite(object)
+      delete_line(object)
+      write(object)
+    end
+
+    def erase(object)
+      delete_line(object)
+    end
+
+    def delete_line(object)
+      is_deleted = false
+      headers = nil
+      storage = File.open(self.storage_path(object.class), 'r+')
+      storage.each do |line|
+        if headers
+          line_csv = CSV.parse(line, col_sep: DELIMITER)
+          if line_csv[0][0].to_i == object.id
+            # seek back to the beginning of the line
+            storage.seek(-line.length, IO::SEEK_CUR)
+            # overwrite line with spaces and add a newline char
+            storage.write(' ' * (line.length - 1))
+            is_deleted = true
+            break
+          end
+        end
+        headers ||= line
+      end
+      storage.close
+      is_deleted
+    end
+  end
+end

data/lib/if_it_werent_4_AR/initialization.rb

@@ -0,0 +1,25 @@
+module IfItWerent4AR
+  module Initialization
+    module_function
+
+    def get_schema
+      YAML.load_file("#{Rails.root}/db/schema_IFWN4AR.yml") rescue raise("No 'schema_IFWN4AR.yml' found in 'db' folder").inspect
+    end
+
+    def init_mapping
+      schema = get_schema
+      schema.each_pair do |table_name, attrs_with_types|
+        invalid_datatypes = schema[table_name].values.map do |datatype|
+          raise("Invalid datatypes #{invalid_datatypes} detected for #{table_name} in schema").inspect if IfItWerent4AR::VALID_DATA_TYPES.exclude?(datatype)
+        end
+
+        IfItWerent4AR::Base.add_associations
+
+        table_name.camelize.constantize.class_eval do
+          attr_accessor *(attrs_with_types.symbolize_keys.keys)
+          self.attributes_with_types = attrs_with_types
+        end
+      end
+    end
+  end
+end

data/lib/if_it_werent_4_AR/search.rb

@@ -0,0 +1,12 @@
+module IfItWerent4AR
+  module Search
+    def where(attrs = {})
+      IfItWerent4AR::FileOp::find_in_storage_by(attrs, self)
+    end
+
+    def find(id)
+      object = self.new(id: id)
+      IfItWerent4AR::FileOp::find_in_storage(object)
+    end
+  end
+end

data/lib/if_it_werent_4_AR/serialization.rb

@@ -0,0 +1,28 @@
+require 'json'
+
+module IfItWerent4AR
+  module Serialization
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def serialize
+      attrs_arr = []
+      self.class.attributes.map do |attr|
+        attrs_arr << send("#{attr}")
+      end
+      attrs_arr.to_s
+    end
+
+    module ClassMethods
+      def deserialize(serialized)
+        attrs_arr = eval(serialized)
+        attrs = {}
+        attributes_with_types.each_with_index do |(attr, type), index|
+          attrs[attr] = (type == 'integer' ? attrs_arr[index].to_s.to_i : attrs_arr[index])
+        end
+        new(attrs)
+      end
+    end
+  end
+end

data/lib/if_it_werent_4_AR/storage_crud.rb

@@ -0,0 +1,18 @@
+module IfItWerent4AR
+  module StorageCRUD
+    # creates/updates/destroys object in storage
+
+    def create(attributes = nil)
+      FileOp::write_to_storage(self) ? self : false
+    end
+
+    def update(attributes = nil)
+      assign_attributes(attributes) if attributes
+      FileOp::update_in_storage(self) ? self : false
+    end
+
+    def destroy
+      FileOp::destroy_from_storage(self) ? true : false
+    end
+  end
+end

data/lib/if_it_werent_4_AR/validations.rb

@@ -0,0 +1,9 @@
+module IfItWerent4AR
+  module Validations
+    module_function
+
+    def validate_primary_key_presence(id)
+      raise("You must provide 'id' attribute in order to work with Storage!").inspect if id.blank?
+    end
+  end
+end

data/lib/rails/generators/iitw4ar_generator.rb

@@ -0,0 +1,25 @@
+require 'if_it_werent_4_AR'
+
+class Iitw4arGenerator < Rails::Generators::Base
+  def create_models_with_storages
+    schema = IfItWerent4AR::Initialization::get_schema
+    schema.each_pair do |table_name, fields_with_types|
+      create_file "app/models/#{table_name.underscore}.rb", <<-FILE
+class #{table_name.camelize} < IfItWerent4AR::Base
+end
+      FILE
+
+      create_file "db/#{table_name.underscore}_storage.csv", <<-FILE
+#{fields_with_types.keys.join(IfItWerent4AR::FileOp::DELIMITER)}
+      FILE
+    end
+  end
+
+  def create_initializer_file
+    create_file "config/initializers/itw4ar.rb", <<-FILE
+require 'if_it_werent_4_AR'
+
+IfItWerent4AR::Initialization::init_mapping
+    FILE
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: if_it_werent_4_AR
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+platform: ruby
+authors:
+- Azat Gataoulline
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-07 00:00:00.000000000 Z
+dependencies: []
+description: Provectus test task
+email: gataniel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/if_it_werent_4_AR.rb
+- lib/if_it_werent_4_AR/associations.rb
+- lib/if_it_werent_4_AR/file_op.rb
+- lib/if_it_werent_4_AR/initialization.rb
+- lib/if_it_werent_4_AR/search.rb
+- lib/if_it_werent_4_AR/serialization.rb
+- lib/if_it_werent_4_AR/storage_crud.rb
+- lib/if_it_werent_4_AR/validations.rb
+- lib/rails/generators/iitw4ar_generator.rb
+homepage: http://rubygems.org/gems/if_it_werent_4_AR
+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.5.0
+signing_key: 
+specification_version: 4
+summary: test
+test_files: []