leafy-ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0cf163d4cd002f7035394d9997d425b7f0834fc2cc91a42a516f3de9de5c6bfe
+  data.tar.gz: 234f95015a72ad3aacf0db48bfe6c4bc5f7c48db0f1e474c6a88516b9e0a3911
+SHA512:
+  metadata.gz: c4c5342b0a90c406bd6cb4e04969f3e9ec59cb10e03d91e2ea1f91d2db8f6cc125809ee23bade0b098480db82a22cba079d344ff4a599b9db9085cd0ee55b8a4
+  data.tar.gz: 8d6cb3f31e9bab0543e51a3b5344ef6ddd26c1052ad07254b6ef89365fd5ab9a55d92de8472688034da3a51191601ac0924eda53b9bdca497d9890c1e48b482d

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea/*
+/coverage/*
+.rbenv-gemsets
+Gemfile.lock
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,38 @@
+sudo: false
+
+language: ruby
+
+rvm:
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - ruby-head
+  - jruby-9.2.0.0
+  - jruby-head
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+
+before_install: gem install bundler
+
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+
+script: bundle exec rspec
+
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT
+
+cache: bundler
+
+env:
+  global:
+    CC_TEST_REPORTER_ID=5c94ea74238649cee4b51abbe647de62a3d63971eaeca9aa58c82b62d9a0e6a8
+    COVERAGE=1
+
+

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in leafy.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Evgeny
+
+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,177 @@
+# Leafy [![Build Status](https://travis-ci.org/estepnv/leafy.svg?branch=master)](https://travis-ci.org/estepnv/leafy) [![Maintainability](https://api.codeclimate.com/v1/badges/5108d8a1ac5e2915f30f/maintainability)](https://codeclimate.com/github/estepnv/leafy/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/5108d8a1ac5e2915f30f/test_coverage)](https://codeclimate.com/github/estepnv/leafy/test_coverage)
+
+A toolkit for dynamic custom attributes for Ruby applications.
+
+* Simple modular design - load only things you need
+* Stored as JSON with your models - allows you to avoid expensive JOIN queries (supports postgresql json/jsonb data types)
+* Type inference - Infers type from custom field data
+* Add your own custom field types
+
+Supported data types:
+- `string` - strings
+- `integer` - integer numbers
+- `double` - floating point numbers
+- `datetime` - `Time` instances
+- `date` - `Date` instances
+- `bool` - `TrueClass` and `FalseClass` instances
+
+## Quick start
+
+Add Leafy to Gemfile
+
+```ruby
+gem 'leafy-ruby'
+```
+
+**Plain Ruby app**
+
+Include "Plain old ruby object" mixin into your class definition to start using leafy
+
+```ruby
+class SchemaHost < ActiveRecord::Base
+  include Leafy::Mixin::Schema[:poro]
+  
+  attr_accessor :leafy_data
+end
+
+class FieldsHost < ActiveRecord::Base
+  include Leafy::Mixin::Fields[:poro]
+  
+  attr_accessor :leafy_data
+  attr_accessor :leafy_fields
+end
+```
+
+Schema mixin introduces next methods:
+
+- `#leafy_fields (Schema)` returns Schema instance allowing you to iterate through custom attribute definitions.
+- `#leafy_fields=` schema setter method
+- `#leafy_fields_attributes=` nested attributes setter method  
+
+Fields mixin:
+
+- `#leafy_values (Hash)` returns a hash representation of your fields data
+- `#leafy_values=` allows you to assign custom attributes data
+- `#leafy_fields_values (Leafy::FieldValueCollection)`  returns a collection of `Field::Value` instances which provide more control over values data
+
+**Please note**:
+Leafy is stateless and changing Schema instance won't reflect on your active record model instance.
+For changes to take place you have to explicitly assign schema or attributes data to the model. 
+
+
+
+```ruby
+host = SchemaHost.new
+host.leafy_fields_attributes = [
+  { name: "Field 1", type: :integer, id: "id_1", metadata: { default: 1, placeholder: "enter an integer", required: true } },
+  { name: "Field 2", type: :string, id: "id_2", metadata: { default: "", placeholder: "enter value" } },
+  { name: "Field 3", type: :datetime, id: "id_3", metadata: { order: 10000 } }
+]
+
+# or build schema yourself
+
+field_1 = Leafy::Field.new(name: "Field 1", type: :integer, id: "id_1", default: 1, placeholder: "enter an integer", required: true)
+field_2 = Leafy::Field.new(name: "Field 2", type: :string, id: "id_2", default: "", placeholder: "enter value")
+field_3 = Leafy::Field.new(name: "Field 3", type: :datetime, id: "id_3", order: 10000)
+
+schema = Leafy::Schema.new
+schema << field_1
+schema << field_2
+schema << field_3
+
+host.leafy_fields = schema
+
+# after that reference schema for fields target instance
+
+target = FieldsHost.new
+target.leafy_fields = host.leafy_fields
+target.leafy_values
+
+# => { "id_1" => nil, "id_2" => nil, "id_3" => nil }
+
+target.leafy_values = { "id_1": 123, "id_2": "test", "id_3": Time.new(2018,10,10, 10,10,10, "+03:00"), "junk": "some junk data" }
+target.leafy_values
+
+# => { "id_1": 123, "id_2": "test", "id_3": Time.new(2018,10,10, 10,10,10, "+03:00") }
+```
+
+**ActiveRecord**
+
+Add migration
+```ruby
+add_column :schema_hosts, :leafy_data, :text, null: false, default: "{}"
+add_column :fields_hosts, :leafy_data, :text, null: false, default: "{}"
+# for postgresql
+# add_column :leafy_data, :jsonb, null: false, default: {} 
+```
+
+Update your models
+
+```ruby
+class SchemaHost < ActiveRecord::Base
+  include Leafy::Mixin::Schema[:active_record]
+end
+
+class FieldsHost < ActiveRecord::Base
+  include Leafy::Mixin::Fields[:active_record]
+  
+  belongs_to :schema_host, required: true
+  delegate :leafy_fields, to: :schema_host 
+end
+```
+
+```ruby
+host = SchemaHost.create(
+  leafy_fields_attributes: [
+    { name: "Field 1", type: :integer, id: "id_1", metadata: { default: 1, placeholder: "enter an integer", required: true } },
+    { name: "Field 2", type: :string, id: "id_2", metadata: { default: "", placeholder: "enter value" } },
+    { name: "Field 3", type: :datetime, id: "id_3", metadata: { order: 10000 } }
+  ]
+)
+
+target = FieldsHost.create(schema_host: host)
+target.leafy_values
+
+# => { "id_1" => nil, "id_2" => nil, "id_3" => nil }
+
+target.leafy_values = { "id_1": 123, "id_2": "test", "id_3": Time.new(2018,10,10, 10,10,10, "+03:00"), "junk": "some junk data" }
+target.save!
+target.reload
+
+target.leafy_values
+
+# => { "id_1": 123, "id_2": "test", "id_3": Time.new(2018,10,10, 10,10,10, "+03:00") }
+```
+
+## Adding your own types
+
+Leafy allows adding your own data types
+To allow leafy process your own data type you need to describe how to store it. For that purpose leafy utilizes converter classes associated for each type.
+
+Converter instance has to implement `#dump` and `#load` methods
+
+```ruby
+class MyComplexTypeConverter
+  def self.load(json_string)
+    #  parsing logic
+    return MyComplexType.new(parsed_data)
+  end 
+  
+  def self.dump(my_complex_type_instance)
+    # serializing logic
+    return json
+  end
+end
+
+Leafy.register_converter(:complex_type, MyComplexTypeConverter)
+```
+
+ 
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/estepnv/leafy.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "leafy"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/leafy.gemspec

@@ -0,0 +1,46 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "leafy/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "leafy-ruby"
+  spec.version       = Leafy.version
+  spec.authors       = ["Evgeny Stepanov"]
+  spec.email         = ["estepnv@icloud.com"]
+
+  spec.summary       = %q{Toolkit for custom attributes in Ruby apps}
+  spec.description   = <<-DESC
+  Leafy is toolkit that allows you to integrate dynamic custom attributes functionality into your ruby application.
+
+  It provides high level API you can use for any suitable use-case.
+  It ships with several basic data types and allows you to add your own data type converters.
+  DESC
+
+  spec.homepage      = "https://gibhub.com/estepnv/leafy"
+  spec.license       = "MIT"
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov"
+
+  if RUBY_VERSION >= "2.2.2"
+    spec.add_development_dependency "activerecord", "~> 5.0"
+  else
+    spec.add_development_dependency "activerecord", "~> 4.2"
+  end
+
+  if RUBY_ENGINE == "jruby"
+    spec.add_development_dependency "activerecord-jdbcsqlite3-adapter", "51"
+  else
+    spec.add_development_dependency "sqlite3"
+  end
+end

data/lib/leafy/converter/bool_converter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leafy
+  module Converter
+    class BoolConverter
+      def dump(value)
+        target = value
+        target = load(target) unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+        target ? "1" : "0"
+      end
+
+      def load(value)
+        return if value.nil?
+
+        target = value.respond_to?(:downcase) ? (value.downcase rescue nil) : value
+        return true if ["1", "true", "t", 1, "yes", "y", true].include?(target)
+        return false if ["0", "false", "f", 0, "no", "n", false].include?(target)
+
+        raise(ArgumentError, "can't parse value to bool: #{value}")
+      end
+    end
+  end
+end

data/lib/leafy/converter/date_converter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Leafy
+  module Converter
+    class DateConverter
+
+      def dump(value)
+        return if value.nil?
+
+        target = value.dup
+        target = load(target) if target.is_a?(String)
+        target = target.dup.to_date if target.is_a?(Time)
+
+        unless target.is_a?(Date)
+          raise(ArgumentError, "is not a Date object")
+        end
+
+        target.iso8601
+      end
+
+      def load(value)
+        return if value.nil?
+        return value if value.is_a?(Date)
+        Date.parse(value)
+      end
+
+    end
+  end
+end

data/lib/leafy/converter/datetime_converter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Leafy
+  module Converter
+    class DatetimeConverter
+
+      def dump(value)
+        return if value.nil?
+
+        target = value.dup
+        target = load(target) if target.is_a?(String)
+
+        raise(ArgumentError, "is not a Time object") unless target.is_a?(Time)
+
+        target.utc.iso8601
+      end
+
+      def load(value)
+        return if value.nil?
+        return value if value.is_a?(Time)
+        Time.parse(value).utc
+      end
+
+    end
+  end
+end

data/lib/leafy/converter/double_converter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Leafy
+  module Converter
+    class DoubleConverter
+      def dump(value)
+        return if value.nil?
+        value.to_s
+      end
+
+      def load(value)
+        return if value.nil?
+        value.to_f
+      end
+    end
+  end
+end

data/lib/leafy/converter/dummy_converter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Leafy
+  module Converter
+    class DummyConverter
+      def dump(value)
+        value
+      end
+
+      def load(value)
+        value
+      end
+    end
+  end
+end

data/lib/leafy/converter/integer_converter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Leafy
+  module Converter
+    class IntegerConverter
+      def dump(value)
+        value.nil? ? nil : value.to_s
+      end
+
+      def load(value)
+        value.nil? ? nil : value.to_i
+      end
+    end
+  end
+end

data/lib/leafy/converter/string_converter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Leafy
+  module Converter
+    class StringConverter
+      def dump(value)
+        value
+      end
+
+      def load(value)
+        value
+      end
+    end
+  end
+end

data/lib/leafy/field.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'securerandom'
+
+module Leafy
+  class Field
+    attr_accessor :id, :name, :type, :metadata
+
+    def initialize(attributes = {})
+      raise ArgumentError, "attributes is not a Hash" unless attributes.is_a?(Hash)
+      attributes = Leafy::Utils.symbolize_keys(attributes)
+
+      self.name = attributes[:name]
+      self.type = attributes[:type]
+      self.id = attributes.fetch(:id) { [name.downcase.strip.tr(" ", "-"), SecureRandom.uuid].join("-") }
+      self.metadata = attributes.fetch(:metadata, {})
+    end
+
+    def serializable_hash
+      {
+        name: name,
+        type: type,
+        id: id,
+        metadata: metadata
+      }
+    end
+  end
+end

data/lib/leafy/field_value.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Leafy
+  class FieldValue
+    attr_accessor :id, :name, :type, :raw, :converter
+
+    def initialize(attributes)
+      attributes = attributes.dup.to_a.map { |pair| [pair[0].to_sym, pair[1]]}.to_h
+
+      self.id = attributes.fetch(:id)
+      self.name = attributes.fetch(:name)
+      self.type = attributes.fetch(:type)
+      self.converter = attributes.fetch(:converter) { Leafy.converters.fetch(type.to_sym) { raise(RuntimeError, "unregistered converter #{type}") } }
+      self.raw = attributes.fetch(:raw)
+    end
+
+    def value
+      converter.load(raw)
+    end
+
+    def value=(val)
+      self.raw = converter.dump(converter.load(val))
+    end
+  end
+end

data/lib/leafy/field_value_collection.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Leafy
+  class FieldValueCollection
+    include ::Enumerable
+
+    def each
+      if block_given?
+        @leafy_field_values.each { |i| yield i }
+      else
+        @leafy_field_values.each
+      end
+    end
+
+    def [](index)
+      to_a[index]
+    end
+
+    def size
+      count
+    end
+
+    def initialize(leafy_fields, values = {})
+      @leafy_fields = leafy_fields
+      @leafy_field_values = leafy_fields.map do |custom_field|
+        Leafy::FieldValue.new(
+          id: custom_field.id,
+          name: custom_field.name,
+          raw: values[custom_field.id],
+          type: custom_field.type
+        )
+      end
+    end
+
+    def values
+      inject({}) do |acc, field_value|
+        acc[field_value.id] = field_value.value
+        acc
+      end
+    end
+
+    def values=(attributes = {})
+      attributes = attributes.dup.to_a.map { |pair| [pair[0].to_s, pair[1]]}.to_h
+
+      @leafy_field_values.each do |field_value|
+        field_value.value = attributes[field_value.id]
+      end
+    end
+
+    def self.dump(field_values_collection)
+      JSON.dump(field_values_collection.map { |field_value| [field_value.id, field_value.raw] }.to_h)
+    end
+
+    def self.load(leafy_fields, data)
+      Leafy::FieldValueCollection.new(leafy_fields, JSON.load(data))
+    end
+
+  end
+end

data/lib/leafy/mixin/active_record/fields.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module Leafy
+  module Mixin
+    module ActiveRecord
+
+      module Fields
+        module ClassMethods
+        end
+
+        module InstanceMethods
+
+          def leafy_fields
+            raise(RuntimeError, "Leafy: leafy_fields method is not defined")
+          end
+
+          def leafy_values
+            leafy_field_values.values
+          end
+
+          def leafy_values=(attributes = {})
+            field_value_list = leafy_field_values
+            field_value_list.values = attributes
+
+            self.leafy_data = ::Leafy::FieldValueCollection.dump(field_value_list)
+          end
+
+          def leafy_field_values
+            ::Leafy::FieldValueCollection.load(leafy_fields, leafy_data || "{}")
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/leafy/mixin/active_record/schema.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module Leafy
+  module Mixin
+    module ActiveRecord
+
+      module Schema
+        module InstanceMethods
+          def leafy_fields
+            data = _leafy_data
+
+            activerecord_json_column? ?
+              ::Leafy::Schema.new(data) :
+              ::Leafy::Schema.load(data.nil? ? "[]" : data)
+          end
+
+          def leafy_fields=(leafy_schema)
+            self._leafy_data = activerecord_json_column? ?
+                                 leafy_schema.serializable_hash :
+                                 ::Leafy::Schema.dump(leafy_schema)
+          end
+
+          def leafy_fields_attributes=(attributes_list)
+            self.leafy_fields = ::Leafy::Schema.new(attributes_list)
+          end
+
+        end
+
+        module ClassMethods
+        end
+      end
+
+    end
+  end
+end

data/lib/leafy/mixin/active_record/shared.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module Leafy
+  module Mixin
+    module ActiveRecord
+      module Shared
+
+        module InstanceMethods
+          private
+
+          def activerecord_json_column?
+            return false unless self.is_a?(::ActiveRecord::Base)
+            return false unless column = self.class.columns_hash[self.class.leafy_data_attribute.to_s]
+
+            [:json, :jsonb].include?(column.type)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/leafy/mixin/data_accessor.rb

@@ -0,0 +1,41 @@
+module Leafy
+  module Mixin
+    module DataAccessor
+
+      module ClassMethods
+        def leafy_data_attribute=(value)
+          @leafy_data_attribute = value
+        end
+
+        def leafy_data_attribute
+          @leafy_data_attribute ||= :leafy_data
+        end
+
+        def leafy_data_getter; leafy_data_attribute; end
+
+        def leafy_data_setter; "#{leafy_data_attribute}="; end
+      end
+
+      module InstanceMethods
+        private
+
+        def _leafy_data=(value)
+          unless respond_to?(self.class.leafy_data_setter)
+            raise(RuntimeError, "must respond to ##{self.class.leafy_data_setter}") unless respond_to?(:leafy_data=)
+          end
+
+          public_send(self.class.leafy_data_setter, value)
+        end
+
+        def _leafy_data
+          unless respond_to?(self.class.leafy_data_getter)
+            raise(RuntimeError, "must respond to ##{self.class.leafy_data_getter}")
+          end
+
+          public_send(self.class.leafy_data_getter)
+        end
+      end
+
+    end
+  end
+end

data/lib/leafy/mixin/fields.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "./data_accessor"
+
+module Leafy
+  module Mixin
+    module Fields
+
+      def self.[](orm = :poro)
+        Module.new do
+          @orm = orm
+
+          def self.included(base)
+
+            base.extend DataAccessor::ClassMethods
+            base.include DataAccessor::InstanceMethods
+
+            case @orm
+
+            when :poro
+
+              require_relative "./poro/fields"
+
+              base.extend Poro::Fields::ClassMethods
+              base.include Poro::Fields::InstanceMethods
+
+            when :active_record
+
+              require_relative "./active_record/shared"
+              require_relative "./active_record/fields"
+
+              base.extend ActiveRecord::Fields::ClassMethods
+              base.include ActiveRecord::Shared::InstanceMethods
+              base.include ActiveRecord::Fields::InstanceMethods
+
+            else
+
+              raise(RuntimeError, "Leafy: unsupported schema storage: #{orm}")
+
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/leafy/mixin/poro/fields.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Leafy
+  module Mixin
+    module Poro
+
+      module Fields
+        module ClassMethods
+        end
+
+        module InstanceMethods
+
+          def leafy_fields
+            raise(RuntimeError, "Leafy: leafy_fields method is not defined")
+          end
+
+          def leafy_values
+            leafy_field_values.values
+          end
+
+          def leafy_values=(attributes = {})
+            field_value_list = leafy_field_values
+            field_value_list.values = attributes
+
+            self._leafy_data = ::Leafy::FieldValueCollection.dump(field_value_list)
+          end
+
+          def leafy_field_values
+            ::Leafy::FieldValueCollection.load(leafy_fields, _leafy_data || "{}")
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/leafy/mixin/poro/schema.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Leafy
+  module Mixin
+    module Poro
+
+      module Schema
+
+        module InstanceMethods
+          def leafy_fields
+            data = _leafy_data
+            Leafy::Schema.load(data.nil? ? "[]" : data)
+          end
+
+          def leafy_fields=(leafy_schema)
+            self._leafy_data = ::Leafy::Schema.dump(leafy_schema)
+          end
+
+          def leafy_fields_attributes=(attributes_list)
+            self.leafy_fields = ::Leafy::Schema.new(attributes_list)
+          end
+        end
+
+        module ClassMethods
+        end
+
+      end
+
+    end
+  end
+end

data/lib/leafy/mixin/schema.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "./data_accessor"
+
+module Leafy
+  module Mixin
+    module Schema
+
+      def self.[](orm)
+        Module.new do
+          @orm = orm
+
+          def self.included(base)
+
+            base.extend DataAccessor::ClassMethods
+            base.include DataAccessor::InstanceMethods
+
+            case @orm
+            when :poro
+
+              require_relative "./poro/schema"
+
+              base.extend Poro::Schema::ClassMethods
+              base.include Poro::Schema::InstanceMethods
+
+            when :active_record
+
+              require_relative "./active_record/shared"
+              require_relative "./active_record/schema"
+
+              base.extend ActiveRecord::Schema::ClassMethods
+              base.include ActiveRecord::Shared::InstanceMethods
+              base.include ActiveRecord::Schema::InstanceMethods
+
+            else
+
+              raise(RuntimeError, "Leafy: unsupported schema storage: #{orm}")
+
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/leafy/schema.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require "json"
+
+module Leafy
+  class Schema
+    include ::Enumerable
+
+    def each
+      if block_given?
+        @fields.each { |i| yield i }
+      else
+        @fields.each
+      end
+    end
+
+    def initialize(fields = [])
+      @fields = fields.map { |field| Leafy::Field.new(field) }
+    end
+
+    def ids
+      @fields.map(&:id)
+    end
+
+    def [](identifier)
+      @fields.find { |f| f.id == identifier }
+    end
+
+    def push(field)
+      raise(ArgumentError, "is not a field") unless field.is_a?(Leafy::Field)
+      @fields << field
+    end
+
+    def serializable_hash
+      @fields.map(&:serializable_hash)
+    end
+
+    def self.dump(schema)
+      JSON.dump(schema.serializable_hash)
+    end
+
+    def self.load(data)
+      Schema.new(JSON.parse(data))
+    end
+
+    alias :<< :push
+  end
+end

data/lib/leafy/utils.rb

@@ -0,0 +1,17 @@
+module Leafy
+  module Utils
+    def self.symbolize_keys(hash)
+      hash.dup.to_a.map do |pair|
+        key, value = pair
+        [key.to_sym, value.is_a?(Hash) ? Leafy::Utils.symbolize_keys(value) : value]
+      end.to_h
+    end
+
+    def self.stringify_keys(hash)
+      hash.dup.to_a.map do |pair|
+        key, value = pair
+        [key.to_s, value.is_a?(Hash) ? Leafy::Utils.stringify_keys(value) : value]
+      end.to_h
+    end
+  end
+end

data/lib/leafy/version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Leafy
+  def self.version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/leafy.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "leafy/version"
+require "leafy/utils"
+require "leafy/field"
+require "leafy/schema"
+require "leafy/field_value"
+require "leafy/field_value_collection"
+Dir[File.expand_path("../leafy/converter/**/*.rb", __FILE__)].each { |f| require f }
+require "leafy/mixin/schema"
+require "leafy/mixin/fields"
+
+
+# module definition
+module Leafy
+  def self.register_converter(name, converter)
+    raise(ArgumentError, "converter is not provided") if converter.nil?
+
+    if !converter.respond_to?(:load) || !converter.respond_to?(:dump)
+      raise(ArgumentError, "converter must respond to #dump and #load")
+    end
+
+    converters[name] = converter
+  end
+
+  def self.converters
+    @converters ||= {}
+  end
+end
+
+Leafy.register_converter(:dummy, Leafy::Converter::DummyConverter.new)
+Leafy.register_converter(:string, Leafy::Converter::StringConverter.new)
+Leafy.register_converter(:integer, Leafy::Converter::IntegerConverter.new)
+Leafy.register_converter(:double, Leafy::Converter::DoubleConverter.new)
+Leafy.register_converter(:datetime, Leafy::Converter::DatetimeConverter.new)
+Leafy.register_converter(:bool, Leafy::Converter::BoolConverter.new)
+Leafy.register_converter(:date, Leafy::Converter::DateConverter.new)

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: leafy-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Evgeny Stepanov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+    Leafy is toolkit that allows you to integrate dynamic custom attributes functionality into your ruby application.
+
+    It provides high level API you can use for any suitable use-case.
+    It ships with several basic data types and allows you to add your own data type converters.
+email:
+- estepnv@icloud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- leafy.gemspec
+- lib/leafy.rb
+- lib/leafy/converter/bool_converter.rb
+- lib/leafy/converter/date_converter.rb
+- lib/leafy/converter/datetime_converter.rb
+- lib/leafy/converter/double_converter.rb
+- lib/leafy/converter/dummy_converter.rb
+- lib/leafy/converter/integer_converter.rb
+- lib/leafy/converter/string_converter.rb
+- lib/leafy/field.rb
+- lib/leafy/field_value.rb
+- lib/leafy/field_value_collection.rb
+- lib/leafy/mixin/active_record/fields.rb
+- lib/leafy/mixin/active_record/schema.rb
+- lib/leafy/mixin/active_record/shared.rb
+- lib/leafy/mixin/data_accessor.rb
+- lib/leafy/mixin/fields.rb
+- lib/leafy/mixin/poro/fields.rb
+- lib/leafy/mixin/poro/schema.rb
+- lib/leafy/mixin/schema.rb
+- lib/leafy/schema.rb
+- lib/leafy/utils.rb
+- lib/leafy/version.rb
+homepage: https://gibhub.com/estepnv/leafy
+licenses:
+- MIT
+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.7.7
+signing_key: 
+specification_version: 4
+summary: Toolkit for custom attributes in Ruby apps
+test_files: []