seeds-db 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a48cfacca9e8e53f2c37e749c3f1432c9dd955e8
+  data.tar.gz: ab99a9ebbbf753067f71d5b7e955fa8e01c5c61a
+SHA512:
+  metadata.gz: ec0170ffd24cc746a74ebec07d167f2c8ebd0d23cb5f3e9aea08a125ba6c25beea038a472d38215acbee69065da61e66f755e177f9adaa8750a78f522108816d
+  data.tar.gz: f04632e1a226a59b1b1325561485bbfa905f5c9f5460a44bf069384940645fca7ca9e33ffdf023371ee0b0ebc4c6e8974684d81b779cd114ef4d5d181db5023e

data/bin/seeds

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+
+require 'seeds'
+require 'optparse'
+
+options = {}
+begin
+  OptionParser.new do |opts|
+    opts.banner = 'Usage: seeds [-options]'
+
+    opts.on('-d', '-d directory', 'Sets seeds directory if directory is not ./seeds') do |arg|
+      options[:dir] = arg
+    end
+
+    opts.on('-c', '-c create', 'Creates an entry in specified seed') do |arg|
+      options[:action] = 'c' if options[:action].nil?
+      options[:seed] = arg
+    end
+
+    opts.on('-r', '-r read', 'Displays all entries in seeds directory') do |arg|
+      options[:action] = 'r' if options[:action].nil?
+      options[:seed] = arg
+    end
+
+    opts.on('-u', '-u update', 'Updates an entry/entries in specified seed') do |arg|
+      options[:action] = 'u' if options[:action].nil?
+      options[:seed] = arg
+    end
+
+    opts.on('-d', '-d create', 'Deletes an entry/entries in specified seed') do |arg|
+      options[:action] = 'd' if options[:action].nil?
+      options[:seed] = arg
+    end
+
+    opts.on('-n', '-n create', 'Creates a seed with specified name') do |arg|
+      options[:action] = 'n' if options[:action].nil?
+      options[:seed] = arg
+    end
+
+    opts.on('-m', '-m delete', 'Deletes a seed with specified name') do |arg|
+      options[:action] = 'm' if options[:action].nil?
+      options[:seed] = arg
+    end
+
+    opts.on('-w', '-w with data', 'Data to create/update leaf with') do |arg|
+      data = {}
+      split = arg.split(',')
+      split.each do |s|
+        key, value = s.split('=')
+        data[key.to_sym] = value
+      end
+      options[:with] = data
+    end
+
+    opts.on('-k', '-k constraints', 'Constraints for read/update/deletes') do |arg|
+      data = {}
+      split = arg.split(',')
+      split.each do |s|
+        key, value = s.split('=')
+        data[key.to_sym] = value
+      end
+      options[:con] = data
+    end
+  end.parse!
+rescue
+  puts 'No actions were specified. See a list of options with -h'
+end
+
+seeds = options[:dir].nil? ? Seeds.new : Seeds.new(options[:dir])
+
+case options[:action]
+when 'c'
+  response = options[:with].nil? ? seeds.create(options[:seed]) : seeds.create(options[:seed], options[:with])
+  puts response
+when 'r'
+  if options[:seed] == 'all'
+    Dir.foreach './seeds' do |seed|
+      next if seed == '.' || seed == '..'
+      response = seeds.read(seed.split('.seed')[0])
+      puts "\n#{seed} ------------------------------------------------------------------------"
+      puts response[:results]
+    end
+  else
+    response = seeds.read(options[:seed])[:results]
+    puts "#{options[:seed]} was not found" if response.nil?
+    puts response unless response.nil?
+  end
+when 'u'
+  seed_name = options[:seed]
+  with_opts = options[:with]
+
+  response = options[:con].nil? ? seeds.update(seed_name, with_opts) : seeds.update(seed_name, with_opts, options[:con])
+  puts response
+when 'd'
+  response = options[:con].nil? ? seeds.delete(options[:seed]) : seeds.delete(options[:seed], options[:con])
+  puts response
+when 'n'
+  response = seeds.create_seed(options[:seed])
+  puts response
+when 'm'
+  response = seeds.delete_seed(options[:seed])
+  puts response
+else
+  puts 'No actions were specified. See a list of options with -h'
+end

data/lib/crud.rb

@@ -0,0 +1,98 @@
+require 'lru_redux'
+require_relative './response'
+require_relative './leaf'
+
+class CRUD
+  def initialize(path)
+    @dir = path
+    @cache = LruRedux::Cache.new(10)
+  end
+
+  def create(seed_name, data)
+    seed = get_seed(seed_name)
+    seed = construct_seed(seed_name) if seed.nil?
+    success = Leaf.create_leaf(seed, data)
+
+    @cache[seed_name.to_sym] = seed
+    update_file(seed, seed_name)
+
+    return Response.create_response(false, 'Unable to create leaf') unless success
+    Response.create_response(true, "Success leaf was created and added to #{seed_name}")
+  end
+
+  def read(seed_name, rules)
+    seed = get_seed(seed_name)
+    return Response.create_response(false, "#{seed_name} seed was not found") if seed.nil?
+    response = Leaf.read_leaf(seed[:leaves], rules)
+
+    return Response.create_response(false, 'No leaves found containing specified rules') if response.empty?
+    Response.create_response(true, 'Success', results: response)
+  end
+
+  def update(seed_name, data, rules)
+    seed = get_seed(seed_name)
+    return Response.create_response(false, "#{seed_name} seed was not found") if seed.nil?
+    success = Leaf.update_leaf(seed[:leaves], data, rules)
+
+    @cache[seed_name.to_sym] = seed
+    update_file(seed, seed_name)
+
+    return Response.create_response(false, 'No leaves found containing specified rules') unless success
+    Response.create_response(true, "Success leaves were updated in #{seed_name}")
+  end
+
+  def delete(seed_name, rules)
+    seed = get_seed(seed_name)
+    return Response.create_response(false, "#{seed_name} seed was not found") if seed.nil?
+    success = Leaf.delete_leaf(seed[:leaves], rules)
+
+    @cache[seed_name.to_sym] = seed
+    update_file(seed, seed_name)
+
+    return Response.create_response(false, 'No leaves found containing specified rules') unless success
+    Response.create_response(true, "Success leaves were deleted in #{seed_name}")
+  end
+
+  def create_seed(seed)
+    return Response.create_response(false, 'Seed already exists') if File.exist? "#{@dir}/#{seed}.seed"
+    seed = construct_seed(seed)
+
+    Response.create_response(true, "Success #{seed} was created as a seed")
+  end
+
+  def delete_seed(seed)
+    return Response.create_response(false, 'Seed did not exist') unless File.exist? "#{@dir}/#{seed}.seed"
+    File.delete "#{@dir}/#{seed}.seed"
+    Response.create_response(true, 'Success seed was delete')
+  end
+
+  private
+
+  def get_seed_path(seed)
+    @dir + "/#{seed}.seed"
+  end
+
+  def get_seed(seed)
+    seed_path = get_seed_path(seed)
+    return @cache[seed.to_sym] unless @cache[seed.to_sym].nil?
+    loaded_seed = Marshal.load(File.open(seed_path)) if File.exist? seed_path
+    @cache[seed.to_sym] = loaded_seed
+    loaded_seed
+  end
+
+  def construct_seed(seed)
+    seed_path = get_seed_path(seed)
+    seed_template = {
+      name: seed,
+      creation_date: Time.now.strftime('%d/%m/%Y %H:%M'),
+      leaves: []
+    }
+
+    File.open(seed_path, 'w') { |file| file.write(Marshal.dump(seed_template)) }
+    seed_template
+  end
+
+  def update_file(seed, seed_name)
+    File.open(get_seed_path(seed_name), 'w') { |file| file.write(Marshal.dump(seed)) }
+  end
+end

data/lib/leaf.rb

@@ -0,0 +1,68 @@
+require 'securerandom'
+
+module Leaf
+  def self.create_leaf(seed, data)
+    leaf_template = {
+      uid: SecureRandom.hex,
+      creation_date: Time.now.strftime('%d/%m/%Y %H:%M')
+    }
+
+    seed[:leaves] << if data.length >= 1
+                       add_data(leaf_template, data)
+                     else
+                       leaf_template
+                     end
+
+    true
+  end
+
+  def self.read_leaf(leaves, rules)
+    return leaves unless rules.length >= 1
+    search_for_leaves(leaves, rules.to_a)
+  end
+
+  def self.update_leaf(leaves, data, rules)
+    results = rules.length >= 1 ? search_for_leaves(leaves, rules.to_a) : leaves
+    false unless results.length >= 1
+
+    results.length.times do |i|
+      add_data(leaves[i], data, true)
+    end
+    true
+  end
+
+  def self.delete_leaf(leaves, rules)
+    unless rules.length >= 1
+      leaves.clear
+      return true
+    end
+
+    results = search_for_leaves(leaves, rules.to_a)
+    false unless results.length >= 1
+
+    results.each do |leaf|
+      leaves.delete(leaf)
+    end
+    true
+  end
+
+  # Private methods
+
+  def self.search_for_leaves(leaves, rules)
+    rule = rules.pop
+    results = leaves.select { |leaf| leaf[rule[0]] == rule[1] }
+
+    return search_for_leaves(results, rules) unless rules.empty? || results.empty?
+    results
+  end
+
+  def self.add_data(template, data, overwrite = false)
+    data.each do |key, value|
+      template[key] = value unless (template.key? key) && !overwrite
+    end
+    template
+  end
+
+  private_class_method :search_for_leaves
+  private_class_method :add_data
+end

data/lib/response.rb

@@ -0,0 +1,26 @@
+module Response
+  def self.failure(err)
+    {
+      success: false,
+      error: err
+    }
+  end
+
+  def self.success(success, opts)
+    response = {
+      success: true,
+      msg: success
+    }
+
+    return response unless opts.length >= 1
+    opts.each do |key, value|
+      response[key] = value unless response.key? key
+    end
+    response
+  end
+
+  def self.create_response(bool, msg, opts = {})
+    return failure(msg) unless bool
+    success(msg, opts)
+  end
+end

data/lib/seeds.rb

@@ -0,0 +1,60 @@
+# Dir[File.expand_path('../*', __FILE__)].each { |path| $LOAD_PATH.unshift path }
+require_relative './response'
+require_relative './crud'
+
+class Seeds
+  def initialize(path = Dir.pwd)
+    @dir_path = path << '/seeds'
+    Dir.mkdir @dir_path unless Dir.exist? @dir_path
+    @crud = CRUD.new(@dir_path)
+  end
+
+  # Creates a new leaf in the specified seed, seed will be created if it doesn't exist.
+  # @param seed [String] name of the seed to create in
+  # @param data [Hash] OPTIONAL: Specifies data to be added to the new leaf
+  # @return response [Hash] indicates success/failure
+  def create(seed, data = {})
+    return Response.create_response(false, 'data was not of type Hash') unless data.is_a? Hash
+    @crud.create(seed, data)
+  end
+
+  # Reads a leaf in the specified seed and returns it.
+  # @param seed [String] name of the seed to read from
+  # @param rules [Hash] OPTIONAL: Specifies rules for the read
+  # @return response [Hash] indicates success/failure, contains results from read if success
+  def read(seed, rules = {})
+    @crud.read(seed, rules)
+  end
+
+  # Updates a leaf in the specified seed.
+  # @param seed [String] name of the seed to update in
+  # @param data [Hash] updates leaves with data, will overwrite existing data
+  # @param rules [Hash] OPTIONAL: Specifies rules for the update
+  # @return response [Hash] indicates success/failure
+  def update(seed, data, rules = {})
+    return Response.create_response(false, 'data was not of type Hash') unless data.is_a? Hash
+    @crud.update(seed, data, rules)
+  end
+
+  # Deletes a leaf in the specified seed.
+  # @param seed [String] name of the seed to read from
+  # @param rules [Hash] OPTIONAL: Specifies rules for the update, if no rules specified all leaves will be deleted
+  # @return response [Hash] indicates success/failure
+  def delete(seed, rules = {})
+    @crud.delete(seed, rules)
+  end
+
+  # Creates a new seed.
+  # @param seed [String] name of the seed to create
+  # @return response [Hash] indicates success/failure
+  def create_seed(seed)
+    @crud.create_seed(seed)
+  end
+
+  # Deletes a seed.
+  # @param seed [String] name of the seed to delete
+  # @return response [Hash] indicates success/failure
+  def delete_seed(seed)
+    @crud.delete_seed(seed)
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: seeds-db
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Isaiah Soung
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lru_redux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.41.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.41.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+description: 
+email: 
+executables:
+- seeds
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/seeds
+- lib/crud.rb
+- lib/leaf.rb
+- lib/response.rb
+- lib/seeds.rb
+homepage: https://github.com/Isoung/seeds
+licenses: []
+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.2
+signing_key: 
+specification_version: 4
+summary: Seeds is a plug&play persistent storage for Ruby
+test_files: []