index.xml

<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Libraries on DDD concepts with Ruby</title>
    <link>https://ddd-ruby.github.io/libraries/index.xml</link>
    <description>Recent content in Libraries on DDD concepts with Ruby</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <copyright>Released under the MIT license</copyright>
    <lastBuildDate>Tue, 08 Mar 2016 21:07:13 +0100</lastBuildDate>
    <atom:link href="https://ddd-ruby.github.io/libraries/index.xml" rel="self" type="application/rss+xml" />
    
    <item>
      <title>Ruby libraries supporting DDD</title>
      <link>https://ddd-ruby.github.io/libraries/</link>
      <pubDate>Tue, 08 Mar 2016 21:07:13 +0100</pubDate>
      
      <guid>https://ddd-ruby.github.io/libraries/</guid>
      <description>

&lt;h2 id=&#34;rdm-the-missing-dependencies-manager-for-ruby-apps&#34;&gt;Rdm: the missing dependencies manager for Ruby apps&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/rdm/&#34; target=&#34;_blank&#34;&gt;Rdm&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;With RDM you can split up one big Ruby application into multiple lightweight packages with explicit dependencies. You can do it before going the &lt;code&gt;microservices&lt;/code&gt; road, because this would be a much smoother transition. Going from explicit dependencies graph to proper SOA / microservices is also more straightforward. In DDD it helps to define clearer &lt;a href=&#34;http://martinfowler.com/bliki/BoundedContext.html&#34;&gt;Bounded Contexts&lt;/a&gt;, where each package can only access explicit dependencies. Contrast this with a monolithic Rails application with one global Ruby memory space, and you might understand the benefit of having stricter, more explicit way of managing dependencies.&lt;/p&gt;

&lt;h2 id=&#34;smartioc-a-declarative-dependency-injection-library&#34;&gt;SmartIoC: a declarative dependency Injection library&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/smart_ioc/&#34; target=&#34;_blank&#34;&gt;SmartIoC&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;SmartIoC is a smart and really simple IoC container for Ruby applications.&lt;/p&gt;

&lt;p&gt;It allows you to create your dependencies on demand, supports lazy-loading of Ruby files, also allows different contexts for each dependency, so you get test/lightweight implementations in development / tests enviroments. It works great in combination with &lt;code&gt;Rdm&lt;/code&gt;.&lt;/p&gt;

&lt;h2 id=&#34;hashcast-hash-attributes-caster-in-declarative-way&#34;&gt;HashCast - Hash attributes caster in declarative way&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/hashcast/&#34; target=&#34;_blank&#34;&gt;HashCast&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;In the DDD context it helps to convert user input to a properly casted Ruby object / hash. It is a lightweight dependency-free Ruby library, with a nice DSL for for specifying the structure of expected input with Ruby types.&lt;/p&gt;

&lt;h2 id=&#34;purevalidator-ruby-domain-object-validation-library&#34;&gt;PureValidator - Ruby domain object validation library&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/pure_validator/&#34; target=&#34;_blank&#34;&gt;PureValidator&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;PureValidator is a simple, mostly dependency-free (except &lt;code&gt;i18n&lt;/code&gt;) library to validate your domain Ruby objects. It is an excellent companion to &lt;a href=&#34;https://ddd-ruby.github.io/hashcast/&#34; target=&#34;_blank&#34;&gt;HashCast&lt;/a&gt; to validate your Ruby objects against specific domain rules. What makes PureValidator special is the separation of validation rules from the object to validate. After countless fights against &lt;strong&gt;one-size-fits-all&lt;/strong&gt; &lt;code&gt;ActiveModel::Validations&lt;/code&gt;-style validations that mix domain/value object with its valudations, we came to prefer this simpler and more flexible approach.&lt;/p&gt;

&lt;p&gt;This approach is more popular in functional programming and leads to maintainable, easily unit-testable code. You are free to use multiple different validators for the same object in different situations. For example your validation rules during creation of an object are different from validations when user is changing a single boolean flag on it.&lt;/p&gt;

&lt;h2 id=&#34;contracts-contracts-for-ruby&#34;&gt;Contracts - Contracts for Ruby&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/contracts.ruby/&#34; target=&#34;_blank&#34;&gt;Contracts&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Contracts let you clearly – even beautifully – express how your code behaves, and free you from writing tons of boilerplate, defensive code.&lt;/p&gt;

&lt;p&gt;We have a forked version of &lt;code&gt;contracts&lt;/code&gt; with nice diff output for KeywordArgs type (Hash).&lt;/p&gt;

&lt;h2 id=&#34;active-serializer-a-simple-objects-to-hash-serializer&#34;&gt;Active Serializer - a simple objects to hash serializer.&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/active_serializer/&#34; target=&#34;_blank&#34;&gt;ActiveSerializer&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;ActiveSerializer is a lightweight dependency-free objects serializer with a nice declarative DSL.&lt;/p&gt;

&lt;p&gt;In our &lt;a href=&#34;https://github.com/ddd-ruby/json_serialization_benchmark&#34; target=&#34;_blank&#34;&gt;Serializers performance benchmark&lt;/a&gt; it places on a solid middle ground right after plain Ruby presenters while sporting a declarative DSL, providing you the same convenience as &lt;code&gt;ActiveModel Serializers&lt;/code&gt; do.&lt;/p&gt;

&lt;p&gt;Compared to &lt;code&gt;ActiveModel::Serializers&lt;/code&gt;-dependencies (activemodel / actionpack), that move with the corresponding Rails version, you get non of the potential headaches of conflicting transient dependencies, that are the horror and bane of many biggish Rails applications.&lt;/p&gt;

&lt;h2 id=&#34;apiview-friggin-fast-serializer-gem&#34;&gt;ApiView - Friggin&amp;rsquo; fast Serializer gem&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/api_view/&#34; target=&#34;_blank&#34;&gt;ApiView&lt;/a&gt;
Another lightweight dependency-free objects serializer. Its &lt;code&gt;DSL&lt;/code&gt; is less involved, because its main focus is performance.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;code&gt;ApiView&lt;/code&gt; is currently the fastest known Ruby-based object serializer. If you are generating huge JSON payloads in your Ruby application, it will bring you 5-10X fold performance improvements, as demonstrated in our &lt;a href=&#34;https://github.com/ddd-ruby/json_serialization_benchmark&#34; target=&#34;_blank&#34;&gt;Serializers performance benchmark&lt;/a&gt;.&lt;/p&gt;

&lt;h2 id=&#34;values-values-is-a-tiny-library-for-creating-value-objects-in-ruby&#34;&gt;Values - Values is a tiny library for creating value objects in ruby.&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/tcrayford/Values&#34; target=&#34;_blank&#34;&gt;Values&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;ol&gt;
&lt;li&gt;Constructors require expected arguments&lt;/li&gt;
&lt;li&gt;Instances are immutable&lt;/li&gt;
&lt;/ol&gt;

&lt;h2 id=&#34;overview-on-travis-ci&#34;&gt;Overview on Travis.CI&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://travis-ci.org/ddd-ruby&#34; target=&#34;_blank&#34;&gt;DDD-Ruby libs on Travis&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
  </channel>
</rss>