activeentity 0.0.1.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2e112f03678388841535d5384522961d51cc1d329ca4d1a89fdf7ce2ac7f60de
+  data.tar.gz: 4b28acea8267bdffe02ff95a4d17522e69bd81475301e7a4f721f9097ab79fb7
+SHA512:
+  metadata.gz: b0c1ba8f2a0b214a556442a32f01777622a556e3e3e07884c5e8cf7ddef8d1bf60daab6807942f04e62c936c19a271ce9db79bc91437f55b94f608992647923b
+  data.tar.gz: 9066e333b4dc888dd705726a44ce644438f9619ea0631507716c7a1e3553a32d99cc0deb44f8ea3ee716412cbb48688f69150aeeddc46327e57c9c9c8e1d7cbb

data/MIT-LICENSE

@@ -0,0 +1,42 @@
+Copyright (c) 2019 jasl
+
+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.
+
+
+Copyright (c) 2005-2019 David Heinemeier Hansson
+
+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,145 @@
+Active Entity
+====
+
+Active Entity is a Rails virtual model solution based on ActiveModel and it's design for Rails 6+.
+
+Active Entity is forked from Active Record by removing all database relates codes, so it nearly no need to learn how to use.
+
+## About Virtual Model
+
+Virtual Model is the model not backed by a database table, usually used as "form model" or "presenter", because it's implement interfaces of Active Model, so you can use it like a normal Active Record model in your Rails app.
+
+## Features
+
+### Attribute declaration
+
+```ruby
+class Book < ActiveEntity::Base
+  attribute :title, :string
+  attribute :tags, :string, array: true, default: []
+end
+```
+
+Same usage with Active Record, [Learn more](https://api.rubyonrails.org/classes/ActiveRecord/Attributes/ClassMethods.html#method-i-attribute).
+
+One enhancement is `array: true` that transform the attribute to an array that can accept multiple values.
+
+### Nested attributes
+
+Active Entity supports its own variant of nested attributes via the `embeds_one` / `embeds_many` macros. The intention is to be mostly compatible with ActiveRecord's `accepts_nested_attributes` functionality.
+
+```ruby
+class Holiday < ActiveRecord::Base
+  validates :date, presence: true
+end
+
+class HolidaysForm < ActiveType::Object
+  nests_many :holidays, reject_if: :all_blank
+end
+```
+
+### Validations
+
+```ruby
+class Book < ActiveEntity::Base
+  attribute :title, :string
+  validates :title, presence: true
+end
+```
+
+Supported Active Record validations:
+
+- [acceptance](https://guides.rubyonrails.org/active_record_validations.html#acceptance)
+- [confirmation](https://guides.rubyonrails.org/active_record_validations.html#confirmation)
+- [exclusion](https://guides.rubyonrails.org/active_record_validations.html#exclusion)
+- [format](https://guides.rubyonrails.org/active_record_validations.html#format)
+- [inclusion](https://guides.rubyonrails.org/active_record_validations.html#inclusion)
+- [length](https://guides.rubyonrails.org/active_record_validations.html#length)
+- [numericality](https://guides.rubyonrails.org/active_record_validations.html#numericality)
+- [presence](https://guides.rubyonrails.org/active_record_validations.html#presence)
+- [absence](https://guides.rubyonrails.org/active_record_validations.html#absence)
+
+[Common validation options](https://guides.rubyonrails.org/active_record_validations.html#common-validation-options) supported too.
+
+#### `subset` validation
+
+Because Active Entity supports array attribute, for some reason, we may want to test values of an array attribute are all included in a given set.
+
+Active Entity provides `subset` validation to achieve that, it usage similar to `inclusion` or `exclusion`
+
+```ruby
+class Steak < ActiveEntity::Base
+  attribute :side_dishes, :string, array: true, default: []
+  validates :side_dishes, subset: { in: %w(chips mashed_potato salad)
+end
+```
+
+#### `uniqueness_in_embedding` validation
+
+Active Entity provides `uniqueness_in_embedding` validation to test duplicate nesting virtual record.
+
+```ruby
+class Category < ActiveEntity::Base
+  attribute :name
+end
+
+class Book < ActiveEntity::Base
+  embeds_many :categories
+  
+  validates :categories, uniqueness_in_embedding: {key: :name}
+end
+```
+
+Argument `key` is attribute name of nested model, it also supports multiple attributes by given an array.
+
+### Others
+
+These Active Record feature also available in Active Entity
+
+- [`composed_of`](https://api.rubyonrails.org/classes/ActiveRecord/Aggregations/ClassMethods.html)
+- [`enum`](https://api.rubyonrails.org/v5.2.2/classes/ActiveRecord/Enum.html) (You must declare the attribute which use for `enum` first)
+- [`serializable_hash`](https://api.rubyonrails.org/classes/ActiveModel/Serialization.html#method-i-serializable_hash)
+- [`serialize`](https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html#method-i-serialize)
+- [`store`](https://api.rubyonrails.org/classes/ActiveRecord/Store.html)
+
+#### I18n
+
+Same to [Active Record I18n](https://guides.rubyonrails.org/i18n.html#translations-for-active-record-models), the only different is the root of locale YAML is `active_entity` instead of `activerecord`
+
+#### Read-only attributes
+
+You can use `attr_readonly :title, :author` to prevent assign value to attribute after initialized.
+
+You can use `enable_readonly!` and `disable_readonly!` to control the behavior.
+
+**Important: It's no effect with embeds or array attributes !!!**
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activeentity'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install activeentity
+```
+
+## Contributing
+
+- Fork the project.
+- Make your feature addition or bug fix.
+- Add tests for it. This is important so I don't break it in a future version unintentionally.
+- Commit, do not mess with Rakefile or version (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+- Send me a pull request. Bonus points for topic branches.
+
+## 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,29 @@
+# frozen_string_literal: true
+
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "MyPlugin"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+task default: :test

data/lib/active_entity.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/rails"
+require "yaml"
+
+require "active_model"
+require "active_model/attribute_set"
+
+require "active_entity/version"
+
+module ActiveEntity
+  extend ActiveSupport::Autoload
+
+  autoload :Base
+  autoload :Core
+  autoload :Enum
+  autoload :Inheritance
+  autoload :Integration
+  autoload :ModelSchema
+  autoload :NestedAttributes
+  autoload :ReadonlyAttributes
+  autoload :Reflection
+  autoload :Serialization
+  autoload :Store
+  autoload :Translation
+  autoload :Validations
+
+  eager_autoload do
+    autoload :ActiveEntityError, "active_entity/errors"
+
+    autoload :Aggregations
+    autoload :Associations
+    autoload :AttributeAssignment
+    autoload :AttributeMethods
+    autoload :ValidateEmbeddedAssociation
+
+    autoload :Type
+  end
+
+  module Coders
+    autoload :YAMLColumn, "active_entity/coders/yaml_column"
+    autoload :JSON, "active_entity/coders/json"
+  end
+
+  module AttributeMethods
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :BeforeTypeCast
+      autoload :PrimaryKey
+      autoload :Query
+      autoload :Serialization
+      autoload :Read
+      autoload :TimeZoneConversion
+      autoload :Write
+    end
+  end
+
+  def self.eager_load!
+    super
+
+    ActiveEntity::Associations.eager_load!
+    ActiveEntity::AttributeMethods.eager_load!
+  end
+end
+
+ActiveSupport.on_load(:i18n) do
+  I18n.load_path << File.expand_path("active_entity/locale/en.yml", __dir__)
+end
+
+YAML.load_tags["!ruby/object:ActiveEntity::AttributeSet"] = "ActiveModel::AttributeSet"
+YAML.load_tags["!ruby/object:ActiveEntity::LazyAttributeHash"] = "ActiveModel::LazyAttributeHash"

data/lib/active_entity/aggregations.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  # See ActiveEntity::Aggregations::ClassMethods for documentation
+  module Aggregations
+    def initialize_dup(*) # :nodoc:
+      @aggregation_cache = {}
+      super
+    end
+
+    private
+
+      def init_internals
+        @aggregation_cache = {}
+        super
+      end
+
+      # Active Entity implements aggregation through a macro-like class method called #composed_of
+      # for representing attributes as value objects. It expresses relationships like "Account [is]
+      # composed of Money [among other things]" or "Person [is] composed of [an] address". Each call
+      # to the macro adds a description of how the value objects are created from the attributes of
+      # the entity object (when the entity is initialized either as a new object or from finding an
+      # existing object) and how it can be turned back into attributes (when the entity is saved to
+      # the database).
+      #
+      #   class Customer < ActiveEntity::Base
+      #     composed_of :balance, class_name: "Money", mapping: %w(balance amount)
+      #     composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
+      #   end
+      #
+      # The customer class now has the following methods to manipulate the value objects:
+      # * <tt>Customer#balance, Customer#balance=(money)</tt>
+      # * <tt>Customer#address, Customer#address=(address)</tt>
+      #
+      # These methods will operate with value objects like the ones described below:
+      #
+      #  class Money
+      #    include Comparable
+      #    attr_reader :amount, :currency
+      #    EXCHANGE_RATES = { "USD_TO_DKK" => 6 }
+      #
+      #    def initialize(amount, currency = "USD")
+      #      @amount, @currency = amount, currency
+      #    end
+      #
+      #    def exchange_to(other_currency)
+      #      exchanged_amount = (amount * EXCHANGE_RATES["#{currency}_TO_#{other_currency}"]).floor
+      #      Money.new(exchanged_amount, other_currency)
+      #    end
+      #
+      #    def ==(other_money)
+      #      amount == other_money.amount && currency == other_money.currency
+      #    end
+      #
+      #    def <=>(other_money)
+      #      if currency == other_money.currency
+      #        amount <=> other_money.amount
+      #      else
+      #        amount <=> other_money.exchange_to(currency).amount
+      #      end
+      #    end
+      #  end
+      #
+      #  class Address
+      #    attr_reader :street, :city
+      #    def initialize(street, city)
+      #      @street, @city = street, city
+      #    end
+      #
+      #    def close_to?(other_address)
+      #      city == other_address.city
+      #    end
+      #
+      #    def ==(other_address)
+      #      city == other_address.city && street == other_address.street
+      #    end
+      #  end
+      #
+      # Now it's possible to access attributes from the database through the value objects instead. If
+      # you choose to name the composition the same as the attribute's name, it will be the only way to
+      # access that attribute. That's the case with our +balance+ attribute. You interact with the value
+      # objects just like you would with any other attribute:
+      #
+      #   customer.balance = Money.new(20)     # sets the Money value object and the attribute
+      #   customer.balance                     # => Money value object
+      #   customer.balance.exchange_to("DKK")  # => Money.new(120, "DKK")
+      #   customer.balance > Money.new(10)     # => true
+      #   customer.balance == Money.new(20)    # => true
+      #   customer.balance < Money.new(5)      # => false
+      #
+      # Value objects can also be composed of multiple attributes, such as the case of Address. The order
+      # of the mappings will determine the order of the parameters.
+      #
+      #   customer.address_street = "Hyancintvej"
+      #   customer.address_city   = "Copenhagen"
+      #   customer.address        # => Address.new("Hyancintvej", "Copenhagen")
+      #
+      #   customer.address = Address.new("May Street", "Chicago")
+      #   customer.address_street # => "May Street"
+      #   customer.address_city   # => "Chicago"
+      #
+      # == Writing value objects
+      #
+      # Value objects are immutable and interchangeable objects that represent a given value, such as
+      # a Money object representing $5. Two Money objects both representing $5 should be equal (through
+      # methods such as <tt>==</tt> and <tt><=></tt> from Comparable if ranking makes sense). This is
+      # unlike entity objects where equality is determined by identity. An entity class such as Customer can
+      # easily have two different objects that both have an address on Hyancintvej. Entity identity is
+      # determined by object or relational unique identifiers (such as primary keys). Normal
+      # ActiveEntity::Base classes are entity objects.
+      #
+      # It's also important to treat the value objects as immutable. Don't allow the Money object to have
+      # its amount changed after creation. Create a new Money object with the new value instead. The
+      # <tt>Money#exchange_to</tt> method is an example of this. It returns a new value object instead of changing
+      # its own values. Active Entity won't persist value objects that have been changed through means
+      # other than the writer method.
+      #
+      # The immutable requirement is enforced by Active Entity by freezing any object assigned as a value
+      # object. Attempting to change it afterwards will result in a +RuntimeError+.
+      #
+      # Read more about value objects on http://c2.com/cgi/wiki?ValueObject and on the dangers of not
+      # keeping value objects immutable on http://c2.com/cgi/wiki?ValueObjectsShouldBeImmutable
+      #
+      # == Custom constructors and converters
+      #
+      # By default value objects are initialized by calling the <tt>new</tt> constructor of the value
+      # class passing each of the mapped attributes, in the order specified by the <tt>:mapping</tt>
+      # option, as arguments. If the value class doesn't support this convention then #composed_of allows
+      # a custom constructor to be specified.
+      #
+      # When a new value is assigned to the value object, the default assumption is that the new value
+      # is an instance of the value class. Specifying a custom converter allows the new value to be automatically
+      # converted to an instance of value class if necessary.
+      #
+      # For example, the +NetworkResource+ model has +network_address+ and +cidr_range+ attributes that should be
+      # aggregated using the +NetAddr::CIDR+ value class (http://www.rubydoc.info/gems/netaddr/1.5.0/NetAddr/CIDR).
+      # The constructor for the value class is called +create+ and it expects a CIDR address string as a parameter.
+      # New values can be assigned to the value object using either another +NetAddr::CIDR+ object, a string
+      # or an array. The <tt>:constructor</tt> and <tt>:converter</tt> options can be used to meet
+      # these requirements:
+      #
+      #   class NetworkResource < ActiveEntity::Base
+      #     composed_of :cidr,
+      #                 class_name: 'NetAddr::CIDR',
+      #                 mapping: [ %w(network_address network), %w(cidr_range bits) ],
+      #                 allow_nil: true,
+      #                 constructor: Proc.new { |network_address, cidr_range| NetAddr::CIDR.create("#{network_address}/#{cidr_range}") },
+      #                 converter: Proc.new { |value| NetAddr::CIDR.create(value.is_a?(Array) ? value.join('/') : value) }
+      #   end
+      #
+      #   # This calls the :constructor
+      #   network_resource = NetworkResource.new(network_address: '192.168.0.1', cidr_range: 24)
+      #
+      #   # These assignments will both use the :converter
+      #   network_resource.cidr = [ '192.168.2.1', 8 ]
+      #   network_resource.cidr = '192.168.0.1/24'
+      #
+      #   # This assignment won't use the :converter as the value is already an instance of the value class
+      #   network_resource.cidr = NetAddr::CIDR.create('192.168.2.1/8')
+      #
+      #   # Saving and then reloading will use the :constructor on reload
+      #   network_resource.save
+      #   network_resource.reload
+      #
+      # == Finding records by a value object
+      #
+      # Once a #composed_of relationship is specified for a model, records can be loaded from the database
+      # by specifying an instance of the value object in the conditions hash. The following example
+      # finds all customers with +address_street+ equal to "May Street" and +address_city+ equal to "Chicago":
+      #
+      #   Customer.where(address: Address.new("May Street", "Chicago"))
+      #
+      module ClassMethods
+        # Adds reader and writer methods for manipulating a value object:
+        # <tt>composed_of :address</tt> adds <tt>address</tt> and <tt>address=(new_address)</tt> methods.
+        #
+        # Options are:
+        # * <tt>:class_name</tt> - Specifies the class name of the association. Use it only if that name
+        #   can't be inferred from the part id. So <tt>composed_of :address</tt> will by default be linked
+        #   to the Address class, but if the real class name is +CompanyAddress+, you'll have to specify it
+        #   with this option.
+        # * <tt>:mapping</tt> - Specifies the mapping of entity attributes to attributes of the value
+        #   object. Each mapping is represented as an array where the first item is the name of the
+        #   entity attribute and the second item is the name of the attribute in the value object. The
+        #   order in which mappings are defined determines the order in which attributes are sent to the
+        #   value class constructor.
+        # * <tt>:allow_nil</tt> - Specifies that the value object will not be instantiated when all mapped
+        #   attributes are +nil+. Setting the value object to +nil+ has the effect of writing +nil+ to all
+        #   mapped attributes.
+        #   This defaults to +false+.
+        # * <tt>:constructor</tt> - A symbol specifying the name of the constructor method or a Proc that
+        #   is called to initialize the value object. The constructor is passed all of the mapped attributes,
+        #   in the order that they are defined in the <tt>:mapping option</tt>, as arguments and uses them
+        #   to instantiate a <tt>:class_name</tt> object.
+        #   The default is <tt>:new</tt>.
+        # * <tt>:converter</tt> - A symbol specifying the name of a class method of <tt>:class_name</tt>
+        #   or a Proc that is called when a new value is assigned to the value object. The converter is
+        #   passed the single value that is used in the assignment and is only called if the new value is
+        #   not an instance of <tt>:class_name</tt>. If <tt>:allow_nil</tt> is set to true, the converter
+        #   can return +nil+ to skip the assignment.
+        #
+        # Option examples:
+        #   composed_of :temperature, mapping: %w(reading celsius)
+        #   composed_of :balance, class_name: "Money", mapping: %w(balance amount)
+        #   composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
+        #   composed_of :gps_location
+        #   composed_of :gps_location, allow_nil: true
+        #   composed_of :ip_address,
+        #               class_name: 'IPAddr',
+        #               mapping: %w(ip to_i),
+        #               constructor: Proc.new { |ip| IPAddr.new(ip, Socket::AF_INET) },
+        #               converter: Proc.new { |ip| ip.is_a?(Integer) ? IPAddr.new(ip, Socket::AF_INET) : IPAddr.new(ip.to_s) }
+        #
+        def composed_of(part_id, options = {})
+          options.assert_valid_keys(:class_name, :mapping, :allow_nil, :constructor, :converter)
+
+          unless self < Aggregations
+            include Aggregations
+          end
+
+          name        = part_id.id2name
+          class_name  = options[:class_name]  || name.camelize
+          mapping     = options[:mapping]     || [ name, name ]
+          mapping     = [ mapping ] unless mapping.first.is_a?(Array)
+          allow_nil   = options[:allow_nil]   || false
+          constructor = options[:constructor] || :new
+          converter   = options[:converter]
+
+          reader_method(name, class_name, mapping, allow_nil, constructor)
+          writer_method(name, class_name, mapping, allow_nil, converter)
+
+          reflection = ActiveEntity::Reflection.create(:composed_of, part_id, nil, options, self)
+          Reflection.add_aggregate_reflection self, part_id, reflection
+        end
+
+        private
+          def reader_method(name, class_name, mapping, allow_nil, constructor)
+            define_method(name) do
+              if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? { |key, _| !_read_attribute(key).nil? })
+                attrs = mapping.collect { |key, _| _read_attribute(key) }
+                object = constructor.respond_to?(:call) ?
+                  constructor.call(*attrs) :
+                  class_name.constantize.send(constructor, *attrs)
+                @aggregation_cache[name] = object
+              end
+              @aggregation_cache[name]
+            end
+          end
+
+          def writer_method(name, class_name, mapping, allow_nil, converter)
+            define_method("#{name}=") do |part|
+              klass = class_name.constantize
+
+              unless part.is_a?(klass) || converter.nil? || part.nil?
+                part = converter.respond_to?(:call) ? converter.call(part) : klass.send(converter, part)
+              end
+
+              hash_from_multiparameter_assignment = part.is_a?(Hash) &&
+                part.each_key.all? { |k| k.is_a?(Integer) }
+              if hash_from_multiparameter_assignment
+                raise ArgumentError unless part.size == part.each_key.max
+                part = klass.new(*part.sort.map(&:last))
+              end
+
+              if part.nil? && allow_nil
+                mapping.each { |key, _| self[key] = nil }
+                @aggregation_cache[name] = nil
+              else
+                mapping.each { |key, value| self[key] = part.send(value) }
+                @aggregation_cache[name] = part.freeze
+              end
+            end
+          end
+      end
+  end
+end