key_value_chain 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e6f9bda4e6d93193dbb407f219688b339fbf83964c934df9a3e19e19fc549cf
+  data.tar.gz: fdb16d7af710bf239370f38a769a81afdc157c6cc70c2b46002698f2785ec240
+SHA512:
+  metadata.gz: edadbe7b571b1328f9314f67cfed9e4d3f6ea605c2f687cb1ad2db875a0019eab55ba0911c821684b143e7eb5e4d52918f664c2cc720838ecc3a429557acf2c3
+  data.tar.gz: 7caec92a77e745dae5e542c10d19a1b9f1bdaca021a931caf683803c5ac48a25d369c75c0553bcb2d50901237bf543fd692bd513b9cb15d47b736b2f5e583aaa

data/lib/key_value_chain.rb

@@ -0,0 +1,150 @@
+require 'digest'
+require 'json'
+
+
+class KeyValueChain
+  def initialize(path)
+    @path = path
+    @chain = DriveKVChain.new(path)
+  end
+  def [](key)
+    @chain[key]
+  end
+  def []=(key,value)
+    @chain[key] = value
+  end
+
+  class KVPair
+    attr_reader :key, :value
+    def initialize(prevBlockHash, key, value, nonce = -1)
+      @prevBlockHash = prevBlockHash
+      @key = key
+      @value = value
+      @nonce = nonce
+      if @nonce < 0
+        @none = 0
+        until self.is_valid?
+          @nonce += 1
+        end
+      end
+    end
+    def to_hash
+      Digest::SHA1.hexdigest self.to_json
+    end
+    def from_json(json)
+      h = JSON.parse(json)
+      @prevBlockHash = h["prevBlock"]
+      @nonce = h["nonce"]
+      @key = h["key"]
+      @value = h["value"]
+    end
+    def to_json
+      pairhash = {:prevBlock => @prevBlockHash, :nonce => @nonce, :key => @key, :value => @value}
+      JSON.generate(pairhash)
+    end
+    def is_valid?
+      self.to_hash[0,4] == "0000"
+    end
+  end
+
+  class DriveKVChain
+    def initialize(path)
+      @path = path
+      @last_block_hash = "0000000000000000000000000000000000000000"
+      self[""]
+    end
+    def [](key)
+      prev = "0000000000000000000000000000000000000000"
+      value = ""
+      File.open(@path, "a+") do |f|
+        f.each_line do |line|
+          h = JSON.parse(line)
+          raise "Broken Blockchain, invalid hashes" unless h["prevBlock"] == prev
+          prev = Digest::SHA1.hexdigest line.chomp
+          raise "Broken Blockchain, invalid nonce" unless prev[0,4] == "0000"
+          value = h["value"] if h["key"] == key
+        end
+      end
+      @last_block_hash = prev
+      value
+    end
+
+    def []=(key,value)
+      pair = KVPair.new(@last_block_hash, key, value)
+      open(@path, 'a') { |f|
+        f.puts pair.to_json
+      }
+      @last_block_hash = pair.to_hash
+    end
+  end
+
+  class MemKVChain
+    def initialize(path)
+      @blocks = []
+      @hashtable = Hash.new("")
+      @path = path
+      self.loadfile
+    end
+    def add_block_to_hash(pair)
+      if pair.is_valid?
+        @blocks << pair
+        @hashtable[pair.key] = pair.value
+        return true
+      end
+      false
+    end
+
+    def add_block(pair)
+      if add_block_to_hash(pair)
+        open(@path, 'a') { |f|
+          f.puts pair.to_json
+        }
+        return true
+      else
+        return false
+      end
+    end
+    def last_block_json
+      @blocks[-1].to_json
+    end
+    def last_block_hash
+      if @blocks.any?
+        @blocks[-1].to_hash
+      else
+        "0000000000000000000000000000000000000000"
+      end
+    end
+    def [](key)
+      @hashtable[key]
+    end
+    def []=(key, value)
+      self.add_block(KVPair.new(self.last_block_hash, key, value))
+    end
+    def loadfile(path = @path)
+      #f = File.open(path, "a+")
+      #f.foreach(path).with_index do |line, line_num|
+      #  self.add_block(pair_from_json(line))
+      #end
+      File.open(path, "a+") do |f|
+        f.each_line do |line|
+          self.add_block_to_hash(pair_from_json(line))
+        end
+      end
+
+    end
+  end
+
+  def pair_from_json(json)
+    pair = KVPair.new("", "", "", 0)
+    pair.from_json(json)
+    pair
+  end
+
+end
+
+
+
+
+
+#chain = DriveKVChain.new("./logfile")
+#(1..1000).each { |n| puts chain["key#{n}"]}

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: key_value_chain
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Till Schröder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-07 00:00:00.000000000 Z
+dependencies: []
+description: This is not a serious project! It's just for fun! This is a simple key-value
+  store that you can use just like a hash table, but it's also safed to you hard drive.
+email: tillodoc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/key_value_chain.rb
+homepage: https://gitlab.com/roetlich/keyvaluechainrb
+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.7.6
+signing_key: 
+specification_version: 4
+summary: A key-value store. With a blockchain. For fun.
+test_files: []