djoini 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 077ecd1cdd7b679600c6cc3726f87fd755654889
-  data.tar.gz: 47667d0aa0ed0ff65893e471d525a346e7857085
+  metadata.gz: 34a71a0db65d4024e67e0803aa1cf65448863ed3
+  data.tar.gz: d58e772585d90145b09d2cc103276356522877fe
 SHA512:
-  metadata.gz: c046519dadf67ef0add526e5217bc6d0b35be42aff4ee78794f489a9bf76b50f1964c472f25328cf47239632ea532387471eadddc7f98b414ff1e8db16db04ac
-  data.tar.gz: fd8b3fa054bcb79afef7a82d2a3c5f9182d31e7518b695bf3583e06fff42ab4e3c7ea33748a2037409da04d5d7cf10586d2a32ac6d7491cf7735818f6c9b9e58
+  metadata.gz: 4ee443c72bc06ea95cb86e1f5e0fc02a415b2bd865f625ccf3a228f9e0632c8eb85bd22f1928a80f2fa13b14daa4a2bb373c2aa11ea0665f36323139a11402b5
+  data.tar.gz: e48ccdc6d6e2415092ed3d783ea1c6a2604e4ff34e695b97ef82ae7ccd38171e6561afc2114275626f16b9b6ef27b31deeb14259d9bafe14c3903c5f93c852e9

data/README.md

@@ -0,0 +1,115 @@
+# Djoini
+
+DJsOnINI is a implimentation of ActiveModel pattern and a fixture loader for json and ini formats. It implement's only a little part of pattern, so isn't usable in serious applications.
+
+Thing's that are implemented:
+- Djoini::Base class to inherit from
+- Basic crud operations like
+  - create
+  - update
+  - find
+  - where
+  - destroy
+  - all
+  - delete_all
+- Connection to the postgres database, via pg driver
+- Rake task to load fixtures
+- Config files via `Djoini.config` and .yaml for database
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'djoini'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install djoini
+
+## Usage
+
+**Important**
+Make appropriate tables or use other gem to create migrations. This gem doesn't handle migrations only mapping and loading.
+
+Also you need to create database.yml in your `PWD/config/` folder with  atleast this content to use local db with specified credentials.
+
+```yaml
+postgres:
+  adapter: postgresql
+  db_name: djoini_test
+  username: ruby
+  password: noway
+```
+
+### Model usage:
+
+```ruby
+# Model that will produce Post's object
+class Post < Djoini::Base # Inherit from Base class to use the power of ActiveRecord
+  table_name :posts # Explicitly specify table name to be mapped to, scheme    
+                    # counted as 'public'.
+end
+```
+
+After that just use them like you normaly would with ActiveModel:
+
+```ruby
+@user = User.create(name: 'Jack', last_name: 'Daniels')
+@user.name = 'Nansy'
+@user.last_name = 'Drew'
+@user.age = 30
+@user.save
+```
+
+For more examples see tests.
+
+### Rake task usage
+**Important**
+- With `mixed` loading .ini files will be loaded first.
+- All file names must be named after coresponding tables, nor models
+
+To load fixtures all fixtures(both ini and json) from default directory(`PWD/db/fixtures`):
+
+```
+rake djoini:load
+```
+
+To load only ini fixtures:
+
+```
+rake djoini:load type=ini
+```
+
+To specify location of fixtures use configuration module:
+
+```ruby
+Djoini.config do |config|
+  config.fixtures_folder = 'path'
+  config.fixtures_type = 'ini/json/mixed' 
+end
+```
+Djoini will try to find `PWD/config/initializers/djoini.rb` and load it.
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake false` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/faullik/djoini. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+import './lib/tasks/load.rake'

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "djoini"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/djoini/base.rb

@@ -0,0 +1,28 @@
+require_relative 'composite'
+require_relative 'record'
+require_relative 'relation'
+
+module Djoini
+  # Basic abstract model to inherit
+  class Base
+    include Composable
+
+    def initialize(params)
+      features << Record.new(params)
+    end
+
+    def self.inherited(child_class)
+      child_class.extend(ClassMethods)
+    end
+
+    # Holds method to specify table
+    module ClassMethods
+      include Composable
+
+      def table_name(table_name)
+        features << Relation.new(name: table_name,
+                                 record_class: self)
+      end
+    end
+  end
+end

data/lib/djoini/composite.rb

@@ -0,0 +1,47 @@
+module Djoini
+  # Handles array for dynamic attributes and the module to include
+  module Composable
+    def features
+      @__features__ ||= Composite.new
+    end
+
+    def respond_to_missing?(method, *_array)
+      features.reveives?(method)
+    end
+
+    def method_missing(method, *array, &block)
+      features.dispatch(method, *array, &block)
+    end
+  end
+
+  # Handles dynamic attributes of the model
+  class Composite
+    def initialize
+      self.recievers = []
+    end
+
+    def <<(method)
+      recievers.push(method)
+    end
+
+    def reveives?(method)
+      reciever(method)
+    end
+
+    def dispatch(method, *array, &block)
+      obj = reciever(method)
+
+      fail NoMethodError, "No component implements #{method}" unless obj
+
+      obj.send(method, *array, &block)
+    end
+
+    private
+
+    def reciever(method)
+      recievers.find { |el| el.respond_to?(method) }
+    end
+
+    attr_accessor :recievers
+  end
+end

data/lib/djoini/configuration.rb

@@ -0,0 +1,27 @@
+# Configuration provider
+# Djoini.configure do |config|
+#   config.key1 = value
+#   config.key2 = value
+# end
+module Djoini
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  # Main configuration for app
+  class Configuration
+    # Fixtures config
+    attr_accessor :fixtures_folder
+    attr_accessor :fixtures_type
+
+    def initialize
+      self.fixtures_folder = File.join(Dir.pwd, '/db/fixtures')
+      self.fixtures_type = 'mixed'
+    end
+  end
+end

data/lib/djoini/connection.rb

@@ -0,0 +1,31 @@
+require 'singleton'
+require 'pg'
+
+# Holds connection singleton class
+module Djoini
+  def self.db
+    Connection.instance.conn
+  end
+
+  # Class to manage db connetion to postgres
+  class Connection
+    include Singleton
+
+    attr_reader :conn
+
+    def establish_connection(params)
+      _adapter = params.fetch('adapter', 'postgres')
+      _username = params.fetch('username')
+      _password = params.fetch('password')
+      _host = params.fetch('host', 'localhost')
+      _port = params.fetch('port', '5432')
+      _db_name = params.fetch('db_name')
+
+      @conn = PG.connect("#{_adapter}://#{_username}:#{_password}@#{_host}:#{_port}/#{_db_name}")
+    end
+
+    private
+
+    attr_writer :conn
+  end
+end

data/lib/djoini/crud.rb

@@ -0,0 +1,53 @@
+module Djoini
+  # Holds basic crud operaions. Workds like wrapper above Table.
+  class Crud
+    def initialize(relation)
+      self.relation = relation
+    end
+
+    def create(values)
+      id = table.insert(values)[0]['id'].to_i
+
+      find(id)
+    end
+
+    def update(id, values)
+      table.update(where: { table.primary_key => id },
+                   fields: values)
+    end
+
+    def find(id)
+      values = table.where(table.primary_key => id).first
+
+      return nil unless values
+
+      relation.new_record(values)
+    end
+
+    def where(params)
+      rows = table.where(params)
+
+      rows.map { |values| relation.new_record(values) }
+    end
+
+    def destroy(id)
+      table.delete(table.primary_key => id)
+    end
+
+    def all
+      table.all.map { |values| relation.new_record(values) }
+    end
+
+    def delete_all
+      table.delete_all
+    end
+
+    private
+
+    attr_accessor :relation
+
+    def table
+      relation.table
+    end
+  end
+end

data/lib/djoini/fields.rb

@@ -0,0 +1,30 @@
+module Djoini
+  # Holds all fields and values in row\object
+  class Fields
+    def initialize(params)
+      self.data = {}
+
+      attributes = params.fetch(:attributes)
+      values = params.fetch(:values, {})
+
+      attributes.each { |name| data[name] = values[name.to_s] }
+
+      build_accessors(attributes)
+    end
+
+    def clone_hash
+      data.clone
+    end
+
+    private
+
+    attr_accessor :data
+
+    def build_accessors(attributes)
+      attributes.each do |name|
+        define_singleton_method(name) { data[name] }
+        define_singleton_method("#{name}=") { |value| data[name] = value }
+      end
+    end
+  end
+end

data/lib/djoini/files.rb

@@ -0,0 +1,34 @@
+require_relative 'loaders/ini_loader'
+require_relative 'loaders/json_loader'
+
+module Djoini
+  # Handles loading of ini and json fixtures
+  class Files
+    attr_accessor :path
+
+    def initialize(fixtures_path = '')
+      self.path = fixtures_path || Djoini.configuration.fixtures_folder
+    end
+
+    def load_files(type = 'mixed')
+      puts "Loading #{type} files from #{path}"
+
+      IniLoader.new(path).load_files(find_files('ini')) unless type == 'json'
+      JsonLoader.new(path).load_files find_files('json') unless type == 'ini'
+    end
+
+    private
+
+    def find_files(type)
+      _files = []
+
+      Dir.foreach(path) do |file|
+        next unless File.extname(file) == ".#{type}"
+        _model = file.gsub(".#{type}", '')
+        _files << { model: _model, file: file }
+      end
+
+      _files
+    end
+  end
+end

data/lib/djoini/loaders/ini_loader.rb

@@ -0,0 +1,33 @@
+require 'iniparse'
+
+module Djoini
+  # Handles load of ini type files.
+  class IniLoader
+    attr_reader :path
+
+    def initialize(path)
+      self.path = path
+    end
+
+    # Accepts array of [ { model: name, file: File },.. ]
+    def load_files(array)
+      array.each do |fixture|
+        _model_table = Table.new(name: fixture[:model])
+
+        _data = parse_ini(fixture[:file])
+
+        _data.to_hash.each do |_, obj|
+          _model_table.insert(obj)
+        end
+      end
+    end
+
+    private
+
+    attr_writer :path
+
+    def parse_ini(file)
+      IniParse.parse(File.read(File.join(path, file)))
+    end
+  end
+end

data/lib/djoini/loaders/json_loader.rb

@@ -0,0 +1,33 @@
+require 'multi_json'
+
+module Djoini
+  # Handles load of ini type files.
+  class JsonLoader
+    attr_reader :path
+
+    def initialize(path)
+      self.path = path
+    end
+
+    # Accepts array of [ { model: name, file: File },.. ]
+    def load_files(array)
+      array.each do |fixture|
+        _model_table = Table.new(name: fixture[:model])
+
+        _data = parse_json(fixture[:file])
+        
+        _data.each do |obj|
+          _model_table.insert(obj)
+        end
+      end
+    end
+
+    private
+
+    attr_writer :path
+
+    def parse_json(file)
+      MultiJson.load(File.read(File.join(path, file)))
+    end
+  end
+end

data/lib/djoini/record.rb

@@ -0,0 +1,33 @@
+require_relative 'composite'
+require_relative 'fields'
+
+module Djoini
+  # Holds creation and destruction of model, his fields
+  class Record
+    include Composable
+
+    def initialize(params)
+      self.key = params.fetch(:key, nil)
+      self.relation = params.fetch(:relation)
+
+      features << Fields.new(values: params.fetch(:values, {}),
+                             attributes: relation.attributes)
+    end
+
+    def save
+      if key
+        relation.update(key, clone_hash)
+      else
+        relation.create(clone_hash)
+      end
+    end
+
+    def destroy
+      relation.destroy(key)
+    end
+
+    private
+
+    attr_accessor :relation, :key
+  end
+end

data/lib/djoini/relation.rb

@@ -0,0 +1,35 @@
+require_relative 'composite'
+require_relative 'crud'
+require_relative 'table'
+
+module Djoini
+  # Hold creation of new records(rows\objects)
+  class Relation
+    include Composable
+
+    def initialize(params)
+      self.table = Table.new(name: params.fetch(:name))
+
+      self.record_class = params.fetch(:record_class)
+
+      features << Crud.new(self)
+    end
+
+    attr_reader :table
+
+    def attributes
+      table.columns.keys
+    end
+
+    def new_record(values)
+      record_class.new(relation: self,
+                       values: values,
+                       key: values[table.primary_key])
+    end
+
+    private
+
+    attr_accessor :record_class
+    attr_writer :table
+  end
+end

data/lib/djoini/table.rb

@@ -0,0 +1,86 @@
+module Djoini
+  # Holds basic table info and low-level operations
+  class Table
+    attr_reader :primary_key, :name, :columns
+
+    def initialize(params)
+      self.name = params.fetch(:name)
+      self.db = Djoini.db
+      self.columns = {}
+
+      parse_table_info
+    end
+
+    def insert(params)
+      check_keys params
+
+      _field_names = params.keys.join(', ')
+
+      _values = params.values.map { |a| %('#{a}') }.join(', ')
+
+      db.exec "insert into #{name} (#{_field_names}) values (#{_values})
+               returning #{primary_key}"
+    end
+
+    def update(params)
+      check_keys params[:fields]
+
+      db.exec "update #{name}
+               set #{bind_vars(params[:fields], ', ')}
+               where #{bind_vars(params[:where], ' AND ')}"
+    end
+
+    def where(params)
+      check_keys params
+
+      db.exec "select * from #{name}
+               where #{bind_vars(params, ' AND ')}"
+    end
+
+    def all
+      db.exec "select * from #{name}"
+    end
+
+    def delete(params)
+      db.exec "delete from #{name} where #{bind_vars(params, ', ')}"
+    end
+
+    def delete_all
+      db.exec "delete from #{name}"
+    end
+
+    private
+
+    attr_accessor :db
+    attr_writer :primary_key, :name, :columns
+
+    def check_keys(params)
+      fail unless params.keys.all? { |e| columns.key?(e.to_s) }
+    end
+
+    def bind_vars(params, separator)
+      check_keys params
+
+      params.map { |k, v| "#{k} = #{evaluate_value(v)}" }.join(separator)
+    end
+
+    def evaluate_value(value)
+      return "'#{value}'" unless value.to_s.empty?
+      'NULL'
+    end
+
+    def parse_table_info
+      _raw_data = db.exec("SELECT *
+                           FROM information_schema.columns
+                           WHERE table_schema = 'public'
+                           AND table_name   = '#{name}'")
+      _raw_data.each do |row|
+        column_name = row['column_name']
+
+        self.primary_key ||= column_name
+
+        columns[column_name] = { type: row['data_type'] }
+      end
+    end
+  end
+end

data/lib/djoini/version.rb

@@ -0,0 +1,3 @@
+module Djoini
+  VERSION = '0.1.3'
+end

data/lib/djoini.rb

@@ -0,0 +1,9 @@
+
+require 'djoini/version'
+require 'djoini/configuration'
+require 'djoini/connection'
+require 'djoini/base'
+require 'djoini/files'
+
+module Djoini
+end

data/lib/tasks/load.rake

@@ -0,0 +1,25 @@
+
+namespace :djoini do
+  desc 'Load fixtures'
+  task :load do |_, args|
+    require_relative '../djoini'
+
+    require File.expand_path('/config/initializers/djoini.rb')
+    # To make sure configure was called if initializer wasn't foundw
+    Djoini.configure {}
+
+    _conn_info = YAML.load(File.read(Dir.pwd + '/config/database.yml'))
+    Djoini::Connection.instance.establish_connection(_conn_info['postgres'])
+
+    # Path taken from configuration
+    _loader = Djoini::File.new
+
+    if args[:type] == 'ini' || Djoini.configuration.fixtures_type == 'ini'
+      _loader.load_files('ini')
+    elsif args[:type] == 'json' || Djoini.configuration.fixtures_type == 'json'
+      _loader.load_files('json')
+    else
+      _loader.load_files
+    end
+  end
+end

data/spec/database.yml

@@ -0,0 +1,5 @@
+postgres:
+  adapter: postgresql
+  db_name: djoini_test
+  username: ruby
+  password: noway

data/spec/djoini/model_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Djoini::Base do
+  context 'model of User' do
+    before(:each) do
+      User.delete_all
+    end
+
+    it 'expected to set one value' do
+      _user = User.create(name: 'Jack', last_name: 'Daniels')
+      _user.name = 'Jack'
+      _user.save
+
+      expect(User.find(_user.id).name).to eq 'Jack'
+    end
+
+    it 'expected to update multiple values' do
+      _user = User.create(name: 'Jack', last_name: 'Daniels')
+      _user.name = 'Nansy'
+      _user.last_name = 'Drew'
+      _user.age = 30
+      _user.save
+
+      _new_user = User.find(_user.id)
+      expect(_new_user.name).to eq 'Nansy'
+      expect(_new_user.last_name).to eq 'Drew'
+      expect(_new_user.age).to eq '30'
+    end
+
+    it 'expected to return 3 users' do
+      3.times { User.create(name: 'Bot') }
+
+      expect(User.all.count).to eq 3
+    end
+
+    it 'expected to succesfully delete user' do
+      _user = User.create(name: 'Sacrifice')
+      3.times { User.create(name: 'Bot') }
+
+      expect(User.all.count).to eq 4
+
+      _user.destroy
+
+      expect(User.all.count).to eq 3
+    end
+
+    it 'should find user by name' do
+      User.create(name: 'Bilbo', last_name: 'Beggins')
+
+      _users = User.where(name: 'Bilbo')
+      expect(_users.count).to eq 1
+
+      expect(_users[0]).to be_a User
+      expect(_users[0].last_name).to eq 'Beggins'
+    end
+  end
+end

data/spec/djoini/task_fixtures/users.ini

@@ -0,0 +1,11 @@
+[first]
+  name = Jonny
+  last_name = Bravo
+
+[second]
+  name = Super
+  last_name = Man
+
+[third]
+  name = Cowboy
+  last_name = Bebop

data/spec/djoini/task_fixtures/users.json

@@ -0,0 +1,4 @@
+[ 
+  {"name": "Joana", "last_name": "Jupiter"},
+  {"name": "Tom", "last_name": "Sowyer"}
+] 

data/spec/djoini/task_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Djoini::Files do
+  before(:all) do
+    @loader = Djoini::Files.new(File.join(File.dirname(__FILE__), '/task_fixtures/'))
+  end
+
+  context 'Ini fixture' do
+    before(:all) { User.delete_all }
+
+    it 'should load all ini files' do
+      @loader.load_files('ini')
+    end
+
+    it 'should find loaded entity in database' do
+      _users = User.where(name: 'Cowboy')
+
+      expect(_users.count).to eq 1
+      expect(_users[0].last_name).to eq 'Bebop'
+    end
+  end
+
+  context 'Json fixture' do
+    before(:all) { User.delete_all }
+
+    it 'should load all json files' do
+      @loader.load_files('json')
+    end
+
+    it 'should find loaded entity in database' do
+      _users = User.where(name: 'Tom')
+
+      expect(_users.count).to eq 1
+      expect(_users[0].last_name).to eq 'Sowyer'
+    end
+  end
+
+  context 'Mixed fixtures' do
+    before(:all) { User.delete_all }
+
+    it 'should load all json files' do
+      @loader.load_files
+    end
+
+    it 'should find loaded entity from json in database' do
+      _users = User.where(name: 'Tom')
+
+      expect(_users.count).to eq 1
+      expect(_users[0].last_name).to eq 'Sowyer'
+    end
+
+    it 'should find loaded entity from ini in database' do
+      _users = User.where(name: 'Tom')
+
+      expect(_users.count).to eq 1
+      expect(_users[0].last_name).to eq 'Sowyer'
+    end
+  end
+end

data/spec/models/post.rb

@@ -0,0 +1,3 @@
+class Post < Djoini::Base
+  table_name :posts
+end

data/spec/models/user.rb

@@ -0,0 +1,3 @@
+class User < Djoini::Base
+  table_name :users
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'yaml'
+require 'pry'
+
+require_relative '../lib/djoini'
+
+conn_info = YAML.load(File.read(File.dirname(__FILE__) + '/database.yml'))
+
+Djoini::Connection.instance.establish_connection(conn_info['postgres'])
+
+require_relative 'models/post'
+require_relative 'models/user'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: djoini
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - faul
@@ -100,7 +100,34 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/djoini.rb
+- lib/djoini/base.rb
+- lib/djoini/composite.rb
+- lib/djoini/configuration.rb
+- lib/djoini/connection.rb
+- lib/djoini/crud.rb
+- lib/djoini/fields.rb
+- lib/djoini/files.rb
+- lib/djoini/loaders/ini_loader.rb
+- lib/djoini/loaders/json_loader.rb
+- lib/djoini/record.rb
+- lib/djoini/relation.rb
+- lib/djoini/table.rb
+- lib/djoini/version.rb
+- lib/tasks/load.rake
+- spec/database.yml
+- spec/djoini/model_spec.rb
+- spec/djoini/task_fixtures/users.ini
+- spec/djoini/task_fixtures/users.json
+- spec/djoini/task_spec.rb
+- spec/models/post.rb
+- spec/models/user.rb
+- spec/spec_helper.rb
 homepage: 
 licenses:
 - MIT
@@ -125,4 +152,12 @@ rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Implimentation of ActiveModel pattern and a fixture loader
-test_files: []
+test_files:
+- spec/database.yml
+- spec/djoini/model_spec.rb
+- spec/djoini/task_fixtures/users.ini
+- spec/djoini/task_fixtures/users.json
+- spec/djoini/task_spec.rb
+- spec/models/post.rb
+- spec/models/user.rb
+- spec/spec_helper.rb