taupe 0.5.3

data/lib/taupe/database/sqlite.rb

@@ -0,0 +1,73 @@
+# File: sqlite.rb
+# Time-stamp: <2014-09-11 16:29:19 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library sqlite driver class
+
+module Taupe
+  class Database
+    # Sqlite database driver
+    class SqliteDriver
+      # Accessors
+      attr_accessor :connection
+
+      # Constructor
+      # @param dsn [Hash] The data source name
+      def initialize(dsn)
+        db = File.expand_path(dsn)
+        fail "Database #{db} not found" unless File.exist? db
+        @connection = SQLite3::Database.new db
+        @connection.results_as_hash = true
+      end
+
+      # Execute a single query
+      # @param query [String] The query to execute
+      # @return [Object]
+      def exec(query)
+        @connection.execute query
+      end
+
+      # Fetch objects from database
+      # @param query [String] The query to fetch
+      # @return [Array, Object]
+      def fetch(query)
+        exec(query).map(&:symbolize_keys)
+      end
+
+      # Get last inserted id
+      # @return [Integer]
+      def last_id
+        @connection.last_insert_row_id.to_i
+      end
+
+      # Guess schema of a table
+      # @param table [String] The table name
+      # @return [Hash]
+      def guess_schema(table)
+        results = {}
+
+        query = format('pragma table_info(%s)', table)
+
+        fetch(query).each do |values|
+          type = Taupe::Validate.standardize_sql_type values[:type]
+
+          results[values[:name].to_sym] = {
+            type: type,
+            null: values[:notnull] == 0,
+            primary_key: values[:pk] == 1
+          }
+        end
+
+        results
+      end
+
+      # Escape a string
+      # @param str [String]
+      # @return [String]
+      def escape(str)
+        # Sqlite3 does not implement this kind of thing
+        # Use prepare statements instead
+        str
+      end
+    end
+  end
+end

data/lib/taupe/database.rb

@@ -0,0 +1,138 @@
+# File: database.rb
+# Time-stamp: <2014-09-11 14:52:41 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library database class
+
+require 'taupe/database/postgresql'
+require 'taupe/database/mysql'
+require 'taupe/database/sqlite'
+
+module Taupe
+  # Database class
+  # Manage database connection and serve as query proxy
+  class Database
+    # Includes
+    include Accessorized
+
+    # Custom accessors
+    # Accessible via _name and _name=
+    single_accessor :type, :host, :port, :username, :password, :database
+
+    # Accessors
+    attr_accessor :instance, :driver
+
+    # Constructor
+    # @param block [Proc] A given block
+    def initialize(&block)
+      instance_eval(&block)
+    end
+
+    # Setup the Database instance
+    # @param block [Proc] A given block
+    def self.setup(&block)
+      @instance = new(&block)
+      setup_defaults
+      driver_factory
+    end
+
+    # Get the database type
+    # @return [Symbol]
+    def self.type
+      @instance._type
+    end
+
+    # Get the database name
+    # @return [Symbol]
+    def self.database
+      @instance._database
+    end
+
+    # Setup default values
+    def self.setup_defaults
+      case @instance._type
+      when :pg, :pgsql, :postgres, :postgresql
+        Taupe.require_gem 'pg', 'PostgreSQL database engine'
+        @instance._type = :postgresql
+        @instance._host ||= :localhost
+        @instance._port ||= 5432
+      when :mysql, :mysql2
+        Taupe.require_gem 'mysql2', 'MySQL database engine'
+        @instance._type = :mysql
+        @instance._host ||= :localhost
+        @instance._port ||= 3306
+      when :sqlite, :sqlite3
+        Taupe.require_gem 'sqlite3', 'SQLite database engine'
+        @instance._type = :sqlite
+        @instance._database ||= File.expand_path('~/.taupe.db')
+      else
+        fail 'Unknown database type'
+      end
+    end
+
+    # Get the data source name
+    # @return [Hash]
+    def self.dsn
+      case @instance._type
+      when :postgresql
+        {
+          host: @instance._host.to_s,
+          user: @instance._username.to_s,
+          password: @instance._password.to_s,
+          dbname: @instance._database.to_s
+        }
+      when :mysql
+        {
+          host: @instance._host.to_s,
+          username: @instance._username.to_s,
+          password: @instance._password.to_s,
+          database: @instance._database.to_s
+        }
+      when :sqlite
+        @instance._database.to_s
+      end
+    end
+
+    # Setup the connection driver
+    def self.driver_factory
+      cname = "Taupe::Database::#{@instance._type.capitalize}Driver"
+      klass = cname.split('::').reduce(Object) { |a, e| a.const_get e }
+      @instance.driver = klass.new dsn
+    end
+
+    # Guess schema of a table
+    # @param table [String] The table name
+    # @return [Hash]
+    def self.guess_schema(table)
+      @instance.driver.guess_schema table
+    end
+
+    # Execute a single query
+    # @param query [String] The query to execute
+    # @return [Object]
+    def self.exec(query)
+      @instance.driver.exec query
+    end
+
+    # Fetch objects from database
+    # @param query [String] The query to fetch
+    # @param single [Boolean] Must return one or more results?
+    # @return [Array, Object]
+    def self.fetch(query, single = false)
+      results = @instance.driver.fetch query
+      single ? results[0] : results
+    end
+
+    # Fetch last inserted id
+    # @return [Integer]
+    def self.last_id
+      @instance.driver.last_id
+    end
+
+    # Escape a string
+    # @param str [String]
+    # @return [String]
+    def self.escape(str)
+      @instance.driver.escape str
+    end
+  end
+end

data/lib/taupe/model/table.rb

@@ -0,0 +1,192 @@
+#!/usr/bin/env ruby
+
+# File: table.rb
+# Time-stamp: <2014-09-11 16:28:23 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library model table class
+
+module Taupe
+  class Model
+    # Model table base class
+    class Table
+      # Set instance variables
+      class << self
+        attr_accessor :_cname, :_table, :_columns
+        attr_accessor :_pkey, :_values, :_pkey_id, :_cache_key
+      end
+
+      # Load a new object
+      # @param pkey_id [Numeric]
+      # @param cache_key [String]
+      def self.load(pkey_id = nil, cache_key = nil)
+        full_cname = "Taupe::Model::#{@_cname}"
+        klass = full_cname.split('::').reduce(Object) { |a, e| a.const_get e }
+
+        options = {
+          pkey_id: pkey_id,
+          cache_key: cache_key,
+          values: nil
+        }
+
+        klass.new @_table, @_columns, options
+      end
+
+      # Load a new object from existing values
+      # @param values [Hash]
+      # @param pkey_id [Numeric]
+      # @param cache_key [String]
+      def self.load_from_hash(values, pkey_id = nil, cache_key = nil)
+        full_cname = "Taupe::Model::#{@_cname}"
+        klass = full_cname.split('::').reduce(Object) { |a, e| a.const_get e }
+
+        options = {
+          pkey_id: pkey_id,
+          cache_key: cache_key,
+          values: values
+        }
+
+        klass.new @_table, @_columns, options
+      end
+
+      # Constructor
+      # @param table [String]
+      # @param columns [Hash]
+      # @param options [Hash]
+      def initialize(table, columns = nil, options = {})
+        columns = Taupe::Database.guess_schema(table) if columns.nil?
+
+        @_table = table
+        @_columns = columns
+        @_pkey = nil
+        @_pkey_id = options[:pkey_id] || nil
+        @_cache_key = options[:cache_key] || nil
+        @_values = options[:values] || {}
+
+        @_pkey = columns.select { |_k, v| v[:primary_key] == true }.first[0]
+        fail "Primary key undefined for model #{table}" if @_pkey.nil?
+
+        if @_values.empty?
+          return if @_pkey_id.nil?
+          retrieve_from_database unless retrieve_from_cache
+        else
+          @_pkey_id = @_values[@_pkey] if @_pkey_id.nil?
+        end
+      end
+
+      # Retrieve data from cache
+      # @return [Boolean]
+      def retrieve_from_cache
+        retrieved = false
+        return retrieved if @_cache_key.nil?
+
+        data = Taupe::Cache.get(@_cache_key) || nil
+        unless data.nil? || data.empty?
+          @_values = data
+          retrieved = true
+        end
+
+        retrieved
+      end
+
+      # Retrieve data from database
+      def retrieve_from_database
+        query = "SELECT * FROM #{@_table} WHERE #{@_pkey} = #{@_pkey_id}"
+        result = Taupe::Database.fetch(query, true)
+
+        return nil if result.nil? || result.empty?
+
+        result.map do |k, v|
+          @_values[k.to_sym] = v unless k.is_a? Numeric
+        end
+
+        Taupe::Cache.set @_cache_key, @_values unless @_cache_key.nil?
+      end
+
+      # Save the model object
+      # @param with_validations [Boolean]
+      def save(with_validations = true)
+        Taupe::Validate.check(@_values, @_columns) if with_validations
+
+        if @_pkey_id.nil?
+          query = "
+            INSERT INTO #{@_table}
+               (#{@_values.keys.map(&:to_s).join(', ')})
+            VALUES
+               (#{@_values.values.map { |e| "'" + e.to_s + "'" }.join(', ')})
+          "
+
+          Taupe::Database.exec query
+          @_pkey_id = Taupe::Database.last_id
+        else
+          joined_values = @_values.map { |k, v| "#{k} = '#{v}'" }.join(', ')
+          query = "
+            UPDATE #{@_table} SET #{joined_values}
+            WHERE #{@_pkey} = #{@_pkey_id}
+          "
+
+          Taupe::Database.exec query
+        end
+
+        Taupe::Cache.delete @_cache_key unless @_cache_key.nil?
+      end
+
+      # Delete the model object
+      def delete
+        fail 'Can not delete an unsaved model object' if @_pkey_id.nil?
+
+        query = "DELETE FROM #{@_table} WHERE #{@_pkey} = #{@_pkey_id}"
+
+        Taupe::Database.exec query
+
+        Taupe::Cache.delete @_cache_key unless @_cache_key.nil?
+      end
+
+      # Is the object empty?
+      # @return [Boolean]
+      def empty?
+        @_values.empty?
+      end
+
+      # Method missing
+      def method_missing(m, *args, &block)
+        return @_pkey_id if m.to_sym == @_pkey.to_sym
+        return @_values[m] if @_values.key? m
+
+        ms = m.to_s
+        if ms.include? '='
+          ms = ms[0..-2]
+          if @_columns.include? ms.to_sym
+            @_values[ms.to_sym] = args[0]
+            return true
+          end
+        end
+
+        super
+      end
+
+      # Execute a single query
+      # @param query [String] The query to execute
+      # @return [Object]
+      def self.exec(query)
+        Taupe::Database.exec query
+      end
+
+      # Fetch objects from database
+      # @param query [String] The query to fetch
+      # @param single [Boolean] Must return one or more results?
+      # @return [Array, Object]
+      def self.fetch(query, single = false)
+        results = []
+        data = Taupe::Database.fetch(query)
+
+        if data
+          data.each do |h|
+            results << load_from_hash(h)
+          end
+        end
+
+        single ? results[0] : results
+      end
+    end
+  end
+end

data/lib/taupe/model/validate.rb

@@ -0,0 +1,50 @@
+# File: validate.rb
+# Time-stamp: <2014-09-11 16:13:29 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library validate class
+
+module Taupe
+  # Validator class
+  class Validate
+    # Check data integrity
+    # @param values [Hash]
+    # @param definitions [Hash]
+    def self.check(values, definitions)
+      errors = []
+      definitions.each do |name, props|
+        can_be_null = props[:null] || true
+        if values.include?(name)
+          value = values[name]
+          expected_type = props[:type] || String
+          unless value.is_a? expected_type
+            errors << "#{name} (#{value.class.name}) must be a #{expected_type}"
+          end
+        else
+          errors << "#{name} can not be null" unless can_be_null
+        end
+      end
+
+      fail errors.join(' - ') unless errors.empty?
+
+      values
+    end
+
+    # Transform a SQL type into a standard type
+    def self.standardize_sql_type(sql_type)
+      standard_type = nil
+      case sql_type.to_s.downcase
+      when 'integer', 'int', 'int(11)', 'bigint', 'smallint', 'tinyint'
+        standard_type = Integer
+      when 'float'
+        standard_type = Float
+      when 'date', 'time', 'datetime', 'timestamp',
+        'timestamp wit time zone', 'timestamp without time zone'
+        standard_type = Time
+      else
+        standard_type = String
+      end
+
+      standard_type
+    end
+  end
+end

data/lib/taupe/model.rb

@@ -0,0 +1,47 @@
+# File: model.rb
+# Time-stamp: <2014-09-11 13:44:58 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library model class
+
+require 'taupe/model/table'
+require 'taupe/model/validate'
+
+module Taupe
+  # Model class
+  class Model
+    # Includes
+    include Accessorized
+
+    # Custom accessors
+    # Accessible via _name and _name=
+    single_accessor :table
+    stacked_accessor :column
+
+    # Accessors
+    attr_accessor :instance
+
+    # Setup the Cache instance
+    # @param block [Proc] A given block
+    def self.setup(&block)
+      @instance = new(&block)
+    end
+
+    # Constructor
+    # @param block [Proc] A given block
+    def initialize(&block)
+      instance_eval(&block)
+      _write_class_code
+    end
+
+    # Build the table related class
+    def _write_class_code
+      cname = @table.to_s.split('_').map(&:capitalize).join
+      klass = Taupe::Model.const_set cname, Class.new(Taupe::Model::Table)
+      klass._cname = cname
+      klass._table = @table
+      klass._columns = @_column_stack
+    end
+
+    private :_write_class_code
+  end
+end

data/lib/taupe.rb

@@ -0,0 +1,26 @@
+# File: taupe.rb
+# Time-stamp: <2014-09-11 16:27:47 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library main file
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__))
+
+require 'taupe/core'
+require 'taupe/database'
+require 'taupe/cache'
+require 'taupe/model'
+
+# Main Taupe module
+module Taupe
+  # Current version constant in the form major.minor.patch
+  VERSION = [0, 5, 3].join('.')
+
+  # Require a gem
+  # @param gem_name [String] the gem name
+  # @param description [String] a description of the gem
+  def self.require_gem(gem_name, description)
+    require gem_name
+  rescue LoadError
+    raise format('To use %s, install the "%s" gem', description, gem_name)
+  end
+end

data/spec/database_spec.rb

@@ -0,0 +1,59 @@
+# File: database_spec.rb
+# Time-stamp: <2014-08-01 12:00:00 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library database tests file
+
+require_relative '../lib/taupe'
+
+describe Taupe::Database do
+  # Before hook
+  before :all do
+    require 'sqlite3'
+    path = File.expand_path('/tmp/taupe-test.db')
+    File.delete path if File.exist? path
+    File.new(path, 'w')
+  end
+
+  # Setup method
+  describe '#setup' do
+    it 'should setup the database driver' do
+      database = Taupe::Database.setup do
+        type :sqlite
+        database File.expand_path('/tmp/taupe-test.db')
+      end
+
+      expect(database).to be_a Taupe::Database::SqliteDriver
+    end
+  end
+
+  # Query method
+  describe '#query' do
+    it 'should execute some direct queries and return true' do
+      queries = []
+      queries << %Q(CREATE TABLE article(
+        article_id INTEGER PRIMARY KEY AUTOINCREMENT,
+        title text NOT NULL,
+        content text,
+        state INTEGER NOT NULL default 1,
+        creation DATETIME DEFAULT CURRENT_TIMESTAMP);)
+      queries << %Q(INSERT INTO article (title, content, state) VALUES (
+        'Article one', 'This is the first article', 1);)
+      queries << %Q(INSERT INTO article (title, content, state) VALUES (
+        'Article two', 'This is the second article', 0);)
+      queries.each do |q|
+        expect(Taupe::Database.exec(q)).to eql []
+      end
+    end
+  end
+
+  # Fetch method
+  describe '#fetch' do
+    it 'should fetch two database entries' do
+      q = 'SELECT * FROM article'
+      results = Taupe::Database.fetch(q)
+      expect(results).to be_a Array
+      expect(results[0]).to be_a Hash
+      expect(results.length).to eql 2
+    end
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,56 @@
+# File: model_spec.rb
+# Time-stamp: <2014-09-11 16:03:43 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library model tests file
+
+require_relative '../lib/taupe'
+
+describe Taupe::Model do
+
+  # Setup method
+  describe '#setup' do
+    it 'should setup the Article model' do
+      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
+      expect(model).to be_a Taupe::Model
+
+      model_object = Taupe::Model::Article.load
+      expect(model_object).to be_a Taupe::Model::Article
+    end
+  end
+
+  # Fetch method
+  describe '#fetch' do
+    it 'should fetch data from Article' do
+      query = "SELECT * FROM article"
+      results = Taupe::Model::Article.fetch(query)
+
+      expect(results).to be_a Array
+      expect(results.length).to eql 2
+    end
+  end
+
+  # Query method
+  describe '#query and #save' do
+    it 'should execute an insert into Article' do
+      model_object = Taupe::Model::Article.load
+      model_object.title = 'This is a new article'
+      model_object.content = 'This is a new article content'
+      model_object.state = 1
+      model_object.save
+
+      query = "SELECT * FROM article"
+      results = Taupe::Model::Article.fetch(query)
+
+      expect(results).to be_a Array
+      expect(results.length).to eql 3
+      expect(results.last.title).to eql 'This is a new article'
+    end
+  end
+end

data/spec/taupe_spec.rb

@@ -0,0 +1,14 @@
+# File: taupe_spec.rb
+# Time-stamp: <2014-08-01 12:00:00 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library main tests file
+
+require_relative '../lib/taupe'
+
+describe Taupe do
+  describe 'VERSION' do
+    it 'should return 0.5.3' do
+      expect(Taupe::VERSION).to eql '0.5.3'
+    end
+  end
+end

data/spec/validator_spec.rb

@@ -0,0 +1,43 @@
+# File: validator_spec.rb
+# Time-stamp: <2014-09-11 15:56:04 pierre>
+# Copyright (C) 2014 Pierre Lecocq
+# Description: Taupe library validator tests file
+
+describe Taupe::Validate do
+  describe '#check' do
+    it 'should succeed' do
+      values = {
+        :article_id => 1,
+        :title => 'This is an article',
+        :amount => 3.0
+      }
+
+      definitions = {
+        :article_id => { :type => Integer, :primary_key => true },
+        :amount => { :type => Float },
+        :title => { :type => String, :null => false },
+        :content => { :type => String }
+      }
+
+      expect(Taupe::Validate.check(values, definitions)).to eql values
+    end
+
+    it 'should send a failure' do
+      values = {
+        :article_id => '1',
+        :title => 'This is an article',
+        :content => 'and the content',
+        :amount => 3.0
+      }
+
+      definitions = {
+        :article_id => { :type => Integer, :primary_key => true },
+        :amount => { :type => Float },
+        :title => { :type => String, :null => false },
+        :content => { :type => String }
+      }
+
+      expect{ Taupe::Validate.check(values, definitions) }.to raise_error
+    end
+  end
+end