easycache 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4ea977cf6a6a27a16734292e29d1e2c6a999a349584be9329992122286476f57
+  data.tar.gz: 4849b2cf1b564da41304e6e3e393d215c5267771445e5320311332f7ff86e180
+SHA512:
+  metadata.gz: 3053b6f55221322790fe99230b7bd939f482dc95f4fd16550a700f73a1939b19e5682080be6417aaa398d687576e7cd2f27cdc54d299df844b88b14166d4313f
+  data.tar.gz: d1d26932c40eaaa986bca6ef3066242c2289932e1831cf2a1d9380b7e6ba9b0bc52a85eff8664e06700cd5874757562393fab57b023242974721ad289ce6c9a1

data/README.md

@@ -0,0 +1,59 @@
+# EasyCache
+<p align="center">
+
+[![Gem Version](https://badge.fury.io/rb/easy-cache.svg)](https://badge.fury.io/rb/easy-cache)
+![License](https://img.shields.io/badge/license-AGPL%203.0-blue.svg)
+[![Lint](https://github.com/malvads/easy-cache/actions/workflows/lint.yml/badge.svg)](https://github.com/malvads/easy-cache/actions/workflows/lint.yml)
+[![Tests](https://github.com/malvads/easy-cache/actions/workflows/tests.yml/badge.svg)](https://github.com/malvads/easy-cache/actions/workflows/tests.yml)
+[![Build](https://github.com/malvads/easy-cache/actions/workflows/build.yml/badge.svg)](https://github.com/malvads/easy-cache/actions/workflows/build.yml)
+</p>
+EasyCache is an in-memory cache system for Ruby designed for situations where you don't want to set up Redis or Memcached but still need a simple solution for caching key-value data.
+
+## Install
+
+```
+gem install easy-cache
+```
+
+## Usage
+
+To use EasyCache in your Ruby project, require the library and include it in your code:
+
+```ruby
+require 'easycache'
+
+cache = EasyCache.new
+```
+
+## Storing data
+
+```ruby
+key = "my_key"
+cache_ttl = 3600
+store_in_mem = true
+data = cache.fetch(cache_key, cache_ttl, store_in_mem) do
+    my_http_get
+end
+```
+
+Now data is in-mem for the next 3600 second (store_in_mem variable is important for storing data first time).
+
+## Getting data
+
+If i want to get the data stored in mem i do
+
+```ruby
+data = cache.fetch("my_key")
+```
+
+or i can also re-call the same function
+
+```ruby
+data = cache.fetch("my_key", cache_ttl, store_in_mem) do
+    my_http_get
+end
+```
+
+because the data is already cached, so it will not call the block, it will return the cached data instead.
+
+This will output the cached data, remember that cached data is stored in mem for only 3600 seconds

data/lib/easycache.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+#
+# This is the core of EasyCache.
+# EasyCache provides an easy-to-use, in-memory cache system for Ruby.
+# It is designed for situations where you don't want to set up Redis or Memcached but still want
+# a simple solution for caching key-value data.
+#
+class EasyCache
+  def initialize
+    @cache = {}
+    @mutex = Mutex.new
+  end
+
+  def fetch(key, expiration = 3600, store_in_cache = false) # rubocop:disable Style/OptionalBooleanParameter
+    @mutex.synchronize do
+      return cached_value(key, store_in_cache) if cache_contains_valid_data?(key) && !block_given?
+
+      if should_fetch_from_block?(key, store_in_cache)
+        value = block_given? ? yield : nil
+        cache_value(key, value, expiration) if value && store_in_cache
+        value
+      else
+        cached_value(key, store_in_cache)
+      end
+    end
+  end
+
+  private
+
+  def cache_contains_valid_data?(key)
+    @cache.key?(key) && !expired?(key)
+  end
+
+  def should_fetch_from_block?(key, store_in_cache)
+    !store_in_cache || (!@cache.key?(key) || expired?(key))
+  end
+
+  def cached_value(key, _store_in_cache)
+    @cache[key][:value]
+  end
+
+  def cache_value(key, value, expiration)
+    @cache[key] = { value: value, timestamp: Time.now, expiration: expiration }
+  end
+
+  def expired?(key)
+    return false unless @cache.key?(key) && @cache[key].key?(:timestamp) && @cache[key].key?(:expiration)
+
+    expiration_date = @cache[key][:timestamp] + @cache[key][:expiration]
+    if Time.now > expiration_date
+      @cache.delete(key)
+      true
+    else
+      false
+    end
+  end
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: easycache
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Miguel Álvarez
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-02-27 00:00:00.000000000 Z
+dependencies: []
+description: A simple gem for store and manage data in mem
+email: thegexi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/easycache.rb
+homepage: https://github.com/malvads/easy-cache
+licenses:
+- AGPL-3.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Easy to use in-mem cache system for ruby
+test_files: []