sack 1.0.0

data/lib/sack/database/model/relationships/has_many.rb

@@ -0,0 +1,56 @@
+# Sack
+# by Eresse <eresse@eresse.net>
+
+# Sack Module
+module Sack
+
+	# Database Class
+	class Database
+
+		# Model Module
+		module Model
+
+			# Relationships Module
+			module Relationships
+
+				# Class Methods
+				module ClassMethods
+
+					# Has Many:
+					# Defines the 'one' side a one-to-many relationship.
+					# @param [Hash] options Options defining the relationship - see README
+					def has_many options
+
+						# Internalise Options (so we can mess it up)
+						options = options.clone
+
+						# Pull Relationship Name & Target Model
+						name, target_model_name = options.first
+						options.delete name
+
+						# Determine Foreign Key (which field in the remote model holds our ID)
+						foreign_key = options[:fk] || table_name
+
+						# Construct Proxy Method Module
+						proxy = Module.new do
+
+							# Proxy Method for Relationship:
+							# Allows fetching entities for a given has-many relationship.
+							define_method name do |db, data|
+
+								# Find Target Model
+								target_model = @model_root.const_get target_model_name.to_s.camelcase
+
+								# Fetch Relationship Entities
+								target_model.fetch_by db, foreign_key, data[:id]
+							end
+						end
+
+						# Extend Model with Proxy
+						@model.extend proxy
+					end
+				end
+			end
+		end
+	end
+end

data/lib/sack/database/model/validation.rb

@@ -0,0 +1,138 @@
+# Sack
+# by Eresse <eresse@eresse.net>
+
+# External Includes
+require 'aromat'
+
+# Internal Includes
+require 'sack/database/ftypes'
+
+# Sack Module
+module Sack
+
+	# Database Class
+	class Database
+
+		# Model Module
+		module Model
+
+			# Validation Module:
+			# Provides a simple entity validation framework.
+			module Validation
+
+				# Validation Exception
+				class ValidationException < Exception
+					attr_reader :errors
+					def initialize msg, errors
+						super msg
+						@errors = errors
+					end
+				end
+
+				# Included:
+				# Inject Validation Methods when included.
+				# @param [Object] base Whatever we've been included into
+				def self.included base
+					base.extend ClassMethods
+				end
+
+				# Class Methods:
+				# Collection of methods to be injected into anything that includes this module.
+				module ClassMethods
+
+					# Is Valid:
+					# Verifies the validity of a given entity (_data_) against this Model.
+					# @param [Database] db Database instance (Sack::Database)
+					# @param [Hash] data Entity data
+					def is_valid? db, data, errors = []
+
+						# Run through Model's Field Schema
+						fields.inject(true) do |a, e|
+
+							# Acquire Field Info
+							name = e[0]
+							info = e[1]
+							ftype = info[:ftype]
+							rules = info[:rules]
+							val = data[name]
+
+							# Handle Required
+							if rules[:required]
+								r = val.try :is_a?, FTYPES_CLASSES[ftype.first]
+								a &&= r
+								errors << "Required field [#{name}] is missing" unless r
+							end
+
+							# Handle Unique
+							if rules[:unique]
+								r = is_uniq? db, data, name, val, rules[:unique]
+								a &&= r
+								errors << "Field [#{name}] has non-unique value [#{val}]#{rules[:unique].is_a?(Array) ? " in scope [#{rules[:unique].join ', '}]" : ''}" unless r
+							end
+
+							# Handle Set Length
+							if rules[:length]
+								r = val.try(:length).try :==, rules[:length]
+								a &&= r
+								errors << "Field [#{name}] has invalid length (#{val.try(:length)} / #{rules[:length]})" unless r
+							end
+
+							# Handle Minimum Length
+							if rules[:min_length]
+								r = val.try(:length).try :>=, rules[:min_length]
+								a &&= r
+								errors << "Field [#{name}] has invalid length (#{val.try(:length)} / Min: #{rules[:min_length]})" unless r
+							end
+
+							# Handle Maximum Length
+							if rules[:max_length]
+								r = val.try(:length).try :<=, rules[:max_length]
+								a &&= r
+								errors << "Field [#{name}] has invalid length (#{val.try(:length)} / Max: #{rules[:max_length]})" unless r
+							end
+
+							# Handle Regex
+							if rules[:regex]
+								r = rules[:regex] =~ val
+								a &&= r
+								errors << "Field [#{name}] doesn't match allowed pattern (#{rules[:regex].inspect})" unless r
+							end
+
+							# Handle Custom
+							if rules[:validate]
+								size = errors.size
+								r = send rules[:validate], db, data, name, val, rules, errors
+								a &&= r
+								errors << "Field [#{name}] is invalid" unless r || (size != errors.size)
+							end
+
+							# Don't leak shit
+							!!a
+						end
+					end
+
+					# Is Unique:
+					# Verifies the unicity of a given field (_name_) value (_val_) on an entity (_data_), possibly within a given _scope_.
+					# @param [Database] db Database instance (Sack::Database)
+					# @param [Hash] data Entity data
+					# @param [Symbol] name Field name
+					# @param [Object] val Field value
+					# @param [Object] scope Either True (if absolute - no scope) or an Array of field names defining the scope
+					def is_uniq? db, data, name, val, scope
+
+						# Fetch all other rows with field [name] equal to [val]
+						others = db.fetch_by table_name, name, val
+						others.reject! { |o| o[:id] == data[:id] } if data[:id]
+
+						# If scopeless (absolutely unique), check empty set and return
+						return others.empty? unless scope.is_a? Array
+
+						# Check Unique throughout Scope
+						scope.each { |f| others.reject! { |o| o[f] != data[f] } }
+						others.empty?
+					end
+				end
+			end
+		end
+	end
+end

data/lib/sack/database/sanitizer.rb

@@ -0,0 +1,78 @@
+# Sack
+# by Eresse <eresse@eresse.net>
+
+# Internal Includes
+require 'sack/database/ftypes'
+
+# Sack Module
+module Sack
+
+	# Database Class
+	class Database
+
+		# Santizer Module:
+		# Provides Table and Field name sanitization methods.
+		module Sanitizer
+
+			# Generic Field Name Regex
+			FIELD_NAME_REX = /^[0-9a-z_.-]+$/
+
+			# Sanitize Table Name:
+			# Raises an exception if _name_ is not a valid table in _schema_.
+			# @param [Hash] schema Database schema
+			# @param [Symbol] name Table name to sanitize
+			# @return [Symbol] Table name if sanitization passed
+			def self.table schema, name
+				raise "Illegal table name [#{name}]" unless (name.to_sym.to_s == name.to_s) && schema.has_key?(name.to_sym)
+				name
+			end
+
+			# Sanitize Table Field Name:
+			# Raises an exception if _table_ or _field_ are not valid according to _schema_.
+			# @param [Hash] schema Database schema
+			# @param [Symbol] table Table name
+			# @param [Symbol] field Field name
+			# @return [Symbol] Field name if sanitization passed
+			def self.field schema, table, field
+				table schema, table
+				raise "Illegal field [#{field}] for table [#{table}]" unless (field.to_sym.to_s == field.to_s) && schema[table.to_sym].has_key?(field.to_sym)
+				field
+			end
+
+			# Sanitize Generic Field Name:
+			# Raises an exception if _name_ contains invalid characters (defined in _FIELD_NAME_REX_).
+			# @param [Symbol] name Field name
+			# @return [Symbol] Field name if sanitization passed
+			def self.field_name name
+				raise "Illegal field name [#{name}]" unless FIELD_NAME_REX =~ name
+				name
+			end
+
+			# Sanitize Field Types
+			# Raises an exception if _t_ is not an allowed Field Type (defined in _FTYPES_).
+			# @param [Symbol] t Field type symbol (from _FTYPES_)
+			# @return [Symbol] Field type if sanitization passed
+			def self.ftype t
+				raise "Illegal field type [#{t}]" unless FTYPES.keys.include? t
+				t
+			end
+
+			# Sanitize Field Value:
+			# Escapes single-quotes inside field values.
+			# @param [Object] v Field value
+			# @return [Object] The supplied value, with single quotes escaped if it's a String.
+			def self.value v
+				return v unless v.is_a? String
+				drop_nonprintascii(v).gsub("'") { "''" }
+			end
+
+			# Drop Non-Print-ASCII:
+			# Removes all non-printable-ASCII characters from a String.
+			# @param [String] s Input string
+			# @return [String] The provided string, stripped of any non-printable-ASCII text
+			def self.drop_nonprintascii s
+				s.bytes.select { |b| (b >= 0x20) && (b <= 0x7e) }.inject('') { |a, e| a + e.chr }
+			end
+		end
+	end
+end

data/lib/sack/database/schema.rb

@@ -0,0 +1,32 @@
+# Sack
+# by Eresse <eresse@eresse.net>
+
+# External Includes
+require 'aromat'
+
+# Sack Module
+module Sack
+
+	# Database Class
+	class Database
+
+		# Schema Module:
+		# Provides utilities for manipulating database schema.
+		module Schema
+
+			# Load from Module:
+			# Constructs a database schema from a given data model module (_mod_).
+			# @param [Module] mod Data model module, containing entity modules
+			# @return [Hash] The complete database schema
+			def self.from_module mod
+
+				# Run through Sub Modules
+				Hash[*(mod.constants
+					.collect { |c| mod.const_get c }
+					.select { |c| c.is_a? Module }
+					.inject([]) { |a, e| (a << e.table_name) << e.field_schema }
+				)]
+			end
+		end
+	end
+end

data/lib/sack/database/statement.rb

@@ -0,0 +1,27 @@
+# Sack
+# by Eresse <eresse@eresse.net>
+
+# Internal Includes
+require 'sack/database/sanitizer'
+
+# Sack Module
+module Sack
+
+	# Database Class
+	class Database
+
+		# Statement Module:
+		# Provides statement manipulation methods.
+		module Statement
+
+			# Prepare Statement:
+			# Binds _params_ to statement fields in _q_.
+			# @param [String] q Statement
+			# @param [Array] params Statement parameters
+			# @return [String] Final statement with all parameters bound
+			def self.prep q, params = []
+				params.inject(q) { |a, p| a.sub!('?') { "'#{Sanitizer.value(p)}'" } }
+			end
+		end
+	end
+end

data/lib/sack/version.rb

@@ -0,0 +1,9 @@
+# Sack
+# by Eresse <eresse@eresse.net>
+
+# Sack Module
+module Sack
+
+	# Version
+	VERSION = '1.0.0'
+end

data/sack.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sack/version'
+
+Gem::Specification.new do |spec|
+	spec.name = 'sack'
+	spec.version = Sack::VERSION
+	spec.authors = ['Eresse']
+	spec.email = ['eresse@eresse.net']
+
+	spec.summary = 'Minimalistic Database Layer based on SQLite3'
+	spec.description = 'Provides a lightweight an easy-to-use database interface.'
+	spec.homepage = 'http://redmine.eresse.net/projects/sack'
+	spec.license = 'MIT'
+
+	spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+	spec.require_paths = ['lib']
+
+	spec.add_development_dependency 'bundler'
+	spec.add_development_dependency 'rake'
+	spec.add_runtime_dependency 'minitest'
+	spec.add_runtime_dependency 'sqlite3'
+	spec.add_runtime_dependency 'aromat'
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: sack
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Eresse
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aromat
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides a lightweight an easy-to-use database interface.
+email:
+- eresse@eresse.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sack.rb
+- lib/sack/connectors.rb
+- lib/sack/connectors/sqlite3.rb
+- lib/sack/database.rb
+- lib/sack/database/data.rb
+- lib/sack/database/ftypes.rb
+- lib/sack/database/generator.rb
+- lib/sack/database/model.rb
+- lib/sack/database/model/data.rb
+- lib/sack/database/model/relationships.rb
+- lib/sack/database/model/relationships/belongs_to.rb
+- lib/sack/database/model/relationships/has_many.rb
+- lib/sack/database/model/validation.rb
+- lib/sack/database/sanitizer.rb
+- lib/sack/database/schema.rb
+- lib/sack/database/statement.rb
+- lib/sack/version.rb
+- sack.gemspec
+homepage: http://redmine.eresse.net/projects/sack
+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.1
+signing_key: 
+specification_version: 4
+summary: Minimalistic Database Layer based on SQLite3
+test_files: []