jsondb 0.0.2 → 0.1.1

data/lib/jsondb/settings.rb

@@ -0,0 +1,34 @@
+module JSONdb
+
+  class Settings
+
+    include JSONdb::Logger
+
+    attr_accessor :folder, :writeable, :raise_errors, :log_enabled, :log_level, :log_file, :log_folder, :verbose
+
+    def initialize
+      @folder           = ""
+      # read-only?
+      @writeable        = true
+      # raise errors or return true or false
+      @raise_errors     = true
+      # logs
+      @log_enabled      = false
+      @log_level        = :info
+      @log_file         = "db.log"
+      @log_folder       = nil
+      @verbose          = false
+      # 
+    end
+
+    def log_level=(level)
+      if allowed_log_level?(level)
+        @log_level = level
+      else
+        log("Log level not log_level_allowed", :error)
+      end
+    end
+
+  end
+
+end

data/lib/jsondb/table.rb

@@ -1,147 +1,95 @@
 module JSONdb
-	class Table
-
-		attr_accessor :updated_at
-		attr_reader :fields, :records, :last_id, :persisted
-
-		include Validation
-
-		def initialize(name, folder, updated_at, writeable)
-			allowed_name?(name)
-			
-			@name = name
-			@folder = folder
-			@writeable = writeable
-
-			@structure_file = FileOps.new(@folder, "#{@name}_structure.json", 'table_structure', @writeable)
-			@records_file   = FileOps.new(@folder, "#{@name}_records.json", 'table_records', @writeable)
-
-			# last_id
-			@last_id = @structure_file.contents["last_id"]
-
-			# Fields
-			@fields = Hash.new
-
-			if @structure_file.contents["fields"].keys.count
-				@structure_file.contents["fields"].each do |name, field|
-					@fields[name] ||= Field.new(name)
-				end
-			end
-			# add id and timestamps fields if not exists...
-			add_main_fields 
-
-			# Fills records hash
-			@records_contents = @records_file.contents || {}
-			@records = Hash.new
-			@records_contents.each do |id, record|
-				@records[id] = Record.new(@fields, record)
-			end
-
-			@updated_at = Time.now.to_i if @structure_file.new_file
-			@persisted = !@structure_file.new_file
-
-		end
-
-		def field(name)
-			return @fields[name] ||= Field.new(@name)
-		end
-
-		def records
-			return @records
-		end
-
-		def new_record
-			@persisted = false
-			@updated_at = Time.now.to_i
-			return Record.new(@fields)
-		end
-
-		def query(array_fields = nil)
-			return select(array_fields)
-		end
-
-		def select(array_fields = nil)
-			return ResultSet.new(self, array_fields)
-		end
-
-		def insert(record)
-			if record.id != 0
-				raise "Record already exists."
-			else
-				id = new_id
-				record.save_with_id(id)
-				@records[id] = record
-				@persisted = false
-				return id
-			end
-		end
-
-		def update(record)
-			@persisted = false
-			@records[record.id] = record.update
-		end
-
-		def delete(record)
-			@persisted = false
-			@records.delete(record.id)
-		end
-
-		def drop
-			@structure_file.destroy
-			@records_file.destroy
-		end
-
-		def persist
-			@structure_file.contents['last_id'] = @last_id
-			@fields.each do |id, field|
-				@structure_file.contents['fields'][id] = field.to_hash
-			end
-			@structure_file.save
-
-			@records_file.contents = {}
-			@records.each do |id, record|
-				@records_file.contents[id] = record.to_hash
-			end
-			@records_file.save
-			@updated_at = Time.now.to_i
-			@persisted = true
-		end
-
-		def to_hash
-			return { "name" => @name, "updated_at" => @updated_at }
-		end
-
-		def updated_at_time
-			Time.at(@updated_at)
-		end
-
-		private
-
-		def new_id
-			@last_id = @last_id + 1
-			return @last_id
-		end
-
-		def add_main_fields
-			if @fields["id"].nil?
-				id_field = self.field('id')
-				id_field.type 				= "Fixnum"
-				id_field.nullable 		= false
-				id_field.default 		= 0
-			end
-			if @fields["created_at"].nil?
-				created_field = self.field('created_at')
-				created_field.type 				= "Fixnum"
-				created_field.nullable 		= false
-				created_field.default 		= 0
-			end
-			if @fields["updated_at"].nil?
-				updated_field = self.field('updated_at')
-				updated_field.type 				= "Fixnum"
-				updated_field.nullable 		= false
-				updated_field.default 		= 0
-			end
-		end
-
-	end
+
+  class Table
+
+    include JSONdb::Validations::Naming
+    include JSONdb::Logger
+    include JSONdb::Fields
+    include JSONdb::Records
+
+    attr_reader :created_at, :updated_at, :persisted
+    attr_accessor :timestamp
+
+    def initialize(name, new_table = true)
+      @name = name
+      
+      @persisted = false
+
+      JSONdb.records[@name] = Hash.new 
+      JSONdb.fields[@name] = Hash.new
+
+      set_defaults
+      add_main_fields
+      init_table(new_table)
+    end
+
+    def persist
+      @persisted = true
+      @file.contents = records_to_hash
+      @file.write
+    end
+
+    def to_hash
+      {
+        @name => {
+          "created_at" => @created_at,
+          "updated_at" => @updated_at,
+          "last_id" => @last_id,
+          "fields" => fields_to_hash
+        },
+      }
+    end
+
+    def destroy
+      @file.destroy
+    end
+
+    private
+
+    def new_id
+      @last_id = @last_id + 1
+      return @last_id
+    end
+
+    def set_defaults
+      @created_at     = Time.now.to_i
+      @updated_at     = Time.now.to_i
+
+      @timestamp      = true
+      @id_autonumber  = true
+      @last_id        = 0
+    end
+
+    def init_table(new_table)
+      begin
+        if allowed_name?(@name)
+          @file = FileOps.new(JSONdb.settings.folder, "#{@name}.json", 'table', true)
+          @file.read
+
+          records_in_file = @file.contents
+      
+          JSONdb.records[@name] = Hash.new
+          records_in_file.each do |key, values|
+            JSONdb.records[@name][values['id']] = Record.new(@name, values)
+          end
+
+          if new_table
+            @file.write
+            @persisted = true
+            log("Created data file for '#{@name}'.", :info)
+          else
+            @persisted = true
+            log("Loaded data file for '#{@name}'.", :info)
+          end
+        else
+          log("Could not initialize class for table '#{@name}'.", :error)
+        end
+      rescue
+        log("Could not initialize class for table '#{@name}'.", :error)
+      end
+    end
+
+
+  end
+
 end

data/lib/jsondb/tables.rb

@@ -0,0 +1,78 @@
+module JSONdb
+
+    module Tables 
+
+    include JSONdb::Logger
+
+    def table(name)
+      begin
+        return JSONdb.tables[name]
+      rescue
+        log("Table does not exists '#{name}'.", :error)
+        return nil
+      end
+    end
+
+    def table_names
+      JSONdb.tables.keys
+    end
+
+    def table_count
+      return table_names.count
+    end
+
+    def table_exists?(name)
+      JSONdb.tables.keys.include?(name)
+    end
+
+    def load_table(name)
+      begin
+        JSONdb.tables[name] = JSONdb::Table.new(name, false)
+        log("Loaded from disk '#{name}',", :info)
+        return true
+      rescue
+        log("Cannot load from disk '#{name}'", :error)
+        return false
+      end
+    end
+
+    def create_table(name)
+      if table_exists?(name)
+        log("Already exists '#{name}'.", :error)
+        return false
+      else
+        begin
+          JSONdb.tables[name] = JSONdb::Table.new(name, true) 
+          log("Created '#{name}'.", :info)
+          return true
+        rescue
+          log("Cannot create '#{name}'", :error)
+          return false
+        end
+      end
+    end
+
+    def drop_table(name)
+      begin
+        JSONdb.tables[name].destroy
+        JSONdb.tables[name] = nil
+        JSONdb.tables.delete(name)
+        log("Deleted '#{name}'.", :info)
+        return true
+      rescue
+        log("Could not delete '#{name}'.", :error)
+        return false
+      end
+    end
+
+    def tables_to_hash
+      to_hash = Hash.new
+      JSONdb.tables.each do |key, values|
+        to_hash = to_hash.merge(values.to_hash)
+      end
+      return to_hash
+    end
+
+  end
+
+end

data/lib/jsondb/validations.rb

@@ -0,0 +1,133 @@
+module JSONdb
+
+  module Validations
+
+    module Naming
+
+      include JSONdb::Logger
+      
+      def allowed_name?(name)
+        if (name =~ /^[a-zA-Z0-9_]+$/).nil?
+          log("Name '#{name}' not allowed. /^[a-zA-Z0-9_]+$/", :error)
+          return false
+        else
+          return true
+        end
+      end
+    end
+
+    module Types
+
+      include JSONdb::Logger
+
+      AllowedTypes = [
+        "String", 
+        "Fixnum", 
+        "Integer", 
+        "Float", 
+        "Time", 
+        "Bool"
+      ]
+
+      def allowed_type?(type)
+        if AllowedTypes.include?(type.to_s)
+          return true
+        else
+          log("Validation: Type '#{type.to_s}' not allowed", :error)
+          return false
+        end
+      end
+
+      def validate_type(_class, _value)
+        case _class
+        when "Bool"
+          bool?(_class, _value)
+        when "String"
+          string?(_class, _value)
+        when "Fixnum", "Integer", "Float"
+          numeric?(_class, _value)
+        when "Time"
+          time?(_class, _value)
+        else
+          log("Validation: '#{_class}' type not allowed", :error)
+          return false
+        end
+      end
+
+      private
+      
+      def bool?(_class, _value)
+        case _value
+        when true, false
+          return true
+        else
+          log("Validation: Bool: Not a Bool type", :error)
+          return false
+        end
+      end
+
+      def string?(_class, _value)
+        if _class == _value.class.to_s
+          return true
+        else
+          log("Validation: #{_class}: Value '#{_value}' not allowed for '#{_class}' type", :error)
+          return false
+        end
+      end
+
+      def numeric?(_class, _value)
+        case _class
+        when "Fixnum", "Integer"
+          if _value.class.to_s == "Fixnum"
+            return true
+          else
+            log("Validation: '#{_value}' is not Integer", :error)
+            return false
+          end
+        when "Float"
+          case _value.class.to_s
+          when "Float"
+            return true
+          when "Fixnum"
+            return true
+          else
+            log("Validation: '#{_value} is not a Float type", :error)
+          end
+        else
+          log("Validation: '#{_value} is not a Numeric type", :error)
+          return false
+        end
+      end
+
+      def time?(_class, _value)
+        if eval(_value).class.to_s == "Time"
+          return true
+        else
+          log("Validation: '#{_value} is not a Time type", :error)
+          return false
+        end
+      end
+    end # Types
+
+    module Records
+
+      include JSONdb::Validations::Types
+
+      FieldsToNotVerify = ['id', 'created_at', 'updated_at']
+
+      def record_validates?(table_name, record)
+        table_fields = JSONdb.fields[table_name]
+        table_fields.each do |field_name, field_values|
+          if FieldsToNotVerify.include?(field_name) == false
+            actual_value = record.send field_name.to_sym
+            return false if field_values.nullable == false and actual_value.nil?
+            return false if validate_type(field_values.type, actual_value) == false
+          end
+        end
+        return true # true if no previous invalidation
+      end
+
+    end
+
+  end # Validations
+end # JSONdb