taupe 0.5.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f1b548f21b57a427e78515d3ea17ac0974f3a9d0
+  data.tar.gz: d25d1f8a2dd03b30b583e48f99a353fa09597528
+SHA512:
+  metadata.gz: ef228a38b35977d1cada2add8000afeacf0d7756b42714d27d3b5806eb134193a0aa5f376aa56582440c8bd9451c7e52cc94c4b24b65593a01c5f764be248581
+  data.tar.gz: 560d21ddc307e63daa65469bd566b9c8062ec1d99aabf7ade937be744e70fa4bf199047aceef660d2364604a7843ee16e7ae814480639b1462c4b0c02b6bdc91

data/.rubocop.yml

@@ -0,0 +1,10 @@
+Metrics/ClassLength:
+  CountComments: false
+  Max: 150
+
+Metrics/MethodLength:
+  CountComments: false
+  Max: 25
+
+Style/Encoding:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Utils
+gem 'rake'
+gem 'rspec'
+gem 'yard'

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Pierre Lecocq
+
+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,176 @@
+# Taupe
+
+## What is it?
+
+**Taupe** is a simple and elegant database model manager.
+
+It relies on several popular backends:
+
+- *postgresql*, *mysql* or *sqlite* for database engines
+- *memcached* or *redis* for cache engines
+
+The main idea is to set a database connection, an optional cache connection and your models definitions.
+That's it.
+
+Then, you can query on the database connection or on your models directly. If a cache backend is defined, the data will be stored and retrieved faster than ever.
+
+No fancy SQL DSL. Just pure SQL. Let's be braves and responsibles.
+
+## Why developping it?
+
+It was developped for two main pros:
+
+- control
+- power
+
+I can hear you: "But for this, there are some very popular ORMs like *ActiveRecord* or *Sequel*, you #@$!&+ ! "
+
+Yes.
+But No.
+Definitely.
+
+Here are the main reasons:
+
+- ORMs are too complex for a large percent of our everyday use projects
+- ORMs do not give you the opportunity to write SQL and control your queries (no control, no power). Well, yes they do, but for this, they load so many unused classes that your application's performances are really affected.
+- ORMs have limits on joins, sub-queries, CTEs (... etc) and this is frustrating when doing hard SQL work like statistics
+
+## How to use it?
+
+### Prerequisites
+
+In order to install the Taupe library, simply install the corresponding gem with
+
+    sudo gem install taupe
+
+After that, you must have a few gems install on your system, depending on which backends you want to use
+
+    # If you use PostgreSQL database
+    sudo gem install pg
+
+    # If you use MySQL database
+    sudo gem install mysql2
+
+    # If you use Sqlite database
+    sudo gem install sqlite3
+
+    # If you use Memcached
+    sudo gem install memcached
+
+    # If you use Redis
+    sudo gem install redis
+
+### Define a SQL backend
+
+#### Postgresql (highly recommended)
+
+    # Setup a postgresql database backend
+    Taupe::Database.setup do
+      type :postgresql
+      host :localhost
+      username :myuser
+      password :myfuckingstrongpassword
+      database :mydatabase
+    end
+
+#### MySQL (not recommended)
+
+    # Setup a mysql database backend
+    Taupe::Database.setup do
+      type :mysql
+      host :localhost
+      username :myuser
+      password :myfuckingstrongpassword
+      database :mydatabase
+    end
+
+#### SQLite
+
+    # Setup a sqlite database backend
+    Taupe::Database.setup do
+      type :sqlite
+      database File.expand_path('/tmp/mydatabase.db')
+    end
+
+### Optionally define a cache backend (recommended)
+
+#### Memcached
+
+    # Setup a memcached cache backend
+    Taupe::Cache.setup do
+      type :memcached
+      host :localhost
+      port :11211
+    end
+
+#### Redis
+
+    # Setup a redis cache backend
+    Taupe::Cache.setup do
+      type :redis
+      host :localhost
+      port :6379
+    end
+
+### Define some models
+
+    # Setup a model
+    Taupe::Model.setup do
+      table :article
+      column :article_id, { type: Integer, :primary_key => true }
+      column :title,      { type: String, :null => false }
+      column :content,    { type: String }
+      column :state,      { type: Integer }
+      column :creation,   { type: Date, :locked => true }
+    end
+
+### And then? What can I do?
+
+#### Load a new model object
+
+    article = Taupe::Model::Article.load
+
+#### Load an existing model object
+
+    # A database ID
+    article_id = 3
+
+    # An optional cache key. Set it to nil if cache is not setted or needed
+    cache_key = "article_#{article_id}"
+
+    # Load model from database and create corresponding object
+    article = Taupe::Model::Article.load article_id, cache_key
+
+#### Save a modified model object
+
+    # Modify the ruby object properties
+    article.title = 'This is my modified article title'
+
+    # Reflect changes in database/cache (insert or update)
+    article.save
+
+#### Query, query, query. But by yourself.
+
+    # Execute a single query
+    Taupe::Database.exec "INSERT INTO article (title, state) VALUES ('Another article', 1)"
+
+    # Fetch results in an array
+    articles = Taupe::Database.fetch "SELECT * FROM article"
+
+    # Fetch a single result
+    article = Taupe::Database.fetch "SELECT * FROM article WHERE article_id = 3", true
+
+For more clarity, you can also exec or fetch from any model class. It is exactly the same.
+
+    # Execute an insert query
+    Taupe::Model::Article.exec "INSERT INTO article (title, state) VALUES ('Another article', 1)"
+
+    # Fetch
+    articles = Taupe::Model::Article.fetch "SELECT * FROM article"
+
+    # Fetch single
+    article = Taupe::Model::Article.fetch "SELECT * FROM article WHERE article_id = 3", true
+
+## License
+
+Please see the [LICENSE](https://github.com/pierre-lecocq/taupe/blob/master/LICENSE) file

data/Rakefile

@@ -0,0 +1,28 @@
+task :default => :help
+
+# rake help
+task :help do
+  puts 'Taupe - Available tasks:'
+  puts '  * test:  run rspec tests'
+  puts '  * code:  run rubocop to verify code quality'
+  puts '  * doc:   run yard to generate documentation'
+end
+
+# rake test
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:test)
+
+# rake code
+require 'rubocop/rake_task'
+desc 'Run RuboCop on the lib directory'
+RuboCop::RakeTask.new(:code) do |task|
+  task.patterns = ['lib/**/*.rb']
+  task.fail_on_error = false
+end
+
+# rake doc
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb']
+end
+task :doc => :yard

data/lib/taupe/cache/memcached.rb

@@ -0,0 +1,40 @@
+# File: memcached.rb
+# Time-stamp: <2014-09-11 16:30:12 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library memcached driver class
+
+module Taupe
+  class Cache
+    # Memcached cache driver
+    class MemcachedDriver
+      # Accessors
+      attr_accessor :connection
+
+      # Constructor
+      # @param dsn [Hash] The data source name
+      def initialize(dsn)
+        @connection = Memcached.new dsn
+      end
+
+      # Get a cache entry
+      # @param key [String] The key to retrieve
+      # @return [Object]
+      def get(key)
+        @connection.get key.to_s
+      end
+
+      # Set a cache entry
+      # @param key [String] The key to set
+      # @param value [Object] The value
+      def set(key, value)
+        @connection.set key.to_s, value
+      end
+
+      # Delete a key
+      # @param key [String] The key to delete
+      def delete(key)
+        @connection.delete key.to_s
+      end
+    end
+  end
+end

data/lib/taupe/cache/redis.rb

@@ -0,0 +1,41 @@
+# File: redis.rb
+# Time-stamp: <2014-09-11 16:28:45 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library redis driver class
+
+module Taupe
+  class Cache
+    # Redis cache driver
+    class RedisDriver
+      # Accessors
+      attr_accessor :connection
+
+      # Constructor
+      # @param dsn [Hash] The data source name
+      def initialize(dsn)
+        @connection = Redis.new dsn
+      end
+
+      # Get a cache entry
+      # @param key [String] The key to retrieve
+      # @return [Object]
+      def get(key)
+        @connection.hgetall(key).symbolize_keys
+      end
+
+      # Set a cache entry
+      # @param key [String] The key to set
+      # @param value [Object] The value
+      def set(key, value)
+        fail 'Only HASH values are supported' unless value.is_a?(Hash)
+        @connection.mapped_hmset key, value
+      end
+
+      # Delete a key
+      # @param key [String] The key to delete
+      def delete(key)
+        @connection.del key
+      end
+    end
+  end
+end

data/lib/taupe/cache.rb

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# File: cache.rb
+# Time-stamp: <2014-08-22 16:59:32 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library cache class
+
+require 'taupe/cache/memcached'
+require 'taupe/cache/redis'
+
+module Taupe
+  # Cache class
+  # Manage cache connection and serve as query proxy
+  class Cache
+    # Includes
+    include Accessorized
+
+    # Custom accessors
+    # Accessible via _name and _name=
+    single_accessor :type, :host, :port
+
+    # Accessors
+    attr_accessor :instance, :driver
+
+    # Constructor
+    # @param block [Proc] A given block
+    def initialize(&block)
+      instance_eval(&block)
+    end
+
+    # Setup the Cache instance
+    # @param block [Proc] A given block
+    def self.setup(&block)
+      @instance = new(&block)
+      setup_defaults
+      driver_factory
+    end
+
+    # Setup default values
+    def self.setup_defaults
+      case @instance._type
+      when :memcached
+        Taupe.require_gem 'memcached', 'Memcached cache engine'
+        @instance._host ||= :localhost
+        @instance._port ||= 11_211
+      when :redis
+        Taupe.require_gem 'redis', 'Redis cache engine'
+        @instance._host ||= :localhost
+        @instance._port ||= 6379
+      else
+        fail 'Unknown cache type'
+      end
+    end
+
+    # Get the data source name
+    # @return [Hash, String]
+    def self.dsn
+      case @instance._type
+      when :memcached
+        "#{@instance._host}:#{@instance._port}"
+      when :redis
+        {
+          host: @instance._host.to_s,
+          port: @instance._port.to_i
+        }
+      end
+    end
+
+    # Setup the connection driver
+    def self.driver_factory
+      cname = "Taupe::Cache::#{@instance._type.capitalize}Driver"
+      klass = cname.split('::').reduce(Object) { |a, e| a.const_get e }
+      @instance.driver = klass.new dsn
+    end
+
+    # Get a cache entry
+    # @param key [String] The key to retrieve
+    # @return [Object]
+    def self.get(key)
+      @instance.driver.get key.to_s
+    end
+
+    # Set a cache entry
+    # @param key [String] The key to set
+    # @param value [Object] The value
+    def self.set(key, value)
+      @instance.driver.set key.to_s, value
+    end
+
+    # Delete a key
+    # @param key [String] The key to delete
+    def delete(key)
+      @instance.driver.delete key.to_s
+    end
+  end
+end

data/lib/taupe/core.rb

@@ -0,0 +1,74 @@
+# File: core.rb
+# Time-stamp: <2014-08-22 16:34:51 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library core class
+
+module Taupe
+  # Accessorized module
+  # Add the ability to set custom accessor to a class
+  module Accessorized
+    # Extend ClassMethods
+    # @param base [Object] The caller object
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class methods
+    module ClassMethods
+      # Define single accessor. It can be set one time.
+      # @example single_accessor :name
+      # @note The getter is "_name" instead of "name"
+      # @param names [Array] Set of names
+      def single_accessor(*names)
+        names.each do |name|
+          define_method name do |data|
+            instance_variable_set "@#{name}".to_sym, data
+          end
+          define_method "_#{name}" do
+            instance_variable_get "@#{name}".to_sym
+          end
+          define_method "_#{name}=" do |data|
+            instance_variable_set "@#{name}".to_sym, data
+          end
+        end
+      end
+
+      # Define stacked accessor. It can be set several times.
+      # @example stacked_accessor :name, { type; String, null; false }
+      # @note The getter is "_name_stack" instead of "name"
+      # @param names [Array] Set of names, and a hash of values
+      def stacked_accessor(*names)
+        names.each do |name|
+          define_method name do |*data|
+            stack = instance_variable_get("@_#{name}_stack".to_sym) || {}
+            stack[data[0]] = data[1]
+            instance_variable_set "@_#{name}_stack".to_sym, stack
+          end
+          define_method "_#{name}_stack" do
+            instance_variable_get "@_#{name}_stack".to_sym
+          end
+        end
+      end
+    end
+  end
+end
+
+# Hash ruby core class monkey patching (yes, this is ugly)
+class Hash
+  # Symbolize keys (credits to Avdi Grimm)
+  def symbolize_keys
+    each_with_object({}) do |(key, value), result|
+      new_key = case key
+                when String then key.to_sym
+                else key
+                end
+      new_val = case value
+                when Hash then symbolize_keys(value)
+                else value
+                end
+      result[new_key] = new_val
+
+      result
+    end
+  end
+end

data/lib/taupe/database/mysql.rb

@@ -0,0 +1,70 @@
+# File: mysql.rb
+# Time-stamp: <2014-09-11 16:29:52 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library mysql driver class
+
+module Taupe
+  class Database
+    # Mysql database driver
+    class MysqlDriver
+      # Accessors
+      attr_accessor :connection
+
+      # Constructor
+      # @param dsn [Hash] The data source name
+      def initialize(dsn)
+        dsn[:host] = '127.0.0.1' if dsn[:host].to_s == 'localhost'
+        @connection = Mysql2::Client.new dsn
+        @connection.query_options.merge! symbolize_keys: true
+      end
+
+      # Execute a single query
+      # @param query [String] The query to execute
+      # @return [Object]
+      def exec(query)
+        @connection.query query
+      end
+
+      # Fetch objects from database
+      # @param query [String] The query to fetch
+      # @return [Array, Object]
+      def fetch(query)
+        exec(query).to_a
+      end
+
+      # Get last inserted id
+      # @return [Integer]
+      def last_id
+        @connection.last_id.to_i
+      end
+
+      # Guess schema of a table
+      # @param table [String] The table name
+      # @return [Hash]
+      def guess_schema(table)
+        results = {}
+
+        query = format('SHOW COLUMNS FROM %s', table)
+
+        fetch(query).each do |values|
+          type = Taupe::Validate.standardize_sql_type values[:Type]
+
+          results[values[:Field].to_sym] = {
+            type: type,
+            null: values[:Null] != 'NO',
+            primary_key: values[:Key] == 'PRI'
+          }
+        end
+
+        results
+      end
+
+      # Escape a string
+      # @param str [String]
+      # @return [String]
+      def escape(str)
+        @connection.escape str
+      end
+    end
+  end
+end

data/lib/taupe/database/postgresql.rb

@@ -0,0 +1,89 @@
+# File: postgresql.rb
+# Time-stamp: <2014-09-11 16:29:13 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library postgresql driver class
+
+module Taupe
+  class Database
+    # Postgresql database driver
+    class PostgresqlDriver
+      # Accessors
+      attr_accessor :connection, :last_id
+
+      # Constructor
+      # @param dsn [Hash] The data source name
+      def initialize(dsn)
+        @connection = PG::Connection.new dsn
+      end
+
+      # Execute a single query
+      # @param query [String] The query to execute
+      # @return [Object]
+      def exec(query)
+        result = @connection.exec query
+
+        @last_id = nil
+        @last_id = result[0].flatten[0] if query.upcase.include?('RETURNING')
+
+        result
+      end
+
+      # Fetch objects from database
+      # @param query [String] The query to fetch
+      # @return [Array, Object]
+      def fetch(query)
+        exec(query).to_a.map(&:symbolize_keys)
+      end
+
+      # Get last inserted id
+      # @return [Integer]
+      def last_id
+        if @last_id.nil?
+          message = 'Last ID can not be retrieved.'
+          message << ' Maybe the last query did not include "RETURNING"'
+
+          warn message
+        end
+
+        @last_id.to_i
+      end
+
+      # Guess schema of a table
+      # @param table [String] The table name
+      # @return [Hash]
+      def guess_schema(table)
+        results = {}
+
+        query = 'SELECT'
+        query << ' column_name, data_type, character_maximum_length,'
+        query << ' column_default, is_nullable'
+        query << ' FROM INFORMATION_SCHEMA.COLUMNS'
+        query << format(' WHERE table_name = \'%s\'', table)
+        query << ' ORDER BY ordinal_position'
+
+        fetch(query).each do |values|
+          type = Taupe::Validate.standardize_sql_type values[:data_type]
+          pkey = false
+          unless values[:column_default].nil?
+            pkey = true unless values[:column_default].match('nextval').nil?
+          end
+
+          results[values[:column_name].to_sym] = {
+            type: type,
+            null: values[:is_nullable] != 'NO',
+            primary_key: pkey
+          }
+        end
+
+        results
+      end
+
+      # Escape a string
+      # @param str [String]
+      # @return [String]
+      def escape(str)
+        @connection.escape_string str
+      end
+    end
+  end
+end