mechanomeld 0.1.0

data/ext/mechanomeld/src/write.rs

@@ -0,0 +1,142 @@
+//! Converting Ruby values into automerge operations.
+
+use automerge::{transaction::Transactable, AutoCommit, ObjId, ObjType, Prop, ScalarValue};
+use magnus::{
+    prelude::*,
+    r_hash::ForEach,
+    value::{Qfalse, Qtrue},
+    Error, Float, Integer, RArray, RHash, RObject, RString, Ruby, TryConvert, Value,
+};
+
+use crate::classes::{BYTES, COUNTER, TEXT, TIMESTAMP, UINT};
+use crate::errors::{arg_error, automerge_error, type_error};
+use crate::path;
+
+/// Where a value goes: over an existing prop, or inserted into a list.
+pub enum Slot {
+    Put(Prop),
+    Insert(usize),
+}
+
+enum Written {
+    Scalar(ScalarValue),
+    Map(RHash),
+    List(RArray),
+    Text(String),
+}
+
+pub fn write(
+    ruby: &Ruby,
+    doc: &mut AutoCommit,
+    obj: &ObjId,
+    slot: Slot,
+    value: Value,
+) -> Result<(), Error> {
+    match classify(ruby, value)? {
+        Written::Scalar(scalar) => match slot {
+            Slot::Put(prop) => doc.put(obj, prop, scalar),
+            Slot::Insert(index) => doc.insert(obj, index, scalar),
+        }
+        .map_err(|e| automerge_error(ruby, e)),
+        Written::Map(hash) => {
+            let child = create(ruby, doc, obj, slot, ObjType::Map)?;
+            hash.foreach(|key: Value, item: Value| {
+                let key = path::key(ruby, key)?;
+                write(ruby, doc, &child, Slot::Put(Prop::Map(key)), item)?;
+                Ok(ForEach::Continue)
+            })
+        }
+        Written::List(array) => {
+            let child = create(ruby, doc, obj, slot, ObjType::List)?;
+            for index in 0..array.len() {
+                let item = array.entry::<Value>(index as isize)?;
+                write(ruby, doc, &child, Slot::Insert(index), item)?;
+            }
+            Ok(())
+        }
+        Written::Text(text) => {
+            let child = create(ruby, doc, obj, slot, ObjType::Text)?;
+            doc.splice_text(&child, 0, 0, &text)
+                .map_err(|e| automerge_error(ruby, e))
+        }
+    }
+}
+
+fn create(
+    ruby: &Ruby,
+    doc: &mut AutoCommit,
+    obj: &ObjId,
+    slot: Slot,
+    obj_type: ObjType,
+) -> Result<ObjId, Error> {
+    match slot {
+        Slot::Put(prop) => doc.put_object(obj, prop, obj_type),
+        Slot::Insert(index) => doc.insert_object(obj, index, obj_type),
+    }
+    .map_err(|e| automerge_error(ruby, e))
+}
+
+fn classify(ruby: &Ruby, value: Value) -> Result<Written, Error> {
+    if value.is_nil() {
+        return Ok(Written::Scalar(ScalarValue::Null));
+    }
+    if Qtrue::from_value(value).is_some() {
+        return Ok(Written::Scalar(ScalarValue::Boolean(true)));
+    }
+    if Qfalse::from_value(value).is_some() {
+        return Ok(Written::Scalar(ScalarValue::Boolean(false)));
+    }
+    if let Some(integer) = Integer::from_value(value) {
+        return Ok(Written::Scalar(ScalarValue::Int(integer.to_i64()?)));
+    }
+    if let Some(float) = Float::from_value(value) {
+        return Ok(Written::Scalar(ScalarValue::F64(float.to_f64())));
+    }
+    if let Some(string) = RString::from_value(value) {
+        return Ok(Written::Scalar(ScalarValue::Str(
+            utf8(ruby, string)?.into(),
+        )));
+    }
+    if let Some(hash) = RHash::from_value(value) {
+        return Ok(Written::Map(hash));
+    }
+    if let Some(array) = RArray::from_value(value) {
+        return Ok(Written::List(array));
+    }
+    if value.is_kind_of(ruby.get_inner(&TEXT)) {
+        return Ok(Written::Text(utf8(ruby, wrapped(value)?)?));
+    }
+    if value.is_kind_of(ruby.get_inner(&COUNTER)) {
+        let count = wrapped::<Integer>(value)?.to_i64()?;
+        return Ok(Written::Scalar(ScalarValue::counter(count)));
+    }
+    if value.is_kind_of(ruby.get_inner(&TIMESTAMP)) {
+        let millis = wrapped::<Integer>(value)?.to_i64()?;
+        return Ok(Written::Scalar(ScalarValue::Timestamp(millis)));
+    }
+    if value.is_kind_of(ruby.get_inner(&UINT)) {
+        let uint = wrapped::<Integer>(value)?.to_u64()?;
+        return Ok(Written::Scalar(ScalarValue::Uint(uint)));
+    }
+    if value.is_kind_of(ruby.get_inner(&BYTES)) {
+        let bytes = unsafe { wrapped::<RString>(value)?.as_slice() }.to_vec();
+        return Ok(Written::Scalar(ScalarValue::Bytes(bytes)));
+    }
+    Err(type_error(
+        ruby,
+        format!(
+            "unsupported Automerge value type: {}",
+            path::class_name(value)
+        ),
+    ))
+}
+
+/// The `@value` of a scalar wrapper, read without calling Ruby methods.
+fn wrapped<T: TryConvert>(value: Value) -> Result<T, Error> {
+    RObject::try_convert(value)?.ivar_get("@value")
+}
+
+fn utf8(ruby: &Ruby, string: RString) -> Result<String, Error> {
+    let bytes = unsafe { string.as_slice() }.to_vec();
+    String::from_utf8(bytes).map_err(|_| arg_error(ruby, "string is not valid UTF-8"))
+}

data/lib/mechanomeld/document.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Mechanomeld
+  # Native methods (new, load, get, keys, length, put, delete, commit, rollback, save)
+  # are defined in ext/mechanomeld/src/document.rs.
+  class Document
+    def self.from(hash, actor_id: nil)
+      raise ArgumentError, "Automerge document root must be a Hash" unless hash.is_a?(Hash)
+
+      doc = new(actor_id: actor_id)
+      hash.each { |key, value| doc.put([key], value) }
+      doc.commit
+      doc
+    end
+
+    def [](path)
+      get(path)
+    end
+
+    def []=(path, value)
+      put(path, value)
+    end
+
+    def to_h
+      get([])
+    end
+    alias_method :to_hash, :to_h
+
+    def change(message: nil, timestamp: nil)
+      yield self
+      commit(message: message, timestamp: timestamp)
+      self
+    rescue Exception
+      rollback
+      raise
+    end
+  end
+end

data/lib/mechanomeld/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Mechanomeld
+  class Error < StandardError; end
+end

data/lib/mechanomeld/scalars.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Mechanomeld
+  # A typed Automerge value that has no natural Ruby equivalent.
+  class Scalar
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def ==(other)
+      other.class == self.class && other.value == value
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [self.class, value].hash
+    end
+
+    def inspect
+      "#<#{self.class.name} #{value.inspect}>"
+    end
+  end
+
+  class Counter < Scalar; end
+
+  # Milliseconds since the Unix epoch.
+  class Timestamp < Scalar; end
+
+  class Uint < Scalar; end
+
+  class Bytes < Scalar
+    def initialize(value)
+      super(String(value).b)
+    end
+  end
+
+  # A collaborative text object, as opposed to a plain String value.
+  class Text < Scalar
+    def initialize(value = "")
+      super(String(value))
+    end
+
+    def to_s
+      value
+    end
+  end
+end

data/lib/mechanomeld/version.rb

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

data/lib/mechanomeld.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "mechanomeld/version"
+require_relative "mechanomeld/error"
+require_relative "mechanomeld/scalars"
+
+# Precompiled gems ship one binary per Ruby minor version; source builds put it in lib/mechanomeld.
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require_relative "mechanomeld/#{Regexp.last_match(1)}/mechanomeld"
+rescue LoadError
+  require_relative "mechanomeld/mechanomeld"
+end
+
+require_relative "mechanomeld/document"

data/sig/mechanomeld.rbs

@@ -0,0 +1,4 @@
+module Mechanomeld
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: mechanomeld
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jim Gay
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+description: A native extension wrapping the Rust automerge crate so Ruby can load,
+  read, create, and save Automerge documents shared with JavaScript.
+email:
+- jim@saturnflyer.com
+executables: []
+extensions:
+- ext/mechanomeld/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Cargo.lock
+- Cargo.toml
+- README.md
+- Rakefile
+- checksums/mechanomeld-0.1.0.gem.sha512
+- ext/mechanomeld/Cargo.toml
+- ext/mechanomeld/extconf.rb
+- ext/mechanomeld/src/classes.rs
+- ext/mechanomeld/src/document.rs
+- ext/mechanomeld/src/errors.rs
+- ext/mechanomeld/src/lib.rs
+- ext/mechanomeld/src/path.rs
+- ext/mechanomeld/src/read.rs
+- ext/mechanomeld/src/write.rs
+- lib/mechanomeld.rb
+- lib/mechanomeld/document.rb
+- lib/mechanomeld/error.rb
+- lib/mechanomeld/scalars.rb
+- lib/mechanomeld/version.rb
+- sig/mechanomeld.rbs
+homepage: https://github.com/SOFware/mechanomeld
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/SOFware/mechanomeld
+  source_code_uri: https://github.com/SOFware/mechanomeld
+  changelog_uri: https://github.com/SOFware/mechanomeld/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Read and write Automerge documents from Ruby
+test_files: []