objectmancy 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d58d07ca21141f331f6008c56d07660bc1e9187d
+  data.tar.gz: a5856401d36e4899530e11964b5f748fce6cc93a
+SHA512:
+  metadata.gz: db17c08f46d637f97c1f4730ef9480a99864ebfe2c92432558fc297a4007ad760a4da6041083c2dbdcae16bbee705c574c5b80210b63a13e3737cfd2c9c279ab
+  data.tar.gz: 7c9691474e80119c1c0a3cc94e7fdbb28c2e12e2194b40e10c3cc3ee7ffb4afda0e6abb51e4ddbc976884c14e1c124eae2f26f2c993cb35a811e2402f658700f

data/lib/objectmancy/attribute_options.rb

@@ -0,0 +1,18 @@
+module Objectmancy
+  # @private
+  # Class to contain the options for attribute definitions. Makes accessing them
+  # more Object-Oriented. This could be written with Objectable, but that felt
+  # a little too on-the-nose.
+  class AttributeOptions
+    # @!attribute [r] type
+    # @!attribute [r] objectable
+    # @!attribute [r] multiple
+    attr_reader :type, :objectable, :multiple
+
+    def initialize(**options)
+      @type = options[:type]
+      @objectable = options[:objectable]
+      @multiple = options[:multiple]
+    end
+  end
+end

data/lib/objectmancy/errors.rb

@@ -0,0 +1,21 @@
+module Objectmancy
+  # Error for defining attributes with the same name
+  class AttributeAlreadyDefinedError < StandardError
+    attr_reader :attribute
+
+    # Creates a new AttributeAlreadyDefinedError
+    #
+    # @param attribute [#to_s] name of the attribute in error
+    def initialize(attribute)
+      @attribute = attribute
+    end
+
+    # Message for logging
+    #
+    # @return [String] message containing the attribute name
+    #   explaining the error.
+    def message
+      "#{attribute} has already been defined."
+    end
+  end
+end

data/lib/objectmancy/objectable.rb

@@ -0,0 +1,177 @@
+require 'objectmancy/errors'
+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
+  #
+  #     attribute :name
+  #   end
+  #
+  #   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
+    end
+
+    # Creates your object. You should use the after_initialize
+    #
+    # @param attrs [Hash] Hash of attributes to create the object with
+    def initialize(attrs = {})
+      before_initialize
+
+      _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
+
+      after_initialize
+    end
+
+    private
+
+    # Empty before_initialize callback
+    def before_initialize; end
+
+    # Empty after_initialize callback
+    def after_initialize; end
+
+    # Determines which attributes are assignable
+    #
+    # @param attrs [Hash] Provided base hash
+    # @return [Hash] Allowed attributes
+    def _assignable_attributes(attrs)
+      attrs.select { |k, _| self.class.registered_attributes.include? k.to_sym }
+    end
+
+    # Assigns a multiples attribute
+    #
+    # @param multiples [Array] Array of values to be converted
+    # @param type [Symbol, Class] Type of object to create
+    # @param creator [#to_s, nil] Method used to create the object
+    # @return [Array] Array of newly created objects
+    def _convert_multiples(multiples, type, creator)
+      creation_klass, creation_method = _creation_method(type, creator)
+
+      multiples.map { |m| creation_klass.send(creation_method, m) }
+    end
+
+    # Evaluates what needs to be done for a singular value.
+    #
+    # @param value [Object] Value to be assigned/evaluated.
+    # @param options [AttributeOptions] Options pertaining to the attribute
+    # @return [Object] Value for the new object
+    def _single_value(value, options)
+      return value unless options.type
+
+      _convert_value(value, options.type, options.objectable)
+    end
+
+    # Handles object creation of arbitrary types
+    #
+    # @param old_value [Object] Value to be converted
+    # @param type [Symbol, Class] Type of object to create
+    # @param creator [#to_s, nil] Method used to create the object
+    # @return [Object] The newly created object
+    def _convert_value(old_value, type, creator)
+      creation_klass, creation_method = _creation_method(type, creator)
+
+      creation_klass.send(creation_method, old_value)
+    end
+
+    # Determines the method of creation for a custom object
+    #
+    # @param type [Symbol, Class] Type of object to create
+    # @param creator [#to_s, nil] Method used to create the object
+    # @return [Array] Class to create, method to call.
+    def _creation_method(type, creator)
+      if (known = Types::SPECIAL_TYPES[type])
+        [known[:klass], known[:objectable]]
+      else
+        [type, (creator || :new)]
+      end
+    end
+  end
+end

data/lib/objectmancy/types.rb

@@ -0,0 +1,14 @@
+require 'iso8601'
+
+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
+
+    # Known types with special behavior defined.
+    SPECIAL_TYPES = {
+      datetime: DATETIME
+    }.freeze
+  end
+end

data/lib/objectmancy/version.rb

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

data/lib/objectmancy.rb

@@ -0,0 +1,6 @@
+require 'objectmancy/objectable'
+
+# Namespace for all Objectmancy functionality
+# Also serves as a mixin to include Objectable
+module Objectmancy
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: objectmancy
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jon Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: iso8601
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.43'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.43'
+- !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: minitest
+  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'
+description: Set of extensions used to convert a hash to an object.
+email:
+- jon1992@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/objectmancy.rb
+- lib/objectmancy/attribute_options.rb
+- lib/objectmancy/errors.rb
+- lib/objectmancy/objectable.rb
+- lib/objectmancy/types.rb
+- lib/objectmancy/version.rb
+homepage: https://github.com/jon2992/objectmancy
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Set of extensions used to convert a hash to an object.
+test_files: []