modelish 0.3.0 → 1.0.0.pre.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ebd460629d89807f4466c496083fd9a0a7be54d5
+  data.tar.gz: 667ce55093567f11e2d0c4a5f108828d5c3808fa
+SHA512:
+  metadata.gz: 7414d42602a180112990808d9ce895ad9da82ba6dc19dc9dc69d6967286b986260ae8d9ba8bfaa4c5842d508fc12fdfb902c56567e72ae4f8a1019afc81e137d
+  data.tar.gz: ac6d7d3831e1854da332e0d6b14e0b2358f17e0a6e4baa0d1b326e995c5afc51ab76e7c257a38389673bb554692ee0600b32cd1610b9abcd48a0ea1dacd9090f

data/.gitignore

@@ -1,8 +1,10 @@
 *.gem
 .bundle
 Gemfile.lock
+gemfiles/*.gemfile.lock
 pkg/*
 .yardoc/*
 doc/*
 *~
 .DS_Store
+coverage

data/.rspec

@@ -1 +1,3 @@
---colour
+--color
+--format Fuubar
+--require spec_helper

data/.ruby-version

@@ -1 +1 @@
-ruby-1.8.7-p374
+2.3.4

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.2.7
+  - 2.3.4
+  - 2.4.1
+gemfile:
+  - gemfiles/hashie_1.gemfile
+  - gemfiles/hashie_2.gemfile
+  - gemfiles/hashie_3.gemfile
+before_install:
+  - gem install bundler
+script:
+  - bundle exec rspec spec

data/Appraisals

@@ -0,0 +1,11 @@
+appraise 'hashie-1' do
+  gem 'hashie', '~> 1.0'
+end
+
+appraise 'hashie-2' do
+  gem 'hashie', '~> 2.0'
+end
+
+appraise 'hashie-3' do
+  gem 'hashie', '~> 3.0'
+end

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # CHANGELOG
 
+## 1.0.0.pre.1 (2017-06-11)
+
+* **Backwards incompatible change**: dropped support for ruby 1.8.7
+* Relax dependency on hashie to >= 1.0
+* Add support for ruby 2.3 and 2.4
+* General cleanup in dev and CI environments
+
+## 0.4.0 (2017-06-08)
+
+* **yanked** on 2017-06-11 because it broke compatibility with ruby 1.8.7
+
 ## 0.3.0 (2013-7-8)
 
 * Upgrade hashie dependency to v2.0.x

data/Gemfile

@@ -1,4 +1,8 @@
-source "http://rubygems.org"
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
 
 # Specify your gem's dependencies in modelish.gemspec
 gemspec
+
+gem 'hashie', '~> 3.0'

data/README.md

@@ -3,6 +3,11 @@
 When a real modeling framework is too heavy, sometimes you want something just 
 a little modelish.
 
+**IMPORTANT NOTE**: modelish is considered legacy code at this point.
+Maintenance will continue for bug fixes, but active development has ceased.
+For new projects that require lightweight models, try looking at something like
+[virtus](https://github.com/solnic/virtus) instead.
+
 ## Overview ##
 
 If a Hash or OpenStruct almost suits your needs, but you need bits of 

data/gemfiles/hashie_1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "hashie", "~> 1.0"
+
+gemspec path: "../"

data/gemfiles/hashie_2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "hashie", "~> 2.0"
+
+gemspec path: "../"

data/gemfiles/hashie_3.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "hashie", "~> 3.0"
+
+gemspec path: "../"

data/lib/modelish/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'hashie'
 require 'modelish/property_translations'
 require 'modelish/property_types'
@@ -5,69 +7,18 @@ require 'modelish/validations'
 require 'modelish/configuration'
 
 module Modelish
+  # Base class for all modelish objects
   class Base < Hashie::Dash
     include PropertyTranslations
     include PropertyTypes
     include Validations
     extend Configuration
 
-    def initialize(options={}, &block)
+    def initialize(options = {}, &block)
       super(&block)
 
       attributes = options ? options.dup : {}
-
-      attributes.delete_if do |k,v|
-        if self.class.translations.keys.include?(k.to_sym)
-          self[k]=v
-          true
-        end
-      end
-
-      attributes.each_pair do |att, value|
-        self[att] = value
-      end
-    end
-
-    # Creates a new attribute.
-    #
-    # @param [Symbol] name the name of the property
-    # @param [Hash] options configuration for the property
-    # @option opts [Object] :default the default value for this property
-    #                                when the value has not been explicitly
-    #                                set (defaults to nil)
-    # @option opts [#to_s] :from the original key name for this attribute
-    #                            (created as write-only)
-    # @option opts [Class,Proc] :type the type of the property value. For
-    #                                 a list of accepted types, see
-    #                                 {Modelish::PropertyTypes}
-    # @option opts [true,false] :required enables validation for the property
-    #                                      value's presence; nil or blank values
-    #                                      will cause validation methods to fail
-    # @option opts [Integer] :max_length the maximum allowable length for a valid
-    #                                     property value
-    # @option opts [true,false] :validate_type enables validation for the property value's
-    #                                           type based on the :type option
-    # @option opts [Proc] :validator A block that accepts a value and validates it;
-    #                                 should return nil if validation passes, or an error
-    #                                 message or error object if validation fails.
-    #                                 See {Modelish::Validations}
-    def self.property(name, options={})
-
-      #Hashie::Dash.property is going to delete :required from the options hash
-      required = options[:required]
-
-      super
-
-      add_property_type(name, options[:type]) if options[:type]
-      add_property_translation(options[:from], name) if options[:from]
-
-      if options[:required] || (self.respond_to?(:required?) && required?(name))
-        add_validator(name) { |val| validate_required(name => val).first }
-      end
-
-      add_validator(name) { |val| validate_length(name, val, options[:max_length]) } if options[:max_length]
-      add_validator(name, &options[:validator]) if options[:validator]
-      add_validator(name) { |val| validate_type(name, val, options[:type]) } if options[:validate_type]
+      init_attributes(attributes)
     end
 
     # Convert this Modelish object into a vanilla Hash with stringified keys.
@@ -75,15 +26,7 @@ module Modelish
     # @return [Hash] the hash of properties
     def to_hash
       out = {}
-      self.class.properties.each do |p|
-        val = self.send(p)
-        if val.is_a?(Array)
-          out[p.to_s]||=[]
-          out[p.to_s].concat(val.collect{|x|x.respond_to?(:to_hash) ? x.to_hash : x})
-        else
-          out[p.to_s] = val.respond_to?(:to_hash) ? val.to_hash : val
-        end
-      end
+      self.class.properties.each { |p| out[hash_key(p)] = hash_value(p) }
       out
     end
 
@@ -96,27 +39,120 @@ module Modelish
     end
 
     private
+
+    def init_attributes(attributes)
+      attributes.delete_if do |k, v|
+        if self.class.translations.keys.include?(k.to_sym)
+          self[k] = v
+          true
+        end
+      end
+
+      attributes.each_pair do |att, value|
+        self[att] = value
+      end
+    end
+
     def property_exists?(property)
       if self.class.property?(property.to_sym)
         true
-      elsif self.class.ignore_unknown_properties || 
-            (self.class.ignore_unknown_properties.nil? && Modelish.ignore_unknown_properties)
+      elsif self.class.ignore_unknown_properties ||
+            (self.class.ignore_unknown_properties.nil? &&
+             Modelish.ignore_unknown_properties)
         false
       else
-        raise NoMethodError, "The property '#{property}' is not defined for this Modelish object."
+        raise NoMethodError, "The property '#{property}' is not defined for " \
+                             'this Modelish object.'
       end
     end
 
-    def assert_required_properties_set!
-      nil
-    end
+    # Disable the various ways that hashie tries to assert required properties
+    # are set on initialization (modelish defers this until validation)
+    def assert_required_properties_set!; end
 
-    def assert_property_required!(property,value)
-      nil
-    end
+    def assert_property_required!(_property, _value); end
+
+    def assert_required_attributes_set!; end
 
     def assert_property_exists!(property)
       property_exists?(property)
     end
+
+    def hash_key(property)
+      property.to_s
+    end
+
+    def hash_value(property)
+      val = send(property)
+
+      if val.is_a?(Array)
+        val.map { |x| x.respond_to?(:to_hash) ? x.to_hash : x }
+      else
+        val.respond_to?(:to_hash) ? val.to_hash : val
+      end
+    end
+
+    class << self
+      # Creates a new attribute.
+      #
+      # @param [Symbol] name the name of the property
+      # @param [Hash] options configuration for the property
+      # @option opts [Object] :default the default value for this property
+      #                                when the value has not been explicitly
+      #                                set (defaults to nil)
+      # @option opts [#to_s] :from the original key name for this attribute
+      #                            (created as write-only)
+      # @option opts [Class,Proc] :type the type of the property value. For
+      #                                 a list of accepted types, see
+      #                                 {Modelish::PropertyTypes}
+      # @option opts [true,false] :required enables validation for the property
+      #                                      value's presence; nil or blank
+      #                                      will cause validation to fail
+      # @option opts [Integer] :max_length the maximum allowable length for a
+      #                                     valid property value
+      # @option opts [true,false] :validate_type enables validation for the
+      #                                           property value's type based on
+      #                                           the :type option
+      # @option opts [Proc] :validator A block that validates a value;
+      #                                 returns nil if validation passes, or an
+      #                                 error message or error object if
+      #                                 validation fails.
+      #                                 See {Modelish::Validations}
+      def property(name, options = {})
+        # Hashie::Dash.property deletes the :required key from the options
+        required = options[:required]
+        super
+
+        add_property_type(name, options[:type]) if options[:type]
+        add_property_translation(options[:from], name) if options[:from]
+
+        process_required(name) if required
+        process_max_length(name, options)
+        process_validate_type(name, options)
+
+        add_validator(name, &options[:validator]) if options[:validator]
+      end
+
+      private
+
+      def process_required(name)
+        return unless respond_to?(:required?) && required?(name)
+        add_validator(name) { |val| validate_required(name => val).first }
+      end
+
+      def process_max_length(name, options)
+        return unless options[:max_length]
+        add_validator(name) do |val|
+          validate_length(name, val, options[:max_length])
+        end
+      end
+
+      def process_validate_type(name, options)
+        return unless options[:validate_type]
+        add_validator(name) do |val|
+          validate_type(name, val, options[:type])
+        end
+      end
+    end
   end
 end

data/lib/modelish/configuration.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 module Modelish
+  # Configure modelish's behavior on a global level
   module Configuration
     # If true, ignore unknown property names when initializing new models;
     # otherwise, raise an error when an unknown property is encountered.
     # Defaults to false.
     attr_accessor :ignore_unknown_properties
 
-    # When set, unknown property names will be ignored during modelish initialization
+    # When set, unknown property names will be ignored during initialization
     # and property setting.
     #
     # @see {raise_errors_on_unknown_properties!}
@@ -13,15 +16,16 @@ module Modelish
       self.ignore_unknown_properties = true
     end
 
-    # When set, unknown property names will cause errors to be raised when encountered
-    # during modelish initialization and property setting. This is the default behavior.
+    # When set, raise errors during initializeation and property setting when
+    # unknown property names are encountered. This is the default.
     #
     # @see {ignore_unknown_properties!}
     def raise_errors_on_unknown_properties!
       self.ignore_unknown_properties = false
     end
 
-    # When this module is extended, set all configuration options to their default values
+    # When this module is extended, set all configuration options to their
+    # default values
     def self.extended(base)
       base.reset
     end
@@ -35,10 +39,7 @@ module Modelish
     #     config.ignore_unknown_properties = true
     #   end
     def configure
-      if block_given?
-        yield self
-      end
-
+      yield self if block_given?
       self
     end
 

data/lib/modelish/property_translations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Modelish
   # Mixin behavior for mapping one property name to another
   module PropertyTranslations
@@ -5,6 +7,7 @@ module Modelish
       base.extend(ClassMethods)
     end
 
+    # Methods for managing a dictionary of property translations
     module ClassMethods
       # Adds a property translation to the model.
       # This maps a mutator name to an existing property,
@@ -58,24 +61,33 @@ module Modelish
       # @param [Symbol,String] from_name the name of the source property
       # @param [Symbol,String] to_name the name of the destination property
       def add_property_translation(from_name, to_name)
-        self.translations[from_name.to_sym] ||= []
-        self.translations[from_name.to_sym] << to_name.to_sym
+        source = from_name.to_sym
+        target = to_name.to_sym
 
-        class_eval do
-          define_method("#{from_name}=") do |value|
-            self.class.translations[from_name.to_sym].each do |prop|
-              self.send("#{prop}=", value)
-            end
-          end
-        end
+        translations[source] ||= []
+        translations[source] << target
+        define_writer_with_translations(source)
       end
 
-      # A map of the translations that have already been configured, keyed on from_name.
+      # A map of the configured property translations, keyed on from_name
       #
-      # @return [Hash<Symbol,Array>] the key is the from_name, the value is an array to_names
+      # @return [Hash<Symbol,Array>] key is from_name, value is list of to_names
       def translations
         @translations ||= {}
       end
+
+      private
+
+      def define_writer_with_translations(source)
+        class_eval do
+          remove_method("#{source}=") if method_defined?("#{source}=")
+          define_method("#{source}=") do |value|
+            self.class.translations[source].each do |target|
+              send("#{target}=", value)
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/modelish/property_types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 
 module Modelish
@@ -7,21 +9,24 @@ module Modelish
       base.extend(ClassMethods)
     end
 
+    # Class methods for managing typed properties
     module ClassMethods
       # Adds a typed property to the model.
       # This dynamically generates accessor/mutator methods that perform
       # the appropriate type conversions on the property's value.
-      # 
+      #
       # Generated methods:
-      # * +<property_name>=(new_value)+ -- sets the property value. 
-      # * +<property_name>+ -- returns the property value, converted to the configured
-      #                        type. If the value cannot be converted, no error will be
-      #                        raised, and the raw unconverted value will be returned.
-      # * +<property_name>!+ -- returns the property value, converted to the configured
-      #                         type. If the value cannot be converted, a TypeError will
-      #                         be raised.
-      # * +raw_<property_name> -- the original property value, without any type conversions.
-      # 
+      # * +<property_name>=(new_value)+ -- sets the property value.
+      # * +<property_name>+ -- returns the property value, converted to the
+      #                        configured type. If the value cannot be
+      #                        converted, no error will be raised, and the raw
+      #                        unconverted value will be returned.
+      # * +<property_name>!+ -- returns the property value, converted to the
+      #                         configured type. If the value cannot be
+      #                         converted, a TypeError will be raised.
+      # * +raw_<property_name> -- the original property value, without any type
+      #                           conversions.
+      #
       # @param [Symbol] property_name the name of the property.
       # @param [Class, Proc] property_type the type of the property's value.
       #                                    Valid types include:
@@ -34,49 +39,57 @@ module Modelish
       #   * +String+
       #   * any arbitrary +Class+ -- will attempt conversion by passing the raw
       #                              value into the class's initializer
-      #   * an instance of +Proc+ -- will convert the value by executing the proc,
-      #                              passing in the raw value as an argument
-      def add_property_type(property_name, property_type=String)
+      #   * an instance of +Proc+ -- will convert the value by executing the
+      #                              proc, passing in the raw value
+      def add_property_type(property_name, property_type = String)
         accessor = property_name.to_sym
+        return if property_types[accessor] == property_type
 
-        # TODO: Refactor. This method is getting unwieldy as more 
+        # TODO: Refactor. This method is getting unwieldy as more
         # corner cases are discovered. A few well-placed design
         # refinements should take care of it (now we just need to figure
         # out what those are.)
-        unless property_types[accessor] == property_type
-          property_types[accessor] = property_type
-
-          raw_accessor = define_raw_accessor(accessor)
-          bang_accessor = define_bang_accessor(accessor)
+        property_types[accessor] = property_type
 
-          typed_accessor = "_typed_#{accessor}".to_sym
-          typed_mutator = "#{typed_accessor}=".to_sym
-          to_safe = "_to_safe_#{accessor}".to_sym
+        raw_accessor = define_raw_accessor(accessor)
+        bang_accessor = define_bang_accessor(accessor)
 
-          class_eval do
-            attr_accessor typed_accessor
-            private typed_accessor, typed_mutator
+        typed_accessor = "_typed_#{accessor}".to_sym
+        typed_mutator = "#{typed_accessor}=".to_sym
+        to_safe = "_to_safe_#{accessor}".to_sym
 
-            define_method(to_safe) do
-              self.send(bang_accessor) rescue self.send(raw_accessor)
+        class_eval do
+          remove_method(typed_accessor) if method_defined?(typed_accessor)
+          remove_method(typed_mutator) if method_defined?(typed_mutator)
+          attr_accessor typed_accessor
+          protected typed_accessor, typed_mutator
+
+          remove_method(to_safe) if method_defined?(to_safe)
+          define_method(to_safe) do
+            begin
+              send(bang_accessor)
+            rescue
+              send(raw_accessor)
             end
-            private to_safe
-
-            define_method(accessor) do
-              val = self.send(typed_accessor)
+          end
+          protected to_safe
 
-              unless val || self.send(raw_accessor).nil?
-                val = self.send(to_safe)
-                self.send(typed_mutator, val)
-              end
+          remove_method(accessor) if method_defined?(accessor)
+          define_method(accessor) do
+            val = send(typed_accessor)
 
-              val
+            unless val || send(raw_accessor).nil?
+              val = send(to_safe)
+              send(typed_mutator, val)
             end
 
-            define_method("#{accessor}=") do |val|
-              self.send("#{raw_accessor}=", val)
-              self.send(typed_mutator, self.send(to_safe))
-            end
+            val
+          end
+
+          remove_method("#{accessor}=") if method_defined?("#{accessor}=")
+          define_method("#{accessor}=") do |val|
+            send("#{raw_accessor}=", val)
+            send(typed_mutator, send(to_safe))
           end
         end
       end
@@ -86,6 +99,7 @@ module Modelish
       end
 
       private
+
       def define_raw_accessor(name)
         accessor = name.to_sym
         raw_accessor = "raw_#{name}".to_sym
@@ -112,9 +126,10 @@ module Modelish
         converter = value_converter(property_types[property_name.to_sym])
 
         class_eval do
+          remove_method(bang_accessor) if method_defined?(bang_accessor)
           define_method(bang_accessor) do
-            value = self.send("raw_#{property_name}")
-            (converter && value) ? converter.call(value) : value
+            value = send("raw_#{property_name}")
+            converter && value ? converter.call(value) : value
           end
         end
 
@@ -123,19 +138,21 @@ module Modelish
 
       def value_converter(property_type)
         if [Date, DateTime].include?(property_type)
-          lambda { |val| property_type.parse(val.to_s) }
+          ->(val) { property_type.parse(val.to_s) }
         elsif property_type == Symbol
-          lambda { |val| val.to_s.strip.gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2').
-                                          gsub(/([a-z\d])([A-Z])/, '\\1_\\2').
-                                          gsub(/\s+|-/,'_').downcase.to_sym }
+          lambda do |val|
+            val.to_s.strip.gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2')
+               .gsub(/([a-z\d])([A-Z])/, '\\1_\\2')
+               .gsub(/\s+|-/, '_').downcase.to_sym
+          end
         elsif property_type == String
-          lambda { |val| val.to_s.strip }
-        elsif Kernel.respond_to?(property_type.to_s) 
-          lambda { |val| Kernel.send(property_type.to_s, val) }
+          ->(val) { val.to_s.strip }
+        elsif Kernel.respond_to?(property_type.to_s)
+          ->(val) { Kernel.send(property_type.to_s, val) }
         elsif property_type.respond_to?(:call)
           property_type
         else
-          lambda { |val| property_type.new(val) }
+          ->(val) { property_type.new(val) }
         end
       end
     end