objectmancy 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d58d07ca21141f331f6008c56d07660bc1e9187d
-  data.tar.gz: a5856401d36e4899530e11964b5f748fce6cc93a
+  metadata.gz: 62c3afc8c03ca9e9c0de91c4935d1476aa51eb18
+  data.tar.gz: 2a1834ac88ef320a58f8c15e6e36618a9bb2bcac
 SHA512:
-  metadata.gz: db17c08f46d637f97c1f4730ef9480a99864ebfe2c92432558fc297a4007ad760a4da6041083c2dbdcae16bbee705c574c5b80210b63a13e3737cfd2c9c279ab
-  data.tar.gz: 7c9691474e80119c1c0a3cc94e7fdbb28c2e12e2194b40e10c3cc3ee7ffb4afda0e6abb51e4ddbc976884c14e1c124eae2f26f2c993cb35a811e2402f658700f
+  metadata.gz: 008e5e952f44195e7ea092f7419805887b7e6803f2b97454c7b80bba24b3a0665fcf2724079123c1d5a3dc4fcfed2889068593eaeaccfd0af548fdb893e94e41
+  data.tar.gz: 60c2a0195efd52ad84ca2c507235e6378a1c8588e60ea0f59529db319de588f1304563a98a49fe666eec783bf5411c6428fabf68226826362d4c50750475b997

data/lib/objectmancy/attribute_options.rb

@@ -7,12 +7,22 @@ module Objectmancy
     # @!attribute [r] type
     # @!attribute [r] objectable
     # @!attribute [r] multiple
-    attr_reader :type, :objectable, :multiple
+    # @!attribute [r] hashable
+    attr_reader :type, :objectable, :multiple, :hashable
 
     def initialize(**options)
       @type = options[:type]
       @objectable = options[:objectable]
       @multiple = options[:multiple]
+      @hashable = options[:hashable]
+    end
+
+    # Returns a new copy of of the given object without a value for the multiple
+    # attribute.
+    #
+    # @return [AttributeOptions]
+    def force_singular
+      AttributeOptions.new(type: type, hashable: hashable)
     end
   end
 end

data/lib/objectmancy/common_class_methods.rb

@@ -0,0 +1,69 @@
+require 'objectmancy/errors'
+require 'objectmancy/attribute_options'
+require 'objectmancy/hashable'
+
+module Objectmancy
+  # Class methods mixed into anything including one of the mixins for
+  # Objectmancy
+  module CommonClassMethods
+    # @private
+    # Basic setup of the class-level state.
+    def self.extended(base)
+      base.instance_variable_set(:@registered_attributes, {})
+      base.class.send(:attr_reader, :registered_attributes)
+      base.send(:private_class_method, :attribute, :multiples)
+    end
+
+    # Defines an attribute usable by Objectmancy to create your object.
+    # Only attributes defined with this method will be converted to attributes
+    # on the final object.
+    #
+    # @param name [#to_sym] Attribute name
+    # @param opts [Hash] Options to be applied
+    # @option opts [Symbol, Class] :type The type of object to create. Can be
+    #   either a Symbol of one of: :datetime; else, a Class
+    # @option opts [Symbol, String] :objectable Method to call on :type. Will
+    #   default to calling :new. Ignored if :type is one of the known types.
+    #   Requires :type option.
+    # @raise [AttributeAlreadyDefinedError] Attempt to define two attributes
+    #   of the same name
+    # @raise [ArgumentError] Pass in :objectable without :type
+    def attribute(name, **opts)
+      symbolized_name = name.to_sym
+
+      if registered_attributes.key? symbolized_name
+        raise AttributeAlreadyDefinedError, name
+      end
+
+      if opts[:objectable] && opts[:type].nil?
+        raise ArgumentError, ':objectable option reuqires :type option'
+      end
+
+      registered_attributes[symbolized_name] = AttributeOptions.new(opts)
+
+      attr_accessor symbolized_name
+    end
+
+    # Allows the definition of Arrays of items to be turns into objects. Bear
+    # in mind that Arrays of basic objects (Strings, numbers, anything else
+    # that doesn't need special initialization) are handled by .attribute.
+    #
+    # @param name [#to_sym] Attribute name
+    # @param opts [Hash] Options to be applied
+    # @option opts [Symbol, Class] :type The type of object to create. Can be
+    #   either a Symbol of one of: :datetime; else, a Class
+    # @option opts [Symbol, String] :objectable Method to call on :type. Will
+    #   default to calling :new. Ignored if :type is one of the known types.
+    # @raise [AttributeAlreadyDefinedError] Attempt to define two attributes
+    #   of the same name
+    # @raise [ArgumentError] Calling .multiples without :type option for
+    #   non-Hashable objects.
+    def multiples(name, **opts)
+      if !ancestors.include?(Objectmancy::Hashable) && opts[:type].nil?
+        raise ArgumentError, 'Multiples require the :type option'
+      end
+
+      attribute(name, opts.merge(multiple: true))
+    end
+  end
+end

data/lib/objectmancy/hashable.rb

@@ -0,0 +1,83 @@
+require 'objectmancy/common_class_methods'
+require 'objectmancy/types'
+require 'pry'
+
+module Objectmancy
+  # Mixin for allowing your object to be converted into a Hash.
+  module Hashable
+    # ClassMethods specific to Hashable functionality
+    # module ClassMethods
+    #   # Allows the definition of Arrays of items to be turns into objects. Bear
+    #   # in mind that Arrays of basic objects (Strings, numbers, anything else
+    #   # that doesn't need special initialization) are handled by .attribute.
+    #   #
+    #   # @param name [#to_sym] Attribute name
+    #   # @param opts [Hash] Options to be applied
+    #   # @option opts [Symbol, Class] :type The type of object to create. Can be
+    #   #   either a Symbol of one of: :datetime; else, a Class
+    #   # @option opts [Symbol, String] :objectable Method to call on :type. Will
+    #   #   default to calling :new. Ignored if :type is one of the known types.
+    #   # @raise [AttributeAlreadyDefinedError] Attempt to define two attributes
+    #   #   of the same name
+    #   def multiples(name, **opts)
+    #     super(name, { hashable: true }.merge(opts))
+    #   end
+    # end
+
+    # @private
+    # This is a little shady, but I'm not sure of a better way to do it.
+    # I gladly welcome suggestions.
+    def self.included(base)
+      base.extend(CommonClassMethods)
+    end
+
+    # Turns the object into a Hash according to the rules defined with
+    #
+    # @return [Hash] Hash representing the object
+    def hashify
+      _present_hashable_values.each_with_object({}) do |(attr, options), memo|
+        memo[attr] = _hashify_value(send(attr), options)
+      end
+    end
+
+    private
+
+    # Provides current hashable values which have a non-empty value
+    #
+    # @return [Hash] Hash of values
+    def _present_hashable_values
+      self.class.registered_attributes.reject do |attr, _|
+        attr_to_check = send(attr)
+
+        attr_to_check.nil? ||
+          (attr_to_check.respond_to?(:empty?) && attr_to_check.empty?)
+      end
+    end
+
+    # Generates the value for the produced hash
+    #
+    # @param value [Object] Object to be used as a value for the hash
+    # @param attribute_options [AttributeOptions] Options for the current
+    #   attribute
+    # @return [Object] Value for the final hash
+    def _hashify_value(value, attribute_options)
+      if value.respond_to? :hashify
+        value.hashify
+      elsif attribute_options.multiple
+        value.map { |v| _hashify_value(v, attribute_options.force_singular) }
+      elsif attribute_options.hashable || attribute_options.type
+        _convert_hashable_value(value, attribute_options)
+      else
+        value
+      end
+    end
+
+    def _convert_hashable_value(value, attribute_options)
+      hashable_method =
+        attribute_options.hashable ||
+        Types::SPECIAL_TYPES[attribute_options.type][:hashable]
+
+      value.send(hashable_method)
+    end
+  end
+end

data/lib/objectmancy/objectable.rb

@@ -1,13 +1,9 @@
-require 'objectmancy/errors'
+require 'objectmancy/common_class_methods'
 require 'objectmancy/types'
-require 'objectmancy/attribute_options'
-
-require 'pry'
 
 module Objectmancy
   # Mixin for allowing your objects to take a Hash and turn them into an object.
-  # By default, the values will be whatever the value of the Hash at that key
-  # is.
+  #
   # @example Including Objectable
   #   class Kitten
   #     include Objectmancy::Objectable
@@ -17,75 +13,10 @@ module Objectmancy
   #
   #   tabby = Kitten.new(name: 'Eddy')
   #   tabby.name # => "Eddy"
-  #
-  #
   module Objectable
     # @private
     def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    # Class methods mixed into anything including Objectable. These are where
-    # the real power of Objectmancy comes from.
-    module ClassMethods
-      # @private
-      # Basic setup of the class-level state.
-      def self.extended(base)
-        base.instance_variable_set(:@registered_attributes, {})
-        base.class.send(:attr_reader, :registered_attributes)
-        base.send(:private_class_method, :attribute, :multiples)
-      end
-
-      # Defines an attribute usable by Objectmancy to create your object.
-      # Only attributes defined with this method will be converted to attributes
-      # on the final object.
-      #
-      # @param name [#to_sym] Attribute name
-      # @param opts [Hash] Options to be applied
-      # @option opts [Symbol, Class] :type The type of object to create. Can be
-      #   either a Symbol of one of: :datetime; else, a Class
-      # @option opts [Symbol, String] :objectable Method to call on :type. Will
-      #   default to calling :new. Ignored if :type is one of the known types.
-      #   Requires :type option.
-      # @raise [AttributeAlreadyDefinedError] Attempt to define two attributes
-      #   of the same name
-      # @raise [ArgumentError] Pass in :objectable without :type
-      def attribute(name, **opts)
-        symbolized_name = name.to_sym
-
-        if registered_attributes.key? symbolized_name
-          raise AttributeAlreadyDefinedError, name
-        end
-
-        if opts[:objectable] && opts[:type].nil?
-          raise ArgumentError, ':objectable option reuqires :type option'
-        end
-
-        registered_attributes[symbolized_name] = AttributeOptions.new(opts)
-
-        attr_accessor symbolized_name
-      end
-
-      # Allows the definition of Arrays of items to be turns into objects. Bear
-      # in mind that Arrays of basic objects (Strings, numbers, anything else
-      # that doesn't need special initialization) are handled by .attribute.
-      #
-      # @param name [#to_sym] Attribute name
-      # @param opts [Hash] Options to be applied
-      # @option opts [Symbol, Class] :type The type of object to create. Can be
-      #   either a Symbol of one of: :datetime; else, a Class
-      # @option opts [Symbol, String] :objectable Method to call on :type. Will
-      #   default to calling :new. Ignored if :type is one of the known types.
-      # @raise [AttributeAlreadyDefinedError] Attempt to define two attributes
-      #   of the same name
-      # @raise [ArgumentError] Calling .multiples without :type option
-      def multiples(name, **opts)
-        if opts[:type].nil?
-          raise ArgumentError, 'Multiples require the :type option'
-        end
-
-        attribute(name, opts.merge(multiple: true))
-      end
+      base.extend(CommonClassMethods)
     end
 
     # Creates your object. You should use the after_initialize
@@ -94,20 +25,28 @@ module Objectmancy
     def initialize(attrs = {})
       before_initialize
 
-      _assignable_attributes(attrs).each do |attr, value|
-        options = self.class.registered_attributes[attr.to_sym]
+      _attributes_update!(attrs)
 
-        value =
-          if options.multiple
-            _convert_multiples(value, options.type, options.objectable)
-          else
-            _single_value(value, options)
-          end
+      after_initialize
+    end
 
-        send("#{attr}=", value)
-      end
+    # Updates the attributes of the object
+    #
+    # @param attrs [Hash] Attributes to update
+    def mass_update(attrs = {})
+      _attributes_update!(attrs)
+    end
 
-      after_initialize
+    # Comparator for two objects
+    #
+    # @param other [Object]to be compared to
+    # @return [TrueClass, FalseClass] Boolean indicating if the two objects
+    #   are equal.
+    def ==(other)
+      self.class == other.class &&
+        self.class.registered_attributes.keys.all? do |attr|
+          send(attr) == other.send(attr)
+        end
     end
 
     private
@@ -120,12 +59,30 @@ module Objectmancy
 
     # Determines which attributes are assignable
     #
-    # @param attrs [Hash] Provided base hash
+    # @param attrs [Hash] Provided hash of attributes
     # @return [Hash] Allowed attributes
     def _assignable_attributes(attrs)
       attrs.select { |k, _| self.class.registered_attributes.include? k.to_sym }
     end
 
+    # Updates the values for defiend attributes
+    #
+    # @param attrs [Hash] Provided hash of attributes
+    def _attributes_update!(attrs)
+      _assignable_attributes(attrs).each do |attr, value|
+        options = self.class.registered_attributes[attr.to_sym]
+
+        value =
+          if options.multiple
+            _convert_multiples(value, options.type, options.objectable)
+          else
+            _single_value(value, options)
+          end
+
+        send("#{attr}=", value)
+      end
+    end
+
     # Assigns a multiples attribute
     #
     # @param multiples [Array] Array of values to be converted

data/lib/objectmancy/types.rb

@@ -4,7 +4,11 @@ module Objectmancy
   # Namespace for storing type logic around manipulating different data types.
   module Types
     # DateTime special type specification
-    DATETIME = { klass: ISO8601::DateTime, objectable: :new }.freeze
+    DATETIME = {
+      klass: ISO8601::DateTime,
+      objectable: :new,
+      hashable: :to_s
+    }.freeze
 
     # Known types with special behavior defined.
     SPECIAL_TYPES = {

data/lib/objectmancy/version.rb

@@ -1,4 +1,4 @@
 module Objectmancy
   # Version of the gem
-  VERSION = '1.0.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/objectmancy.rb

@@ -1,6 +1,11 @@
 require 'objectmancy/objectable'
+require 'objectmancy/hashable'
 
 # Namespace for all Objectmancy functionality
 # Also serves as a mixin to include Objectable
 module Objectmancy
+  def self.included(base)
+    base.include(Objectable)
+    base.include(Hashable)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: objectmancy
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Jon Anderson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-08 00:00:00.000000000 Z
+date: 2016-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: iso8601
@@ -75,7 +75,9 @@ extra_rdoc_files: []
 files:
 - lib/objectmancy.rb
 - lib/objectmancy/attribute_options.rb
+- lib/objectmancy/common_class_methods.rb
 - lib/objectmancy/errors.rb
+- lib/objectmancy/hashable.rb
 - lib/objectmancy/objectable.rb
 - lib/objectmancy/types.rb
 - lib/objectmancy/version.rb
@@ -89,9 +91,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="