options_model 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bbc86cf05d36942bfaedc8e5110ffde4560dec33
-  data.tar.gz: 51d723a133527412281c1751da1269cff2e6eb13
+  metadata.gz: 68ef05d17124810d0f70c7c6f08e996045d455dd
+  data.tar.gz: 4b0511272bf4303dff6a6ae0b87d149e3074cee4
 SHA512:
-  metadata.gz: 349f91af8fe2bdc272af7fd56ba0f307a798e9bfc14b13c28216ea0ca5c07551cc6fecba7f130171e61328c84352c9415cdcd66a897b3eed276d6f4834d39b9c
-  data.tar.gz: 41fb67f98b8ca797a0a7d97985694eceadbc419dd03db1141cecf07643efd81eb9227c4e6530d8890f53ffde9a93390f015082725987e90d30a92b3a31af5349
+  metadata.gz: 17ce123c0378e081b1c49298b4666f357677b77d1bd8d7faf431bef6bcbe38516aabbdc31c35982c6f6e26265d1bb4e7288d5ffd30e5bddb98a419dea0bcc11a
+  data.tar.gz: c487d6352c9a9d749aa3d5165776398733af9e44f05cf406169765158edde4f272953271549db831cf559ca83a18d51fe170a72e54d9b87afa15f1708073257a

data/lib/options_model/concerns/attribute_assignment.rb

@@ -1,77 +1,79 @@
-module OptionsModel::Concerns
-  module AttributeAssignment
-    extend ActiveSupport::Concern
+module OptionsModel
+  module Concerns
+    module AttributeAssignment
+      extend ActiveSupport::Concern
 
-    def initialize(attributes = {})
-      update_attributes(attributes)
-    end
+      def initialize(attributes = {})
+        update_attributes(attributes)
+      end
 
-    def initialize_dup(other)
-      super
+      def initialize_dup(other)
+        super
 
-      update_attributes(other)
-    end
+        update_attributes(other)
+      end
 
-    def update_attributes(other)
-      return unless other
+      def update_attributes(other)
+        return unless other
 
-      unless other.respond_to?(:to_h)
-        raise ArgumentError, "#{other} must be respond to `to_h`"
-      end
+        unless other.respond_to?(:to_h)
+          raise ArgumentError, "#{other} must be respond to `to_h`"
+        end
 
-      other.to_h.each do |k, v|
-        if respond_to?("#{k}=")
-          public_send("#{k}=", v)
-        else
-          unused_attributes[k] = v
+        other.to_h.each do |k, v|
+          if respond_to?("#{k}=")
+            public_send("#{k}=", v)
+          else
+            unused_attributes[k] = v
+          end
         end
       end
-    end
 
-    def [](key)
-      public_send(key) if respond_to?(key)
-    end
-
-    def []=(key, val)
-      setter = "#{key}="
-      if respond_to?(setter)
-        public_send(setter, val)
-      else
-        unused_attributes[key] = val
+      def [](key)
+        public_send(key) if respond_to?(key)
       end
-    end
 
-    def fetch(key, default = nil)
-      if self.class.attribute_names.exclude?(key.to_sym) && default.nil? && !block_given?
-        raise KeyError, "attribute not found"
+      def []=(key, val)
+        setter = "#{key}="
+        if respond_to?(setter)
+          public_send(setter, val)
+        else
+          unused_attributes[key] = val
+        end
       end
 
-      value = respond_to?(key) ? public_send(key) : nil
-      return value if value
+      def fetch(key, default = nil)
+        if self.class.attribute_names.exclude?(key.to_sym) && default.nil? && !block_given?
+          raise KeyError, "attribute not found"
+        end
+
+        value = respond_to?(key) ? public_send(key) : nil
+        return value if value
 
-      if default
-        default
-      elsif block_given?
-        yield
+        if default
+          default
+        elsif block_given?
+          yield
+        end
       end
-    end
 
-    def _attributes
-      @attributes ||= ActiveSupport::HashWithIndifferentAccess.new
-    end
-    private :_attributes
-    alias_method :attributes, :_attributes
+      def _attributes
+        @attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+      private :_attributes
+      alias_method :attributes, :_attributes
 
-    def _nested_attributes
-      @nested_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
-    end
-    private :_nested_attributes
-    alias_method :nested_attributes, :_nested_attributes
+      def _nested_attributes
+        @nested_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+      private :_nested_attributes
+      alias_method :nested_attributes, :_nested_attributes
 
-    def _unused_attributes
-      @unused_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      def _unused_attributes
+        @unused_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+      private :_unused_attributes
+      alias_method :unused_attributes, :_unused_attributes
     end
-    private :_unused_attributes
-    alias_method :unused_attributes, :_unused_attributes
   end
 end

data/lib/options_model/concerns/attributes.rb

@@ -1,30 +1,31 @@
-module OptionsModel::Concerns
-  module Attributes
-    extend ActiveSupport::Concern
+module OptionsModel
+  module Concerns
+    module Attributes
+      extend ActiveSupport::Concern
 
-    module ClassMethods
-      def attribute(name, cast_type, default: nil, array: false)
-        check_not_finalized!
+      module ClassMethods
+        def attribute(name, cast_type, default: nil, array: false)
+          check_not_finalized!
 
-        name = name.to_sym
-        check_name_validity! name
+          name = name.to_sym
+          check_name_validity! name
 
-        ActiveModel::Type.lookup(cast_type)
+          ActiveModel::Type.lookup(cast_type)
 
-        attribute_defaults[name] = default
+          attribute_defaults[name] = default
 
-        generated_attribute_methods.synchronize do
-          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+          generated_attribute_methods.synchronize do
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
             def #{name}
               value = attributes[:#{name}]
               return value unless value.nil?
               attributes[:#{name}] = self.class.attribute_defaults[:#{name}].#{default.respond_to?(:call) ? "call" : "dup"}
               attributes[:#{name}]
             end
-          STR
+            STR
 
-          if array
-            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            if array
+              generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
               def #{name}=(value)
                 if value.respond_to?(:to_a)
                   attributes[:#{name}] = value.to_a.map { |i| ActiveModel::Type.lookup(:#{cast_type}).cast(i) }
@@ -35,70 +36,70 @@ module OptionsModel::Concerns
                         "`value` should respond to `to_a`, but got \#{value.class} -- \#{value.inspect}"
                 end
               end
-            STR
-          else
-            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+              STR
+            else
+              generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
               def #{name}=(value)
                 attributes[:#{name}] = ActiveModel::Type.lookup(:#{cast_type}).cast(value)
               end
-            STR
+              STR
 
-            if cast_type == :boolean
-              generated_attribute_methods.send :alias_method, :"#{name}?", name
+              if cast_type == :boolean
+                generated_attribute_methods.send :alias_method, :"#{name}?", name
+              end
             end
           end
-        end
 
-        self.attribute_names_for_inlining << name
-        name
-      end
+          self.attribute_names_for_inlining << name
+          name
+        end
 
-      def enum_attribute(name, enum, default: nil, allow_nil: false)
-        check_not_finalized!
+        def enum_attribute(name, enum, default: nil, allow_nil: false)
+          check_not_finalized!
 
-        unless enum.is_a?(Array) && enum.any?
-          raise ArgumentError, "enum should be an Array and can't empty"
-        end
-        enum = enum.map(&:to_s)
+          unless enum.is_a?(Array) && enum.any?
+            raise ArgumentError, "enum should be an Array and can't empty"
+          end
+          enum = enum.map(&:to_s)
 
-        attribute name, :string, default: default
+          attribute name, :string, default: default
 
-        pluralized_name = name.to_s.pluralize
-        generated_class_methods.synchronize do
-          generated_class_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+          pluralized_name = name.to_s.pluralize
+          generated_class_methods.synchronize do
+            generated_class_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
             def #{pluralized_name}
               %w(#{enum.join(" ")}).freeze
             end
-          STR
+            STR
 
-          validates name, inclusion: {in: enum}, allow_nil: allow_nil
+            validates name, inclusion: {in: enum}, allow_nil: allow_nil
+          end
         end
-      end
 
-      def embeds_one(name, class_name: nil, anonymous_class: nil)
-        check_not_finalized!
+        def embeds_one(name, class_name: nil, anonymous_class: nil)
+          check_not_finalized!
 
-        if class_name.blank? && anonymous_class.nil?
-          raise ArgumentError, "must provide at least one of `class_name` or `anonymous_class`"
-        end
+          if class_name.blank? && anonymous_class.nil?
+            raise ArgumentError, "must provide at least one of `class_name` or `anonymous_class`"
+          end
 
-        name = name.to_sym
-        check_name_validity! name
+          name = name.to_sym
+          check_name_validity! name
 
-        if class_name.present?
-          nested_classes[name] = class_name.constantize
-        else
-          nested_classes[name] = anonymous_class
-        end
+          if class_name.present?
+            nested_classes[name] = class_name.constantize
+          else
+            nested_classes[name] = anonymous_class
+          end
 
-        generated_attribute_methods.synchronize do
-          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+          generated_attribute_methods.synchronize do
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
             def #{name}
               nested_attributes[:#{name}] ||= self.class.nested_classes[:#{name}].new(attributes[:#{name}])
             end
-          STR
+            STR
 
-          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
             def #{name}=(value)
               klass = self.class.nested_classes[:#{name}]
               if value.respond_to?(:to_h)
@@ -112,91 +113,92 @@ module OptionsModel::Concerns
                       "`value` should respond to `to_h` or \#{klass}, but got \#{value.class}"
               end
             end
-          STR
+            STR
+          end
+
+          self.attribute_names_for_nesting << name
+          name
         end
 
-        self.attribute_names_for_nesting << name
-        name
-      end
+        def attribute_defaults
+          @attribute_defaults ||= ActiveSupport::HashWithIndifferentAccess.new
+        end
 
-      def attribute_defaults
-        @attribute_defaults ||= ActiveSupport::HashWithIndifferentAccess.new
-      end
+        def nested_classes
+          @nested_classes ||= ActiveSupport::HashWithIndifferentAccess.new
+        end
 
-      def nested_classes
-        @nested_classes ||= ActiveSupport::HashWithIndifferentAccess.new
-      end
+        def attribute_names_for_nesting
+          @attribute_names_for_nesting ||= Set.new
+        end
 
-      def attribute_names_for_nesting
-        @attribute_names_for_nesting ||= Set.new
-      end
+        def attribute_names_for_inlining
+          @attribute_names_for_inlining ||= Set.new
+        end
 
-      def attribute_names_for_inlining
-        @attribute_names_for_inlining ||= Set.new
-      end
+        def attribute_names
+          attribute_names_for_nesting + attribute_names_for_inlining
+        end
 
-      def attribute_names
-        attribute_names_for_nesting + attribute_names_for_inlining
-      end
+        def finalized?
+          @finalized ||= false
+        end
 
-      def finalized?
-        @finalized ||= false
-      end
+        def finalize!(nested = true)
+          if nested
+            nested_classes.values.each &:finalize!
+          end
 
-      def finalize!(nested = true)
-        if nested
-          nested_classes.values.each &:finalize!
+          @finalized = true
         end
 
-        @finalized = true
-      end
+        protected
 
-      protected
+        def check_name_validity!(symbolized_name)
+          if dangerous_attribute_method?(symbolized_name)
+            raise ArgumentError, "#{symbolized_name} is defined by #{OptionsModel::Base}. Check to make sure that you don't have an attribute or method with the same name."
+          end
 
-      def check_name_validity!(symbolized_name)
-        if dangerous_attribute_method?(symbolized_name)
-          raise ArgumentError, "#{symbolized_name} is defined by #{OptionsModel::Base}. Check to make sure that you don't have an attribute or method with the same name."
+          if attribute_names_for_inlining.include?(symbolized_name) || attribute_names_for_nesting.include?(symbolized_name)
+            raise ArgumentError, "duplicate define attribute `#{symbolized_name}`"
+          end
         end
 
-        if attribute_names_for_inlining.include?(symbolized_name) || attribute_names_for_nesting.include?(symbolized_name)
-          raise ArgumentError, "duplicate define attribute `#{symbolized_name}`"
+        def check_not_finalized!
+          if finalized?
+            raise "can't modify finalized #{self}"
+          end
         end
-      end
 
-      def check_not_finalized!
-        if finalized?
-          raise "can't modify finalized #{self}"
+        # A method name is 'dangerous' if it is already (re)defined by OptionsModel, but
+        # not by any ancestors. (So 'puts' is not dangerous but 'save' is.)
+        def dangerous_attribute_method?(name) # :nodoc:
+          method_defined_within?(name, OptionsModel::Base)
         end
-      end
 
-      # A method name is 'dangerous' if it is already (re)defined by OptionsModel, but
-      # not by any ancestors. (So 'puts' is not dangerous but 'save' is.)
-      def dangerous_attribute_method?(name) # :nodoc:
-        method_defined_within?(name, OptionsModel::Base)
-      end
-
-      def method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
-        if klass.method_defined?(name) || klass.private_method_defined?(name)
-          if superklass.method_defined?(name) || superklass.private_method_defined?(name)
-            klass.instance_method(name).owner != superklass.instance_method(name).owner
+        def method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
+          if klass.method_defined?(name) || klass.private_method_defined?(name)
+            if superklass.method_defined?(name) || superklass.private_method_defined?(name)
+              klass.instance_method(name).owner != superklass.instance_method(name).owner
+            else
+              true
+            end
           else
-            true
+            false
           end
-        else
-          false
         end
-      end
 
-      def generated_attribute_methods
-        @generated_attribute_methods ||= Module.new {
-          extend Mutex_m
-        }.tap { |mod| include mod }
-      end
+        def generated_attribute_methods
+          @generated_attribute_methods ||= Module.new {
+            extend Mutex_m
+          }.tap { |mod| include mod }
+        end
 
-      def generated_class_methods
-        @generated_class_methods ||= Module.new {
-          extend Mutex_m
-        }.tap { |mod| extend mod }
+        def generated_class_methods
+          @generated_class_methods ||= Module.new {
+            extend Mutex_m
+          }.tap { |mod| extend mod }
+        end
       end
     end
   end

data/lib/options_model/concerns/name_hacking.rb

@@ -1,18 +1,20 @@
-module OptionsModel::Concerns
-  module NameHacking
-    extend ActiveSupport::Concern
+module OptionsModel
+  module Concerns
+    module NameHacking
+      extend ActiveSupport::Concern
 
-    module ClassMethods
-      def name
-        @_name
-      end
-
-      def name=(value)
-        unless /^[A-Z][a-zA-Z_0-9]*$/ =~ value
-          raise ArgumentError, "`name` must a valid class name"
+      module ClassMethods
+        def name
+          @_name
         end
 
-        @_name = value
+        def name=(value)
+          unless /^[A-Z][a-zA-Z_0-9]*$/ =~ value
+            raise ArgumentError, "`name` must a valid class name"
+          end
+
+          @_name = value
+        end
       end
     end
   end

data/lib/options_model/concerns/serialization.rb

@@ -1,50 +1,52 @@
-module OptionsModel::Concerns
-  module Serialization
-    extend ActiveSupport::Concern
-
-    def to_h
-      hash = {}
-
-      self.class.attribute_names.each do |attribute_name|
-        attribute = public_send(attribute_name)
-        if attribute.is_a?(OptionsModel::Base)
-          hash[attribute_name] = attribute.to_h
-        else
-          hash[attribute_name] = attribute
+module OptionsModel
+  module Concerns
+    module Serialization
+      extend ActiveSupport::Concern
+
+      def to_h
+        hash = {}
+
+        self.class.attribute_names.each do |attribute_name|
+          attribute = public_send(attribute_name)
+          if attribute.is_a?(OptionsModel::Base)
+            hash[attribute_name] = attribute.to_h
+          else
+            hash[attribute_name] = attribute
+          end
         end
+
+        hash
       end
 
-      hash
-    end
+      def to_h_with_unused
+        to_h.merge unused_attributes
+      end
 
-    def to_h_with_unused
-      to_h.merge unused_attributes
-    end
+      module ClassMethods
+        def dump(obj)
+          return YAML.dump({}) unless obj
 
-    module ClassMethods
-      def dump(obj)
-        return YAML.dump({}) unless obj
+          unless obj.is_a? self
+            raise ArgumentError,
+                  "can't dump: was supposed to be a #{self}, but was a #{obj.class}. -- #{obj.inspect}"
+          end
 
-        unless obj.is_a? self
-          raise ArgumentError,
-                "can't dump: was supposed to be a #{self}, but was a #{obj.class}. -- #{obj.inspect}"
+          YAML.dump obj.to_h
         end
 
-        YAML.dump obj.to_h
-      end
+        def load(yaml)
+          return new unless yaml
+          return new unless yaml.is_a?(String) && /^---/.match?(yaml)
 
-      def load(yaml)
-        return new unless yaml
-        return new unless yaml.is_a?(String) && /^---/.match?(yaml)
+          hash = YAML.load(yaml) || Hash.new
 
-        hash = YAML.load(yaml) || Hash.new
+          unless hash.is_a? Hash
+            raise ArgumentError,
+                  "can't load: was supposed to be a #{Hash}, but was a #{hash.class}. -- #{hash.inspect}"
+          end
 
-        unless hash.is_a? Hash
-          raise ArgumentError,
-                "can't load: was supposed to be a #{Hash}, but was a #{hash.class}. -- #{hash.inspect}"
+          new hash
         end
-
-        new hash
       end
     end
   end

data/lib/options_model/version.rb

@@ -1,3 +1,3 @@
 module OptionsModel
-  VERSION = "0.0.1".freeze
+  VERSION = "0.0.2".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: options_model
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - jasl