yaml_exporter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 11669d9671c43a7dced493565d65af864c3e0b61ba583c40b678f547dc952796
+  data.tar.gz: 2f235b07235119bffc293e3030bbeaedfb8f4eca263ef921d0076a83bf658e0c
+SHA512:
+  metadata.gz: 29676b99c64faa28c7e70fddd67fb1376fe9d0ff1bf1657318197367021313164048eb8e75d8ff7e6cbb90b0eba48bbc71ee7aa3fe8ab32bc23e431adc6a8d0b
+  data.tar.gz: 618c63aa98999137b72d3dfc030cb9d861f29a60c333671d58fa21e71974ced9041dd10a6d2c49176669c627d9edca92a19965743945682225e807bffe8f41ef

data/.github/workflows/gem-push.yml

@@ -0,0 +1,36 @@
+name: Ruby Gem
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+    name: Build + Publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Ruby 3.3.x
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.3.4
+
+    - name: Publish to RubyGems
+      run: |
+        mkdir -p $HOME/.gem
+        touch $HOME/.gem/credentials
+        chmod 0600 $HOME/.gem/credentials
+        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        gem build *.gemspec
+        gem push *.gem
+      env:
+        GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}"

data/.gitignore

@@ -0,0 +1,56 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Anatoly Zelenin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# YamlExporter
+
+YamlExporter is a Ruby gem that provides YAML serialization and deserialization functionality for ActiveRecord models,
+with JSON schema generation for validation.
+
+## Features
+
+- Serialize ActiveRecord models to YAML
+- Deserialize YAML back to ActiveRecord models
+- Generate JSON schemas for model validation
+- Support for nested associations (has_many and has_one)
+- Automatic type inference based on database column types
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'yaml_exporter'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install yaml_exporter
+```
+
+## Usage
+
+### Setting up your model
+
+Include the `YamlExporter` module in your ActiveRecord model and define the YAML structure:
+
+```ruby
+
+class Quiz < ApplicationRecord
+  include YamlExporter
+
+  yaml_structure do
+    yaml_attribute :title, :quiz_type
+    yaml_has_many :questions do
+      yaml_attribute :text, :question_type, :feedback
+      yaml_has_many :answers do
+        yaml_attribute :text, :is_correct, :impact
+      end
+    end
+  end
+end
+```
+
+### Serializing to YAML
+
+To serialize a model instance to YAML:
+
+```ruby
+quiz = Quiz.find(1)
+yaml_string = quiz.yaml_export
+```
+
+### Deserializing from YAML
+
+To deserialize YAML back to a model instance:
+
+```ruby
+quiz = Quiz.new
+quiz.yaml_import(yaml_string)
+```
+
+### Generating JSON Schema
+
+To generate a JSON schema for validation:
+
+```ruby
+schema = Quiz.yaml_schema
+```
+
+## Configuration
+
+The YamlExporter automatically infers types based on the database column types. JSON and JSONB columns are treated as
+objects in the generated schema.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/itadventurer/yaml_exporter.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/yaml_exporter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'yaml_serializable/structure_builder'
+require_relative 'yaml_serializable/yaml_exporter'
+
+module YamlExporter
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def yaml_structure(&block)
+      class_attribute :yaml_structure_definition, instance_writer: false
+      self.yaml_structure_definition = YamlSerializable::StructureBuilder.new(&block).build
+      include InstanceMethods
+    end
+
+    def yaml_schema
+      YamlSerializable::YamlExporter.generate_schema(self, yaml_structure_definition)
+    end
+  end
+
+  module InstanceMethods
+    def yaml_export
+      YamlSerializable::YamlExporter.export(self, self.class.yaml_structure_definition)
+    end
+
+    def yaml_import(yaml_string)
+      YamlSerializable::YamlExporter.import(self, yaml_string, self.class.yaml_structure_definition)
+    end
+  end
+end

data/lib/yaml_serializable/structure_builder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module YamlSerializable
+  class StructureBuilder
+    def initialize(&block)
+      @structure = { attributes: [], associations: {} }
+      instance_eval(&block)
+    end
+
+    def yaml_attribute(*attrs)
+      @structure[:attributes].concat(attrs)
+    end
+
+    def yaml_has_one(name, &block)
+      @structure[:associations][name] = { type: :has_one, structure: self.class.new(&block).build }
+    end
+
+    def yaml_has_many(name, &block)
+      @structure[:associations][name] = { type: :has_many, structure: self.class.new(&block).build }
+    end
+
+    def yaml_condition(&block)
+      @structure[:condition] = block
+    end
+
+    def build
+      @structure
+    end
+  end
+end

data/lib/yaml_serializable/version.rb

@@ -0,0 +1,3 @@
+module YamlSerializable
+  VERSION = "0.1.0"
+end

data/lib/yaml_serializable/yaml_exporter.rb

@@ -0,0 +1,196 @@
+require 'yaml'
+require 'json-schema'
+
+module YamlSerializable
+  class YamlExporter
+    def self.export(object, structure)
+      new(object, structure).export
+    end
+
+    def self.import(object, yaml_string, structure)
+      new(object, structure).import(yaml_string)
+    end
+
+    def self.generate_schema(klass, structure)
+      new(klass.new, structure).generate_schema
+    end
+
+    def initialize(object, structure)
+      @object = object
+      @structure = structure
+    end
+
+    def export
+      yaml = YAML.dump(build_hash(@structure, @object))
+      validate(yaml)
+      yaml
+    end
+
+    def import(yaml_string)
+      data = YAML.safe_load(yaml_string)
+      validate(yaml_string)
+      update_object(data)
+      @object
+    end
+
+    def generate_schema
+      {
+        type: 'object',
+        properties: generate_properties(@structure, @object.class),
+        required: required_attributes(@structure, @object.class)
+      }
+    end
+
+    private
+
+    def build_hash(structure, object)
+      result = {}
+
+      structure[:attributes].each do |attr|
+        value = object.send(attr)
+        result[attr.to_s] = value unless value.nil?
+      end
+
+      structure[:associations].each do |name, config|
+        if config[:type] == :has_many
+          associated_objects = object.send(name).unscope(:order).order(:id)
+          if associated_objects.any?
+            result[name.to_s] = associated_objects.map { |item| build_hash(config[:structure], item) }
+          end
+        elsif config[:type] == :has_one
+          associated_object = object.send(name)
+          result[name.to_s] = build_hash(config[:structure], associated_object) if associated_object
+        end
+      end
+
+      result.compact
+    end
+
+    def validate(yaml)
+      schema = generate_schema
+      data = YAML.safe_load(yaml)
+      JSON::Validator.validate!(schema, data)
+    rescue JSON::Schema::ValidationError => e
+      raise "Invalid YAML structure: #{e.message}"
+    end
+
+    def update_object(data)
+      @object.transaction do
+        update_attributes(@object, data, @structure[:attributes])
+        @structure[:associations].each do |name, config|
+          if config[:type] == :has_many
+            update_collection(@object, data[name.to_s], name, config[:structure])
+          elsif config[:type] == :has_one && data[name.to_s]
+            update_nested(@object, data[name.to_s], name, config[:structure])
+          end
+        end
+        @object.save!
+      end
+    end
+
+    def update_attributes(object, data, attributes)
+      attributes.each do |attr|
+        if data.key?(attr.to_s)
+          object.send("#{attr}=", data[attr.to_s])
+        else
+          object.send("#{attr}=", nil)
+        end
+      end
+    end
+
+    def update_collection(parent, items_data, association_name, config)
+      existing_items = parent.send(association_name).unscope(:order).order(:id).to_a
+      new_items = []
+
+      items_data&.each_with_index do |item_data, index|
+        item = existing_items[index] || parent.send(association_name).build
+        update_attributes(item, item_data, config[:attributes])
+        config[:associations]&.each do |sub_name, sub_config|
+          if sub_config[:type] == :has_many
+            update_collection(item, item_data[sub_name.to_s], sub_name, sub_config[:structure])
+          elsif sub_config[:type] == :has_one && item_data[sub_name.to_s]
+            update_nested(item, item_data[sub_name.to_s], sub_name, sub_config[:structure])
+          end
+        end
+        new_items << item
+      end
+
+      # Entferne Items, die nicht mehr im YAML vorhanden sind
+      (existing_items - new_items).each(&:mark_for_destruction)
+
+      parent.send("#{association_name}=", new_items)
+    end
+
+    def update_nested(parent, nested_data, association_name, config)
+      nested_object = parent.send(association_name) || parent.send("build_#{association_name}")
+      update_attributes(nested_object, nested_data, config[:attributes])
+      config[:associations]&.each do |sub_name, sub_config|
+        if sub_config[:type] == :has_many
+          update_collection(nested_object, nested_data[sub_name.to_s], sub_name, sub_config[:structure])
+        elsif sub_config[:type] == :has_one && nested_data[sub_name.to_s]
+          update_nested(nested_object, nested_data[sub_name.to_s], sub_name, sub_config[:structure])
+        end
+      end
+    end
+
+    def generate_properties(structure, klass)
+      properties = {}
+
+      structure[:attributes].each do |attr|
+        column = klass.columns_hash[attr.to_s]
+        properties[attr.to_s] = { type: infer_type(column) }
+      end
+
+      structure[:associations].each do |name, config|
+        if config[:type] == :has_many
+          properties[name.to_s] = {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: generate_properties(config[:structure], association_class(klass, name)),
+              required: required_attributes(config[:structure], association_class(klass, name))
+            }
+          }
+        elsif config[:type] == :has_one
+          properties[name.to_s] = {
+            type: 'object',
+            properties: generate_properties(config[:structure], association_class(klass, name)),
+            required: required_attributes(config[:structure], association_class(klass, name))
+          }
+        end
+      end
+
+      properties
+    end
+
+    def infer_type(column)
+      case column.type
+      when :string, :text
+        'string'
+      when :integer, :bigint
+        'integer'
+      when :float, :decimal
+        'number'
+      when :boolean
+        'boolean'
+      when :date, :datetime, :time
+        'string'
+      when :json, :jsonb
+        'object'
+      else
+        'string'
+      end
+    end
+
+    def association_class(klass, association_name)
+      klass.reflect_on_association(association_name).klass
+    end
+
+    def required_attributes(structure, klass)
+      structure[:attributes].select do |attr|
+        column = klass.columns_hash[attr.to_s]
+        column && !column.null
+      end
+    end
+  end
+end

data/yaml_exporter.gemspec

@@ -0,0 +1,31 @@
+require_relative "lib/yaml_serializable/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = "yaml_exporter"
+  spec.version     = YamlSerializable::VERSION
+  spec.authors     = ["Anatoly Zelenin"]
+  spec.email       = ["anatoly@zelenin.de"]
+
+  spec.summary     = "YAML serialization for ActiveRecord models with JSON schema support"
+  spec.description = "A Ruby gem for YAML serialization and deserialization of ActiveRecord models with JSON schema generation."
+  spec.homepage    = "https://github.com/itadventurer/yaml_exporter"
+  spec.license     = "MIT"
+
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/itadventurer/yaml_exporter"
+  #spec.metadata["changelog_uri"] = "https://github.com/itadventurer/yaml_exporter/blob/master/CHANGELOG.md"
+
+  # 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.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 5.2"
+  spec.add_dependency "activesupport", ">= 5.2"
+
+  spec.add_development_dependency "rake", "~> 13.0"
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: yaml_exporter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Anatoly Zelenin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A Ruby gem for YAML serialization and deserialization of ActiveRecord
+  models with JSON schema generation.
+email:
+- anatoly@zelenin.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/gem-push.yml"
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- lib/yaml_exporter.rb
+- lib/yaml_serializable/structure_builder.rb
+- lib/yaml_serializable/version.rb
+- lib/yaml_serializable/yaml_exporter.rb
+- yaml_exporter.gemspec
+homepage: https://github.com/itadventurer/yaml_exporter
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/itadventurer/yaml_exporter
+  source_code_uri: https://github.com/itadventurer/yaml_exporter
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key: 
+specification_version: 4
+summary: YAML serialization for ActiveRecord models with JSON schema support
+test_files: []