structure 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcf8086bf1877fd717dc7502032e3885d330b9f94121ccdf78c7284e2d5142d9
-  data.tar.gz: c57b41a06c261f717dc00b3d4b97a2ff764b84fcfcbf4a478a53aaba6f60b646
+  metadata.gz: 6b08d68f313a052ecf51e5ddae25a9c01b2fa97f4d62faffd0886036f2143569
+  data.tar.gz: '0330855f5dbce7826cbdc2c845e719c81e6b1e60e17fcf5bc3a58a496ffa2944'
 SHA512:
-  metadata.gz: 4ecebfdf31f9380e7739f80e43ac16ebf975f18a9e19fe17af922fb9652fe348e1cc858912404d2baf5c1ee108073e11e3037d1fbc75078c1779ba99f27a44f7
-  data.tar.gz: e0b73c21bc741741f5e6808abd2f2fdbb97270f869f4ddd44bc5864d15f97be236514b12bf9d31aec25a8bc1c43a30b511c983f88caf4d91e6cffd957e1095b4
+  metadata.gz: 0c4bfbe6e6cbeaaf3440b71894f469e03b71eb272a570bd127923960eddec434750badd66d5258a79ee559b4c59f5be9141ab9595eb7f82b27108f5e26340751
+  data.tar.gz: 48fa29e4f97245598a2af38667e32b4bee11e87c65944c9570219fb764e0383a3d4bdaf5b71d403cde00f0e4dcff7bdb68f25566d2cb8f866b1f9c8ee1ae2913

data/lib/structure.rb

@@ -1,20 +1,44 @@
 # frozen_string_literal: true
 
 require 'structure/class_methods'
-require 'structure/utils'
 
 module Structure
+  def self.inspect(value)
+    if value.is_a?(::Array)
+      inspection = value.take(3)
+                        .map { |subvalue| inspect(subvalue) }
+                        .join(', ')
+      inspection += '...' if value.size > 3
+
+      "[#{inspection}]"
+    else
+      value.inspect
+    end
+  end
+
+  def self.serialize(value)
+    if value.respond_to?(:attributes)
+      value.attributes
+    elsif value.is_a?(::Array)
+      value.map { |subvalue| serialize(subvalue) }
+    else
+      value
+    end
+  end
+
   def self.included(base)
     base.extend ClassMethods
-    base.__overwrite_initialize__
   end
 
+  # Returns a hash of all the attributes with their names as keys and the
+  # values of the attributes as values
   def attributes
     attribute_names.each_with_object({}) do |key, hash|
-      hash[key] = Utils.serialize(send(key))
+      hash[key] = Structure.serialize(send(key))
     end
   end
 
+  # Returns an array of attribute names as strings
   def attribute_names
     self.class.attribute_names
   end
@@ -27,19 +51,9 @@ module Structure
 
   def inspect
     name = self.class.name || self.class.to_s.gsub(/[^\w:]/, '')
-    values =
-      attribute_names
-      .map do |key|
-        value = send(key)
-        if value.is_a?(::Array)
-          description = value.take(3).map(&:inspect).join(', ')
-          description += '...' if value.size > 3
-          "#{key}=[#{description}]"
-        else
-          "#{key}=#{value.inspect}"
-        end
-      end
-      .join(', ')
+    values = attribute_names
+             .map { |key| "#{key}=#{Structure.inspect(send(key))}" }
+             .join(', ')
 
     "#<#{name} #{values}>"
   end

data/lib/structure/class_methods.rb

@@ -2,16 +2,19 @@
 
 module Structure
   module ClassMethods
+    # Returns an array of attribute names as strings
     attr_reader :attribute_names
 
     def self.extended(base)
       base.instance_variable_set :@attribute_names, []
+      base.send :__overwrite_initialize
     end
 
     def attribute(name, &block)
       name = name.to_s
 
-      if name.chomp!('?')
+      if name.end_with?('?')
+        name = name.chop
         module_eval <<-CODE, __FILE__, __LINE__ + 1
           def #{name}?
             #{name}
@@ -21,48 +24,51 @@ module Structure
 
       module_eval <<-CODE, __FILE__, __LINE__ + 1
         def #{name}
-          @__mutex__.synchronize {
-            return @#{name} if defined?(@#{name})
+          @__mutex.synchronize {
+            break if @__table.key?("#{name}")
 
-            @#{name} = __#{name}__
-            @#{name}.freeze unless @#{name}.is_a?(Structure)
+            @__table["#{name}"] = __#{name}
+            @__table["#{name}"].freeze
 
-            @#{name}
+            @__table["#{name}"]
           }
+
+          @__table["#{name}"]
         end
       CODE
 
-      define_method "__#{name}__", block
-      private "__#{name}__"
+      define_method "__#{name}", block
+      private "__#{name}"
 
       @attribute_names << name
 
       name.to_sym
     end
 
-    def __overwrite_initialize__
+    private
+
+    def __overwrite_initialize
       class_eval do
-        unless method_defined?(:__custom_initialize__)
-          define_method :__custom_initialize__ do |*args|
-            @__mutex__ = ::Thread::Mutex.new
-            __original_initialize__(*args)
+        unless method_defined?(:__custom_initialize)
+          define_method :__custom_initialize do |*arguments, &block|
+            @__mutex = ::Thread::Mutex.new
+            @__table = {}
+            __original_initialize(*arguments, &block)
+            freeze
           end
         end
 
         return if instance_method(:initialize) ==
-                  instance_method(:__custom_initialize__)
+                  instance_method(:__custom_initialize)
 
-        alias_method :__original_initialize__, :initialize
-        alias_method :initialize, :__custom_initialize__
+        alias_method :__original_initialize, :initialize
+        alias_method :initialize, :__custom_initialize
+        private :__custom_initialize, :__original_initialize
       end
     end
 
-    private
-
     def method_added(name)
-      return if name != :initialize
-
-      __overwrite_initialize__
+      __overwrite_initialize if name == :initialize
     end
 
     def inherited(subclass)

data/lib/structure/double.rb

@@ -2,31 +2,32 @@
 
 module Structure
   module ClassMethods
+    # Creates a double that mocks a value object built with Structure during a
+    # test
+    #
+    # The double has an alternative constructor that takes a hash to set values.
+    # Otherwise, it shares the public API of the mocked value object.
     def double
       klass = Class.new(self)
 
-      (
-        private_instance_methods(false) +
-        protected_instance_methods(false) -
-        [:initialize]
-      ).each do |name|
+      (private_instance_methods(false) + protected_instance_methods(false) -
+        [:initialize]).each do |name|
         klass.send :undef_method, name
       end
 
       klass.module_eval do
-        def initialize(data = {})
-          data.each do |key, value|
+        def initialize(values = {})
+          values.each do |key, value|
             instance_variable_set :"@#{key}", value
           end
         end
 
         attribute_names.each do |name|
           module_eval <<-CODE, __FILE__, __LINE__ + 1
-            def __#{name}__
+            private def __#{name}
               @#{name}
             end
           CODE
-          private "__#{name}__"
         end
 
         module_eval(&Proc.new) if block_given?

data/lib/structure/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Structure
-  VERSION = '1.1.1'
+  VERSION = '1.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Hakan Ensari
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-24 00:00:00.000000000 Z
+date: 2019-05-26 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: 
@@ -19,7 +19,6 @@ files:
 - lib/structure.rb
 - lib/structure/class_methods.rb
 - lib/structure/double.rb
-- lib/structure/utils.rb
 - lib/structure/version.rb
 homepage: 
 licenses:

data/lib/structure/utils.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Structure
-  module Utils
-    def self.serialize(value)
-      if value.respond_to?(:attributes)
-        value.attributes
-      elsif value.is_a?(::Array)
-        value.map { |subvalue| serialize(subvalue) }
-      else
-        value
-      end
-    end
-  end
-end