stg 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e9c7c1bdc57ae80ecb2f59b5104e4c2e2be91521044a8921e0a801879843543d
+  data.tar.gz: ea29aa8292c71cfc198232b977eca56a971698e2de7efed838ea78427c92ce79
+SHA512:
+  metadata.gz: f57259e0e823d045aedef0004c892c9009f8ae5bdd6ad5820500402f0663e36b24125a1815fa0e6d2d3f59efc8db4540c5582ff0ebcb8ef57c425e4a3c4c2681
+  data.tar.gz: e2368f884e3fad925e0bd9d0716f663189a9cbd8e772f7a32b6ad567e3451dd9ec82052fb29c30e21caffec5f9ba22103f56bdc666a405ba928f701af92bb349

data/README.md

@@ -0,0 +1,27 @@
+<div align="center">
+  <h1>Stolen Git</h1>
+  <span>
+    Have you ever wanted to use Git but it's too good?
+  </span>
+</div>
+<br>
+
+## What is stolen git? \ Why?
+
+Stolen git is well... you get it. I'm building a mini git clone to learn version control and get comfortable with ruby.
+
+## Commands
+
+| Command  | description                                                       | Flags                                                                                              |
+| -------- | ----------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
+| init     | Initialize the project                                            | N/A                                                                                                |
+| stage    | add a file or directory to be tracked                             | N/A                                                                                                |
+| commit   | Save the current tracked state                                    | `-n [--name]` <br> `-d [--description]`                                                            |
+| diff     | get the difference between working directory and the last commit  | N/A                                                                                                |
+| log      | print out commit history (limit print by a number `log <number>`) | N/A                                                                                                |
+| checkout | check a commit or a branch without loss in data                   | `-c [--commit] <commit_id>` to check out a commit instaed of a branch wihout changing HEAD pointer |
+| branch   | List all branches. (or creating a branch by `branch <name>`)      | N/A                                                                                                |
+
+## Tech stack
+
+Just ruby... (for now at least)

data/bin/stg

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'stg'
+
+Stg::CLI.start

data/lib/actions.rb

@@ -0,0 +1,349 @@
+require 'securerandom'
+require 'optparse'
+require_relative 'differencing'
+require_relative 'utils'
+require 'fileutils'
+require 'colorize'
+require 'json'
+module Actions
+  include DiffCalc
+
+  def p_initialize
+    # Check if already initialized
+    if File.exist?('.stolen-git')
+      if confirm?('An instance of stolen-git is already up here do you want to replace it')
+        if confirm?('THIS WILL DELETE ALL COMMITS AND INSTANCES OF stolen-git. ARE YOU SURE')
+          FileUtils.rm_rf('.stolen-git')
+
+          if File.exist?('.stolen-git')
+            puts 'An error occured during the deletion process of the old directory of stolen-git'
+          else
+            p_initialize
+          end
+        else
+          puts 'ok'
+        end
+      else
+        puts 'ok'
+      end
+
+    else
+      # main dot directory
+      FileUtils.mkdir_p('.stolen-git')
+
+      # Sub Directories
+      FileUtils.mkdir_p('.stolen-git/commits')
+      FileUtils.mkdir_p('.stolen-git/branches')
+
+      FileUtils.mkdir_p('.stolen-git/storage')
+      FileUtils.mkdir_p('.stolen-git/storage/blobs')
+      FileUtils.mkdir_p('.stolen-git/storage/trees')
+
+      # main files
+      File.write('.stolen-git/project_info.json', {})
+      File.write('.stolen-git/commits.json', JSON.pretty_generate({ commits: [] }))
+      File.write('.stolen-git/index.json', {})
+
+      main_branch_id = SecureRandom.uuid
+      File.write(".stolen-git/branches/#{main_branch_id}.json",
+                 JSON.pretty_generate({ name: 'main', created_at: Time.now, commit_pointer: '' }))
+
+      File.write('.stolen-git/pointer.json', JSON.pretty_generate({ point_to: main_branch_id, type: 'branch' }))
+      puts 'Stolen-git initialized Sucessfully :D'
+    end
+  end
+
+  def stage
+    files = ARGV
+    if files.empty?
+      puts 'Usage: stolen-git stage <files..>'
+      return
+    end
+
+    index = JSON.parse(File.read('.stolen-git/index.json'))
+    files.each do |file_path|
+      file_hash = get_file_hash(file_path)
+      file_content = File.read(file_path)
+
+      next if index[file_path] && index[file_path]['hash'] == file_hash
+
+      # Create blob
+      File.write(".stolen-git/storage/blobs/#{file_hash}", file_content)
+
+      # Assign index_obj
+      default_index_obj = {}
+      index[file_path] ||= default_index_obj
+      index[file_path]['hash'] = file_hash
+    end
+    index = index.sort.to_h
+    File.write('.stolen-git/index.json', JSON.pretty_generate(index))
+  end
+
+  def commit
+    options = { name: '', description: '' }
+
+    # Getting commit name & description
+    OptionParser.new do |opts|
+      opts.banner = 'Usage: stolen-git commit [options]'
+
+      opts.on('-n', '--name NAME', 'Add a commit name') do |name|
+        options[:name] = name
+      end
+
+      opts.on('-d', '--description DESCRIPTION', 'Add a commit description') do |description|
+        options[:description] = description
+      end
+    end.parse!
+
+    options[:name] = ask('Add a commit name: ') if options[:name].empty?
+
+    # Get the index
+    index = JSON.parse(File.read('.stolen-git/index.json'))
+    tree_content = {
+      entries: []
+    }
+
+    commit_history = JSON.parse(File.read('.stolen-git/commits.json'))
+
+    pointer = read_json('.stolen-git/pointer.json')
+    branch_id = pointer['point_to']
+    branch_content = read_json(".stolen-git/branches/#{branch_id}.json")
+    parent_commit = branch_content['commit_pointer']
+
+    # Getting differences to last commit
+
+    no_insertions = 0
+    no_deletions = 0
+    no_file_changed = 0
+    commit_diff = {}
+
+    getting_diff = lambda do |entries|
+      parent_index = 0
+
+      index.each do |key, value|
+        if entries && entries[parent_index] && key == entries[parent_index]['path']
+          new_hash = value['hash']
+          old_hash = entries[parent_index]['hash']
+          parent_index += 1
+          next if value['hash'] == new_hash
+
+          entry_content = File.read(".stolen-git/storage/blobs/#{old_hash}").lines.to_a
+          new_entry_content = File.read(".stolen-git/storage/blobs/#{new_hash}").lines.to_a
+          compute_diff(entry_content, new_entry_content)
+          diff = build_sequences
+          no_insertions += diff[:insertions]
+          no_deletions += diff[:deletions]
+          no_file_changed += 1
+          commit_diff[key] = diff
+        else
+          new_entry_content = File.read(".stolen-git/storage/blobs/#{value['hash']}").lines.to_a
+          compute_diff('', new_entry_content)
+          diff = build_sequences
+
+          no_insertions += diff[:insertions]
+          no_deletions += diff[:deletions]
+          no_file_changed += 1
+          commit_diff[key] = diff
+        end
+      end
+    end
+
+    if parent_commit.empty?
+      getting_diff.call(nil)
+    else
+      parent_commit_content = read_json(".stolen-git/commits/#{parent_commit}.json")
+      parent_tree_hash = parent_commit_content['tree_hash']
+      parent_tree_content = JSON.parse(File.read(".stolen-git/storage/trees/#{parent_tree_hash}.json"))
+      getting_diff.call(parent_tree_content['entries'])
+    end
+
+    if no_file_changed <= 0
+      puts 'Everything up to date'
+      puts "If you have changed please 'stolen-git stage' them first "
+      return
+    end
+
+    # Making the tree
+    index.each do |key, value|
+      tree_content[:entries].push({
+                                    path: key,
+                                    type: 'blob',
+                                    hash: value['hash'],
+                                    diff: commit_diff[key] || {}
+                                  })
+    end
+    tree_content[:entries] = tree_content[:entries].sort { |a, b| a['path'] <=> b['path'] }
+    tree_content = JSON.pretty_generate(tree_content)
+    tree_hash = get_string_hash(tree_content)
+    File.write(".stolen-git/storage/trees/#{tree_hash}.json", tree_content)
+
+    # Making the commit
+    # TODO: Change to actual values when personal profiles are created
+    commit_id = SecureRandom.uuid
+    commit_content = {
+      tree_hash: tree_hash,
+      created_at: Time.now,
+      id: commit_id,
+      parent_commit: parent_commit,
+      branch_id: branch_id,
+      author_profile: {
+        name: 'Amr',
+        email: 'amrbassem218@gmail.com',
+        username: 'amrbassem218'
+      },
+      name: options[:name],
+      description: options[:description],
+
+      no_insertions: no_insertions,
+      no_deletions: no_deletions,
+      no_files_changed: no_file_changed
+    }
+    commit_content = JSON.pretty_generate(commit_content)
+    commit_hash = get_string_hash(commit_content)
+    File.write(".stolen-git/commits/#{commit_hash}.json", commit_content)
+
+    # Adding commit to history
+    commit_history['commits'].push({ id: commit_id, hash: commit_hash, name: options[:name] })
+    File.write('.stolen-git/commits.json', JSON.pretty_generate(commit_history))
+
+    # Adding to branch
+    branch_content['commit_pointer'] = commit_hash
+    File.write(".stolen-git/branches/#{branch_id}.json", JSON.pretty_generate(branch_content))
+
+    # Print
+    puts "#{no_file_changed} files changed, #{no_insertions} insertions(+), #{no_deletions} deletions(-)"
+  end
+
+  def reset
+    commit_id = ARGV.first
+    commit_history = read_json('.stolen-git/commits.json')
+    pointer = read_json('.stolen-git/pointer.json')
+    branch_id = pointer['point_to']
+    branch_content = read_json(".stolen-git/branches/#{branch_id}.json")
+    current_commit_hash = branch_content['commit_pointer']
+    parent_commit_hash = if !commit_id || commit_id.empty?
+                           read_json(".stolen-git/commits/#{current_commit_hash}.json")['parent_commit']
+                         else
+                           commit_history['commits'].find { |x| x['id'] == commit_id }['hash']
+                         end
+
+    if parent_commit_hash.empty?
+      puts "The current commit is the earliest in the project. Can't reset behind that."
+      return
+    end
+    revert_to_commit(parent_commit_hash)
+    branch_content['commit_pointer'] = parent_commit_hash
+    File.write(".stolen-git/branches/#{branch_id}.json", JSON.pretty_generate(branch_content))
+  end
+
+  def checkout
+    options = { commit: false }
+
+    # Getting commit name & description
+    OptionParser.new do |opts|
+      opts.banner = 'Usage: stolen-git checkout [options]'
+
+      opts.on('-c', '--commit', 'Add a commit id instead') do
+        options[:commit] = true
+      end
+    end.parse!
+    inp = ARGV.last
+    if !inp
+      puts 'Please Enter the name of a branch or commit_id'
+    elsif options[:commit]
+      commit_history = read_json('.stolen-git/commits.json')
+      current_commit_hash = commit_history['commits'].find { |x| x['id'] == inp }['hash']
+      revert_to_commit(current_commit_hash)
+    else
+      # TODO: Handle if user enters branch_id instead
+      branch_content = {}
+      branch_id = ''
+      Dir.children('.stolen-git/branches').each do |entry|
+        branch_content = read_json(".stolen-git/branches/#{entry}")
+        if branch_content['name'] == inp
+          branch_id = File.basename(entry, '.*')
+          break
+        end
+      end
+      if branch_content.empty?
+        puts 'There is no branch with that name.'
+        nil
+      end
+      commit_hash = branch_content['commit_pointer']
+      revert_to_commit(commit_hash)
+      pointer = read_json('.stolen-git/pointer.json')
+      pointer['point_to'] = branch_id
+      pointer['type'] = 'branch'
+      File.write('.stolen-git/pointer.json', JSON.pretty_generate(pointer))
+    end
+  end
+
+  def branch
+    name = ARGV.last
+    pointer = read_json('.stolen-git/pointer.json')
+    pointed_branch = pointer['type'] == 'branch' ? pointer['point_to'] : ''
+    if name
+      first_commit = pointer['type'] == 'branch' ? read_json(".stolen-git/branches/#{pointed_branch}.json")['commit_pointer'] : pointer['point_to']
+      id = SecureRandom.uuid
+      File.write(".stolen-git/branches/#{id}.json", JSON.pretty_generate({
+                                                                           name: name,
+                                                                           created_at: Time.now,
+                                                                           commit_pointer: first_commit
+                                                                         }))
+      return
+      puts "branch #{name} created"
+    end
+    Dir.children('.stolen-git/branches').each do |entry|
+      branch_content = read_json(".stolen-git/branches/#{entry}")
+      branch_id = File.basename(entry, '.*')
+      if pointed_branch == branch_id
+        print '* '
+        puts "#{branch_content['name']}".green
+      else
+        puts "#{branch_content['name']}"
+      end
+    end
+  end
+
+  def diff
+    index = read_json('.stolen-git/index.json')
+    index.each do |key, value|
+      new_file_content = File.exist?(key) ? File.read(key) : nil
+      file_name = File.basename(key)
+      if new_file_content.nil?
+        print "@@#{file_name}".cyan
+        print " [DELETED]]\n".red
+      else
+        new_hash = get_file_hash(key)
+        next if new_hash == value['hash']
+
+        print "@@#{file_name}".cyan
+        blob_content = File.read(".stolen-git/storage/blobs/#{value['hash']}")
+        print_diff(blob_content, new_file_content)
+      end
+    end
+  end
+
+  def log
+    limit = ARGV.last
+    limit = limit && !limit.empty? ? limit.to_i : 0
+    commit_history_content = read_json('.stolen-git/commits.json')
+
+    commit_history_content['commits'].each_with_index do |commit, i|
+      break if limit > 0 && i >= limit
+
+      if limit == 0 && i >= 5
+        q = ask(':')
+        break if q == 'q'
+      end
+      commit_content = read_json(".stolen-git/commits/#{commit['hash']}.json")
+      puts
+      puts "commit #{commit_content['id']}".green
+      puts "Author #{commit_content['author_profile']['username']} <#{commit_content['author_profile']['email']}>"
+      puts "Date: #{commit_content['created_at']}"
+      puts
+      puts "    #{commit_content['name']}"
+      puts
+    end
+  end
+end

data/lib/differencing.rb

@@ -0,0 +1,219 @@
+require 'colorize'
+module DiffCalc
+  attr_reader :mem, :cnt, :old_s, :new_s
+
+  def initialize
+    @mem = {}
+    @cnt = 0
+  end
+
+  def compute_diff(old_arr, new_arr)
+    @mem = {}
+    @old_s = old_arr.is_a?(String) ? old_arr.split("\n").to_a : old_arr
+    @new_s = new_arr.is_a?(String) ? new_arr.split("\n").to_a : new_arr
+    differencing(0, 0)
+  end
+
+  def differencing(i1 = 0, i2 = 0)
+    cached = @mem[[i1, i2]]
+    return cached if cached
+
+    if i1 >= @old_s.length && i2 >= @new_s.length
+      result = { diff_cnt: 0, insertions: 0, deletions: 0, action: :done }
+      @mem[[i1, i2]] = result
+      return result
+    end
+
+    if i1 >= @old_s.length
+      result = { diff_cnt: @new_s.length - i2, insertions: @new_s.length - i2, deletions: 0, action: :insert }
+      @mem[[i1, i2]] = result
+      differencing(i1, i2 + 1) if i2 < @new_s.length
+      return result
+    end
+
+    if i2 >= @new_s.length
+      result = { diff_cnt: @old_s.length - i1, insertions: 0, deletions: @old_s.length - i1, action: :delete }
+      @mem[[i1, i2]] = result
+      differencing(i1 + 1, i2) if i1 < @old_s.length
+      return result
+    end
+
+    if @old_s[i1] == @new_s[i2]
+      result = differencing(i1 + 1, i2 + 1)
+      result = { diff_cnt: result[:diff_cnt], insertions: result[:insertions], deletions: result[:deletions],
+                 action: :keep }
+      @mem[[i1, i2]] = result
+      return result
+    end
+
+    del = differencing(i1 + 1, i2)
+    add = differencing(i1, i2 + 1)
+
+    del_cost = del[:diff_cnt] + 1
+    add_cost = add[:diff_cnt] + 1
+
+    result = if del_cost <= add_cost
+               { diff_cnt: del_cost, insertions: del[:insertions], deletions: del[:deletions] + 1, action: :delete }
+             else
+               { diff_cnt: add_cost, insertions: add[:insertions] + 1, deletions: add[:deletions], action: :insert }
+             end
+
+    @mem[[i1, i2]] = result
+    result
+  end
+
+  def build_sequences
+    i1 = 0
+    i2 = 0
+    insertion_seq = {}
+    deletion_seq = {}
+
+    while i1 < @old_s.length || i2 < @new_s.length
+      action = @mem[[i1, i2]][:action]
+
+      case action
+      when :done
+        break
+      when :keep
+        i1 += 1
+        i2 += 1
+      when :delete
+        deletion_seq[i2] ||= []
+        deletion_seq[i2].push({ old_index: i1, ma_type: 'bs' })
+        i1 += 1
+      when :insert
+        insertion_seq[i2] = { value: @new_s[i2], old_index: i1 }
+        i2 += 1
+      end
+    end
+
+    result = @mem[[0, 0]]
+    {
+      insertion_seq: insertion_seq,
+      deletion_seq: deletion_seq,
+      insertions: result[:insertions],
+      deletions: result[:deletions],
+      diff_cnt: result[:diff_cnt]
+    }
+  end
+
+  def print_diff(file_a, file_b)
+    compute_diff(file_a, file_b)
+    diff = build_sequences
+    insertions, deletions, insertion_seq, deletion_seq = diff.values_at(:insertions, :deletions, :insertion_seq,
+                                                                        :deletion_seq)
+    # printing diff
+    print "   (+): #{insertions}".green
+    print "   (-): #{deletions}\n".red
+
+    # sorting by keys
+    insertion_seq = insertion_seq.sort.to_h
+    insertion_seq_keys = insertion_seq.keys
+
+    deletion_seq = deletion_seq.sort.to_h
+    deletion_seq_keys = deletion_seq.keys
+
+    # index (old or new)
+    # value (styled text to be printed)
+    # type (-1 => deletion, 0 => insertion, 1 => not changed)
+    edit_list = []
+
+    # Getting a list of all the changes
+    insertion_poniter = 0
+    deletion_pointer = 0
+    while insertion_poniter < insertions || deletion_pointer < deletion_seq_keys.length
+      is_insertion = if insertion_poniter >= insertions
+                       false
+                     elsif deletion_pointer >= deletion_seq_keys.length
+                       true
+                     else
+                       insertion_seq_keys[insertion_poniter] < deletion_seq_keys[deletion_pointer]
+                     end
+      index = is_insertion ? insertion_seq_keys[insertion_poniter] : deletion_seq_keys[deletion_pointer]
+      if is_insertion
+        edit_list.push({ index: index, value: "#{insertion_seq[index][:value]}", type: 0,
+                         old_index: insertion_seq[index][:old_index] })
+        insertion_poniter += 1
+      else
+        deletion_seq[index] = deletion_seq[index].sort_by { |del| del[:old_index] }
+        deletion_seq[index].each do |del|
+          old_index = del[:old_index]
+          edit_list.push({ index: index, value: "#{@old_s[old_index]}", type: -1,
+                           old_index: old_index })
+        end
+        deletion_pointer += 1
+      end
+
+    end
+
+    max_space_diff = 3
+    print_queue = {}
+    # Getting all the lines to print (including context ones)
+    edit_list.each_with_index do |order, _i|
+      (order[:index] - max_space_diff..order[:index] + max_space_diff).each do |j|
+        next unless j >= 0 && j < @new_s.length
+
+        line = order[:index] == j ? order : { index: j, value: @new_s[j], type: 1, old_index: j }
+        print_queue[j] ||= []
+        print_queue[j].push(line) unless line[:type] == 1 && print_queue[j].length.positive?
+      end
+    end
+
+    print_queue = print_queue.sort.to_h
+    print_queue_keys = print_queue.keys
+    printed = {}
+
+    # Stylizing & printing lines
+    def print_line(line)
+      sign = if line[:type] == -1
+               '-'
+             else
+               line[:type] == 0 ? '+' : ''
+             end
+
+      index = if line[:type] == -1
+                line[:old_index]
+              else
+                line[:index]
+              end
+      print_text = "(#{index}) #{sign}#{line[:value]}"
+      if line[:type] == -1
+        print_text = print_text.red
+      elsif line[:type] == 0
+        print_text = print_text.green
+      end
+      puts print_text
+    end
+
+    # Printing all the lines
+    print_queue.each_with_index do |(index, lines), queue_i|
+      lines = lines.sort_by { |line| line[:type] }
+      is_changed = false
+      lines.each do |line, _i|
+        next if printed[[index, line[:type]]] == 1
+
+        print_line(line) unless is_changed == true && line[:type] == 1
+        is_changed = true
+
+        next unless line[:type] == -1
+
+        j = queue_i + 1
+
+        define_singleton_method :is_deletion? do
+          return false if j >= print_queue_keys.length
+
+          print_queue[print_queue_keys[j]]&.any? { |x| x[:type] == -1 }
+        end
+
+        while is_deletion?
+          q_i = print_queue_keys[j]
+          cur_line = print_queue[q_i].find { |x| x[:type] == -1 }
+          cur_line ||= print_queue[q_i].find { |x| x[:type] == 1 }
+          print_line(cur_line)
+          printed[[q_i, cur_line[:type]]] = 1
+          j += 1
+        end
+      end
+    end
+  end
+end

data/lib/help.rb

@@ -0,0 +1,21 @@
+module Help
+  def print_usage
+    usage_error_message = "Usage: stolen-git <command> [options]
+
+  Commands:\n"
+    commands_docs = {
+      commit: 'Save changes',
+      reset: 'Revert to commit',
+      init: 'Initialize stolen-git to start tracking'
+    }
+    max_len = 0
+    commands_docs.each_key do |command|
+      max_len = max_len > command.length ? max_len : command.length
+    end
+    commands_docs.each do |key, value|
+      command = key.to_s
+      usage_error_message << '    ' << command << ' ' * (max_len - command.length) << '   ' << value << "\n"
+    end
+    puts usage_error_message
+  end
+end

data/lib/stg.rb

@@ -0,0 +1,47 @@
+require_relative 'help'
+require_relative 'actions'
+
+command = ARGV.shift
+NAME = 'stolen-git'
+include Actions
+include Help
+case command
+when 'init'
+  p_initialize
+
+when 'commit'
+  commit
+
+when 'diff'
+  diff
+when 'test'
+  test
+
+when 'stage'
+  stage
+
+when 'check_router'
+  check_router
+when 'reset'
+  reset
+when 'log'
+  log
+
+when 'checkout'
+  checkout
+
+when 'branch'
+  branch
+
+when 'help'
+  puts print_usage
+  exit 1
+
+when nil
+  puts print_usage
+  exit 1
+
+else
+  puts "Unknown command: #{command}"
+  exit 1
+end

data/lib/utils.rb

@@ -0,0 +1,63 @@
+require 'fileutils'
+require 'optparse'
+require 'digest'
+module Utils
+  def confirm?(prompt)
+    loop do
+      print "#{prompt} (y/n): "
+      input = gets.chomp.downcase
+      case input
+      when 'y'
+        return true
+      when 'n'
+        return false
+      else
+        puts 'wrong input only enter y/n'
+      end
+    end
+  end
+
+  def ask(prompt)
+    print prompt
+    gets.chomp
+  end
+
+  def get_string_hash(str)
+    Digest::SHA256.hexdigest(str)
+  end
+
+  def read_json(path)
+    JSON.parse(File.read(path))
+  end
+
+  def get_file_hash(path)
+    Digest::SHA256.file(path).hexdigest
+  end
+
+  def get_file_from_hash(hash, dir_path)
+    Dir.glob("#{dir_path}/**/*").each do |file_path|
+      next unless File.file?(file_path)
+
+      file_hash = get_file_hash(file_path)
+      return file_path if file_hash == hash
+    end
+    nil
+  end
+
+  def revert_to_commit(commit_hash)
+    commit_content = read_json(".stolen-git/commits/#{commit_hash}.json")
+    commit_tree = read_json(".stolen-git/storage/trees/#{commit_content['tree_hash']}.json")
+    index = {}
+    commit_tree['entries'].each do |entry|
+      blob = File.read(".stolen-git/storage/blobs/#{entry['hash']}")
+      # TODO: Figure out what to do when path changes
+      File.write(entry['path'], blob)
+      index[entry['path']] ||= {}
+      index[entry['path']]['hash'] = entry['hash']
+    end
+
+    File.write('.stolen-git/index.json', JSON.pretty_generate(index))
+  end
+end
+
+include Utils

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: stg
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Amr ElTaweel
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Stg is a version control system built on an architecture inspired by
+  git's but in the great language of ruby
+email:
+- amrbeducation@gmail.com
+executables:
+- stg
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/stg
+- lib/actions.rb
+- lib/differencing.rb
+- lib/help.rb
+- lib/stg.rb
+- lib/utils.rb
+homepage: https://github.com/amrbassem218/stolen-git
+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: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Stg is like git but worse.
+test_files: []