mps 0.5.0

data/lib/mps/elements/note.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module MPS
+  module Elements
+    class Note
+      SIGNATURE_STAMP = "note"
+      SIGNATURE_REGEX = /\Anote\z/
+      include Element
+
+      def self.parse_args(raw)
+        { tags: Element.split_args(raw)[:tags] }
+      end
+    end
+  end
+end

data/lib/mps/elements/reminder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module MPS
+  module Elements
+    class Reminder
+      SIGNATURE_STAMP = "reminder"
+      SIGNATURE_REGEX = /\Areminder\z/
+      include Element
+
+      def self.parse_args(raw)
+        p = Element.split_args(raw)
+        { tags: p[:tags], at: p[:attrs][:at] }
+      end
+    end
+  end
+end

data/lib/mps/elements/task.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module MPS
+  module Elements
+    class Task
+      SIGNATURE_STAMP = "task"
+      SIGNATURE_REGEX = /\Atask\z/
+      include Element
+
+      def self.parse_args(raw)
+        p = Element.split_args(raw)
+        { tags: p[:tags], status: p[:attrs].fetch(:status, "open") }
+      end
+
+      def done? = parsed_args[:status] == "done"
+      def open? = !done?
+    end
+  end
+end

data/lib/mps/engines/engines.rb

@@ -0,0 +1 @@
+ir "./mps"

data/lib/mps/engines/mps.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module MPS
+  module Engines
+    class EngineError < StandardError; end
+
+    class Parser
+      # Holds an unknown element type (sign not in registered element_classes).
+      Unknown = Struct.new(:ecn, :args, :refs, :body_str)
+
+      attr_reader :logger
+      attr_reader :element_classes
+      attr_reader :interpolator_classes
+
+      def initialize(config)
+        @config = config
+        @element_classes = ::MPS::Elements.constants
+          .map    { |k| ::MPS::Elements.const_get(k) }
+          .select { |x| x.class == Class }
+        @interpolator_classes = ::MPS::Interpolators.constants
+          .map    { |k| ::MPS::Interpolators.const_get(k) }
+          .select { |x| x.class == Class }
+        @logger = @config.logger
+      end
+
+      # Returns the element class whose SIGNATURE_REGEX matches +str+, or nil.
+      def self.matched_element_class(str, element_classes)
+        element_classes.find { |ec| str =~ ec::SIGNATURE_REGEX }
+      end
+
+      # Peeks ahead in +str_scanner+ for +regex_la+ without consuming input.
+      # Returns the position of the match, or string size if no match.
+      def self.look_ahead_pos(str_scanner, regex_la)
+        return str_scanner.string.size unless str_scanner.scan_until(regex_la)
+        pos = str_scanner.pos
+        str_scanner.unscan
+        pos
+      end
+
+      # Parses +mps_file_path+ into a flat hash of ref-path => element instances.
+      def self.parse_mps_file_to_elements_hash(mps_file_path, element_classes)
+        content  = File.read(mps_file_path)
+        wrapped  = "@#{::MPS::Elements::MPS::SIGNATURE_STAMP}[]{\n#{content}\n}"
+        base_ref = ::MPS::Constants::MPS_FILE_NAME_CLIPPER
+                     .call(File.basename(mps_file_path)).to_i
+
+        open_re  = ::MPS::Constants::AT_REGEXP
+        close_re = ::MPS::Constants::END_CURLY_REGEXP
+
+        elements = {}
+        stack    = []
+        pos      = 0
+
+        while pos < wrapped.size
+          open_m  = open_re.match(wrapped, pos)
+          close_m = close_re.match(wrapped, pos)
+
+          break if open_m.nil? && close_m.nil?
+
+          use_open = open_m && (close_m.nil? || open_m.begin(0) < close_m.begin(0))
+
+          if use_open
+            ref_path = if stack.empty?
+              [base_ref]
+            else
+              parent = stack.last
+              parent[:child_counter] += 1
+              parent[:ref_path] + [parent[:child_counter]]
+            end
+
+            stack.push(
+              sign:          open_m[:element_sign],
+              args:          open_m[:args],
+              body_start:    open_m.end(0),
+              child_counter: 0,
+              ref_path:      ref_path
+            )
+            pos = open_m.end(0)
+          else
+            break if stack.empty?
+
+            frame    = stack.pop
+            body_str = wrapped[frame[:body_start]...close_m.begin(0)]
+            ref_key  = frame[:ref_path].join(".")
+            ec       = matched_element_class(frame[:sign], element_classes)
+
+            elements[ref_key] = if ec
+              ec.new(args: frame[:args], refs: frame[:ref_path], body_str: body_str)
+            else
+              Unknown.new(frame[:sign], frame[:args], frame[:ref_path], body_str)
+            end
+
+            pos = close_m.end(0)
+          end
+        end
+
+        elements
+      end
+
+      class << self
+        alias parse_mps_file_to_elments_hash parse_mps_file_to_elements_hash
+      end
+    end
+
+    # Backward-compatible alias — existing code using Engines::MPS still works.
+    MPS = Parser
+  end
+end

data/lib/mps/interpolators/interpolators.rb

@@ -0,0 +1 @@
+ir "./time"

data/lib/mps/interpolators/time.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module MPS
+  module Interpolators
+    class Time
+      SIGNATURE_REGEX = /:time/
+      def get_str(**ref)
+        Chronic.parse(ref[:args].first).strftime("Date: %Y-%m-%d, Time: %H:%M")
+      end
+    end
+  end
+end

data/lib/mps/mps.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+# 
+
+def ir(rltv_rb_fp)
+  clf = caller_locations.first
+  f, l = clf.path, clf.lineno
+  rltv_rb_fp = File.expand_path(rltv_rb_fp, File.dirname(f))
+  r = require_relative(rltv_rb_fp)
+  puts("#{f} at #{l} for #{rltv_rb_fp}  #=> #{r}") if ENV["MPS_DEBUG"]=="true"
+end
+module MPS
+  def self.get_date(str)
+    return Chronic.parse(str).to_date
+  end
+  def self.get_filename_from_date(date)
+    "#{date.strftime('%Y%m%d')}.#{Constants::MPS_EXT}"
+  end
+  def self.get_filenames_from_date_range(s_date, e_date)
+    (s_date..e_date).collect do |date|
+      MPS.get_filename_from_date(date)
+    end
+  end
+  def self.open_editor(text_file)
+    init_size = 0
+    init_size = File.size(text_file) if File.exist?(text_file)
+    TTY::Editor.open(text_file, command: "vim")
+    curr_size = 0
+    curr_size = File.size(text_file) if File.exist?(text_file)
+    return curr_size-init_size
+  end
+end
+

data/lib/mps/store.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module MPS
+  class Store
+    def initialize(storage_dir)
+      @storage_dir     = storage_dir
+      @element_classes = Elements.constants
+        .map    { |k| Elements.const_get(k) }
+        .select { |x| x.class == Class }
+    end
+
+    # First .mps file found for +date+, or nil.
+    def find_file(date)
+      find_files(date).first
+    end
+
+    # All .mps files matching +date+ (handles multiple files per day).
+    def find_files(date)
+      date_str = date.strftime("%Y%m%d")
+      Dir[File.join(@storage_dir, "#{date_str}*.#{Constants::MPS_EXT}")]
+        .select { |f| File.basename(f) =~ Constants::MPS_FILE_NAME_REGEXP }
+        .sort
+    end
+
+    # Existing file for +date+, or a generated new path (file not yet created).
+    def find_or_create_path(date)
+      find_file(date) || File.join(@storage_dir, Constants::MPS_NEW_FILE_NAME_GEN.call(date))
+    end
+
+    # Parsed elements hash for +date+. Returns {} when no file exists.
+    def parse_date(date)
+      path = find_file(date)
+      return {} unless path
+      Engines::Parser.parse_mps_file_to_elements_hash(path, @element_classes)
+    end
+
+    # Appends a new element to today's (or +date+'s) file. Returns the file path.
+    def append(type:, body:, tags: [], attrs: {}, date: Date.today)
+      args_parts = attrs.map { |k, v| "#{k}: #{v}" } + Array(tags)
+      args_str   = args_parts.join(", ")
+      path       = find_or_create_path(date)
+      File.open(path, "a") { |f| f.write("\n@#{type}[#{args_str}]{\n  #{body}\n}\n") }
+      path
+    end
+
+    # All .mps files in storage, sorted by filename (chronological).
+    def all_files
+      Dir[File.join(@storage_dir, "*.#{Constants::MPS_EXT}")]
+        .select { |f| File.basename(f) =~ Constants::MPS_FILE_NAME_REGEXP }
+        .sort
+    end
+
+    # Files whose date-stamp is >= +since_date+.
+    def files_since(since_date)
+      since_str = since_date.strftime("%Y%m%d")
+      all_files.select { |f| File.basename(f).slice(0, 8) >= since_str }
+    end
+
+    # Full-text search across files. Returns [{element:, file:, date_str:}].
+    # +since_date+ is a Date; +type_filter+ and +tag_filter+ are strings.
+    def search(query, type_filter: nil, tag_filter: nil, since_date: nil)
+      files = since_date ? files_since(since_date) : all_files
+      files.flat_map do |file|
+        date_str = File.basename(file).slice(0, 8)
+        Engines::Parser.parse_mps_file_to_elements_hash(file, @element_classes)
+          .values
+          .reject { |e| e.is_a?(Elements::MPS) }
+          .select { |e| type_filter.nil? || e.class::SIGNATURE_STAMP == type_filter }
+          .select { |e| tag_filter.nil?  || e.tags.include?(tag_filter) }
+          .select { |e| query.nil?       || e.body_str.downcase.include?(query.downcase) }
+          .map    { |e| { element: e, file: file, date_str: date_str } }
+      end
+    end
+  end
+end

data/lib/mps/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MPS
+  VERSION = "0.5.0"
+end

data/lib/mps.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "logger"
+require "chronic"
+require "tty-editor"
+require "strscan"
+require_relative "mps/version"
+require_relative "mps/mps"
+
+ir "mps/constants"
+ir "mps/config"
+ir "mps/interpolators/interpolators"
+ir "mps/elements/elements"
+ir "mps/engines/engines"
+ir "mps/store"
+ir "cli/mps"
+module MPS
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/mps.gemspec

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "lib/mps/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mps"
+  spec.version       = MPS::VERSION
+  spec.authors       = ["mash-97"]
+  spec.email         = ["itzmashz@gmail.com"]
+
+  spec.summary       = "MPS (MonoPsyches)"
+  spec.description   = "Manage MonoPsyches."
+  spec.homepage      = "https://github.com/mash-97/mps"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_runtime_dependency "strscan", ">= 3.0"
+  spec.add_runtime_dependency "thor", "~> 1.3"
+  spec.add_runtime_dependency "tty-editor", "~> 0.7.0"
+  spec.add_runtime_dependency "chronic", "~> 0.10.2"
+  spec.add_runtime_dependency "cli-ui", "~> 2.2"
+
+  spec.add_development_dependency "rake", "~> 13.2"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "fakefs", "~> 2.5"
+  spec.add_development_dependency "tmpdir", ">= 0.1.3"
+  spec.add_development_dependency "yard", "~> 0.9.37"
+  spec.add_development_dependency "rack", "~> 3.1"
+  spec.add_development_dependency "webrick", "~> 1.8"
+  spec.add_development_dependency "rackup", "~> 2.1"
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end