soulless 0.6.0 → 1.0.0

data/lib/soulless/inheritance.rb

@@ -1,139 +1,135 @@
 module Soulless
   module Inheritance
-    def self.included(base)
-     base.instance_eval do
-       def inherit_from(klass, options = {})
-         attributes = get_attributes(klass, options)
+    def inherit_from(klass, options = {})
+      attributes = get_attributes(klass, options)
 
-         attributes.each do |attribute|
-           self.attribute(attribute[:name], attribute[:primitive], attribute[:options])
-           if Object.const_defined?('ActiveModel'.to_sym) && klass.ancestors.include?(ActiveModel::Validations)
-             setup_validators(attribute[:name], klass, options)
-           end
-         end
-       end
+      attributes.each do |attribute|
+        self.attribute(attribute[:name], attribute[:primitive], attribute[:options])
+        if Object.const_defined?('ActiveModel'.to_sym) && klass.ancestors.include?(ActiveModel::Validations)
+          setup_validators(attribute[:name], klass, options)
+        end
+      end
+    end
 
-       private
-       def get_attributes(klass, options)
-         if klass.ancestors.include?(Virtus::Model::Core)
-           get_virtus_attributes(klass, options)
-         elsif Object.const_defined?('ActiveRecord'.to_sym) && klass.ancestors.include?(ActiveRecord::Base)
-           get_active_record_attributes(klass, options)
-         end
-       end
+    def get_attributes(klass, options)
+      if klass.ancestors.include?(Virtus::Model::Core)
+        get_virtus_attributes(klass, options)
+      elsif Object.const_defined?('ActiveRecord'.to_sym) && klass.ancestors.include?(ActiveRecord::Base)
+        get_active_record_attributes(klass, options)
+      end
+    end
 
-       def get_virtus_attributes(klass, options)
-         attributes = []
-         attribute_set = klass.attribute_set
-         attribute_names = get_attribute_names(attribute_set.map{ |a| a.options[:name] }, options)
-         attribute_names.each do |attribute_name|
-           attribute = attribute_set[attribute_name]
-           if include_attribute?(attribute_name, options)
-             attributes << {
-               name: attribute_name,
-               primitive: attribute.primitive,
-               options: {
-                 default: attribute.default_value
-               }
-             }
-           end
-         end
-         attributes
-       end
+    def get_virtus_attributes(klass, options)
+      attributes = []
+      attribute_set = klass.attribute_set
+      attribute_names = get_attribute_names(attribute_set.map{ |a| a.options[:name] }, options)
+      attribute_names.each do |attribute_name|
+        attribute = attribute_set[attribute_name]
+        if include_attribute?(attribute_name, options)
+          attributes << {
+            name: attribute_name,
+            primitive: attribute.primitive,
+            options: {
+              default: attribute.default_value
+            }
+          }
+        end
+      end
+      attributes
+    end
 
-       def get_active_record_attributes(klass, options)
-         attributes = []
-         attribute_names = get_attribute_names(klass.attribute_names.dup, options)
-         attribute_names.each do |attribute_name|
-           if include_attribute?(attribute_name, options)
-             column = klass.columns_hash[attribute_name.to_s]
-             attribute = {
-               name: attribute_name,
-               primitive: String,
-               options: {}
-             }
-             attribute[:primitive] = translate_primitive(column.type) if column
-             attribute[:options] = { default: column.default } if column &&
-                                                                  (options[:use_database_default] == true ||
-                                                                    options[:use_database_default] == attribute_name ||
-                                                                    (options[:use_database_default].kind_of?(Array) &&
-                                                                      options[:use_database_default].collect { |v| v.to_s }.include?(attribute_name)))
-             attributes << attribute
-           end
-         end
-         attributes
-       end
+    def get_active_record_attributes(klass, options)
+      attributes = []
+      attribute_names = get_attribute_names(klass.attribute_names.dup, options)
+      attribute_names.each do |attribute_name|
+        if include_attribute?(attribute_name, options)
+          column = klass.columns_hash[attribute_name.to_s]
+          attribute = {
+            name: attribute_name,
+            primitive: String,
+            options: {}
+          }
+          attribute[:primitive] = translate_primitive(column.type) if column
+          attribute[:options] = { default: column.default } if column &&
+                                                               (options[:use_database_default] == true ||
+                                                                 options[:use_database_default] == attribute_name ||
+                                                                 (options[:use_database_default].kind_of?(Array) &&
+                                                                   options[:use_database_default].collect { |v| v.to_s }.include?(attribute_name)))
+          attributes << attribute
+        end
+      end
+      attributes
+    end
 
-       def setup_validators(attribute_name, klass, options)
-         return if skip_validators?(attribute_name, options) || !include_attribute?(attribute_name, options)
-         klass.validators.each do |validator|
-           if validator.attributes.include?(attribute_name.to_sym)
-             validator_class = validator.class
-             validator_options = {}
-             validator_options.merge!(validator.options)
-             next if validator_options.include?(:on) && options["validate_#{attribute_name}_on".to_sym] != validator_options[:on]
-             validator_options.delete(:on)
-             if validator_class == ActiveRecord::Validations::UniquenessValidator
-               validator_class = Validations::UniquenessValidator
-               validator_options.merge!(model: klass)
-             else
-               # Validators from models are ActiveRecord
-               # objects which aren't useable in an
-               # environment without a database. It's
-               # necessary to convert to an ActiveModel
-               # validation.
-               if validator_class.name =~ /\AActiveRecord/
-                 validator_class = "ActiveModel::Validations::#{validator_class.name.split('::').last}".constantize
-               end
-             end
-             validates_with(validator_class, { attributes: attribute_name }.merge(validator_options))
-           end
-         end
-       end
+    def setup_validators(attribute_name, klass, options)
+      return if skip_validators?(attribute_name, options) || !include_attribute?(attribute_name, options)
+      klass.validators.each do |validator|
+        if validator.attributes.include?(attribute_name.to_sym)
+          validator_class = validator.class
+          validator_options = {}
+          validator_options.merge!(validator.options)
+          next if validator_options.include?(:on) && options["validate_#{attribute_name}_on".to_sym] != validator_options[:on]
+          validator_options.delete(:on)
+          if validator_class.name == 'ActiveRecord::Validations::UniquenessValidator'
+            validator_class = Validations::UniquenessValidator
+            validator_options.merge!(model: klass)
+          else
+            # Validators from models are ActiveRecord
+            # objects which aren't useable in an
+            # environment without a database. It's
+            # necessary to convert to an ActiveModel
+            # validation.
+            if validator_class.name =~ /\AActiveRecord/
+              validator_class = "ActiveModel::Validations::#{validator_class.name.split('::').last}".constantize
+            end
+          end
+          validates_with(validator_class, { attributes: attribute_name }.merge(validator_options))
+        end
+      end
+    end
 
-       def get_attribute_names(attributes, options)
-         attribute_names = attributes
-         attribute_names << options[:additional_attributes] if options[:additional_attributes]
-         attribute_names.flatten!
-         attribute_names.map!{ |a| a.to_s }
-         attribute_names
-       end
+    def get_attribute_names(attributes, options)
+      attribute_names = attributes
+      attribute_names << options[:additional_attributes] if options[:additional_attributes]
+      attribute_names.flatten!
+      attribute_names.map!{ |a| a.to_s }
+      attribute_names
+    end
 
-       def translate_primitive(primitive)
-         return nil unless primitive
-         translated_primitive = primitive.to_s.capitalize
-         translated_primitive = Virtus::Attribute::Boolean if translated_primitive == 'Boolean'
-         translated_primitive = DateTime if translated_primitive == 'Datetime'
-         translated_primitive = String if translated_primitive == 'Uuid'
-         translated_primitive = BigDecimal if translated_primitive == 'Decimal'
-         translated_primitive
-       end
+    def translate_primitive(primitive)
+      return nil unless primitive
+      translated_primitive = primitive.to_s.capitalize
+      translated_primitive = Virtus::Attribute::Boolean if translated_primitive == 'Boolean'
+      translated_primitive = DateTime if translated_primitive == 'Datetime'
+      translated_primitive = String if translated_primitive == 'Uuid'
+      translated_primitive = String if translated_primitive == 'Citext'
+      translated_primitive = BigDecimal if translated_primitive == 'Decimal'
+      translated_primitive
+    end
 
-       def include_attribute?(attribute_name, options)
-         # Attributes we don't want to inherit
-         exclude_attributes = ['id']
-         exclude_attributes << ['created_at', 'updated_at'] unless options[:include_timestamps]
-         exclude_attributes << options[:exclude] if options[:exclude]
-         exclude_attributes.flatten!
-         exclude_attributes.collect!{ |v| v.to_s }
-         # Attributes we only want to inherit
-         only_attributes = []
-         only_attributes << options[:only] if options[:only]
-         only_attributes.flatten!
-         only_attributes.collect!{ |v| v.to_s }
+    def include_attribute?(attribute_name, options)
+      # Attributes we don't want to inherit
+      exclude_attributes = ['id']
+      exclude_attributes << ['created_at', 'updated_at'] unless options[:include_timestamps]
+      exclude_attributes << options[:exclude] if options[:exclude]
+      exclude_attributes.flatten!
+      exclude_attributes.collect!{ |v| v.to_s }
+      # Attributes we only want to inherit
+      only_attributes = []
+      only_attributes << options[:only] if options[:only]
+      only_attributes.flatten!
+      only_attributes.collect!{ |v| v.to_s }
 
-         !exclude_attributes.include?(attribute_name) && (only_attributes.empty? || only_attributes.include?(attribute_name))
-       end
+      !exclude_attributes.include?(attribute_name) && (only_attributes.empty? || only_attributes.include?(attribute_name))
+    end
 
-       def skip_validators?(attribute_name, options)
-         return true if options[:skip_validators] == true
-         skip_validators = []
-         skip_validators << options[:skip_validators]
-         skip_validators.flatten!
-         skip_validators.collect!{ |v| v.to_s }
-         skip_validators.include?(attribute_name)
-       end
-     end
+    def skip_validators?(attribute_name, options)
+      return true if options[:skip_validators] == true
+      skip_validators = []
+      skip_validators << options[:skip_validators]
+      skip_validators.flatten!
+      skip_validators.collect!{ |v| v.to_s }
+      skip_validators.include?(attribute_name)
     end
   end
 end

data/lib/soulless/model.rb

@@ -1,76 +1,37 @@
 module Soulless
-  module Model
-    def self.included(base)
-      base.class_eval do
-        extend ActiveModel::Naming
-        extend ActiveModel::Translation
-        extend ActiveModel::Callbacks
-        include ActiveModel::Conversion
-        include ActiveModel::Dirty
-        include ActiveModel::Validations
+  class Model
+    extend ActiveModel::Callbacks
+    extend ActiveModel::Naming
+    extend ActiveModel::Translation
 
-        class << self
-          def i18n_scope
-            :soulless
-          end
-        end
+    extend Soulless::Inheritance
 
-        define_model_callbacks :validation, :save
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Dirty
+    include ActiveModel::SecurePassword
+    include ActiveModel::Serialization
+    include ActiveModel::Validations
 
-        def initialize(params = {})
-          init_accessors(attribute_set.map { |a| a.name })
-          super
-          init_dirty
-        end
+    include Soulless::Dirty
+    include Soulless::Validations
 
-        def persisted?
-          false
-        end
+    include Virtus.model
 
-        def valid_with_callbacks?
-          run_callbacks :validation do
-            valid_without_callbacks?
-          end
-        end
+    prepend Soulless::Attributes
+    prepend Soulless::Callbacks
 
-        alias_method_chain :valid?, :callbacks
+    def initialize(params = {})
+      super
 
-        def save
-          if valid?
-            run_callbacks :save do
-              persist!
-              changes_applied
-              true
-            end
-          else
-            false
-          end
-        end
-
-        def assign_attributes(attributes)
-          deep_update(self, attributes)
-        end
-
-        def update_attributes(attributes)
-          assign_attributes(attributes)
-          save
-        end
+      apply_changes
+    end
 
-        private
-        def persist!
-          raise 'Method persist! not defined...'
-        end
+    def i18n_scope
+      :soulless
+    end
 
-        def deep_update(object, attributes)
-          attributes.each do |key, value|
-            if value.kind_of?(Hash)
-              deep_update(object.send(key), value)
-            else
-              object.send("#{key}=", value)
-            end
-          end
-        end
-      end
+    def persisted?
+      false
     end
   end
 end

data/lib/soulless/validations/uniqueness_validator.rb

@@ -5,34 +5,33 @@ module Soulless
         raise 'ActiveRecord is not defined. The Soulless uniqueness validator cannot be used when ActiveRecord is not present.' unless Object.const_defined?('ActiveRecord')
         @model = options[:model]
         @attribute = options[:attribute]
-        options.merge!(class: @model) if ActiveModel::VERSION::STRING >= '4.1.0'
+        options.merge!(class: @model)
         @validator = ActiveRecord::Validations::UniquenessValidator.new(options)
         super(options)
       end
-      
+
       def validate_each(record, attribute, value)
         if !@model
           raise ArgumentError, 'Missing required argument "model"'
         else
           record_orig, attribute_orig = record, attribute
-          
+
           attribute = @attribute if @attribute
           record = @model.new(attribute => value)
-          
-          @validator.setup(@model) if ActiveModel::VERSION::STRING < '4.1'
+
           @validator.validate_each(record, attribute, value)
-          
+
           if record.errors.any?
             record_orig.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(value: value))
           end
         end
       end
     end
-    
+
     module ClassMethods
       def validates_uniqueness_of(*attr_name)
         validates_with(UniquenessValidator, _merge_attributes(attr_name))
       end
     end
   end
-end
+end

data/lib/soulless/validations.rb

@@ -1,4 +1,3 @@
-require 'soulless/validations/associated_validator'
 require 'soulless/validations/uniqueness_validator'
 
 module Soulless
@@ -7,4 +6,4 @@ module Soulless
       base.send(:extend, ClassMethods)
     end
   end
-end
+end

data/lib/soulless/version.rb

@@ -1,3 +1,3 @@
 module Soulless
-  VERSION = "0.6.0"
+  VERSION = '1.0.0'
 end

data/lib/soulless.rb

@@ -1,32 +1,14 @@
-require 'virtus'
-require 'securerandom'
-require 'active_support'
 require 'active_model'
+require 'virtus'
 
-require 'soulless/accessors'
-require 'soulless/associations'
+require 'soulless/attributes'
+require 'soulless/callbacks'
 require 'soulless/dirty'
 require 'soulless/inheritance'
-require 'soulless/model'
 require 'soulless/validations'
+require 'soulless/model'
 require 'soulless/version'
 
-require 'soulless/railtie' if defined?(Rails)
-
 module Soulless
-  I18n.load_path += Dir.glob('lib/soulless/locale/*.{rb,yml}')
-  
-  def self.model(options = {})
-    mod = Module.new
-    mod.define_singleton_method :included do |object|
-      object.send(:include, Virtus.model(options))
-      object.send(:include, Model)
-      object.send(:include, Associations)
-      object.send(:include, Validations)
-      object.send(:include, Dirty)
-      object.send(:include, Accessors)
-      object.send(:include, Inheritance)
-    end
-    mod
-  end
+  # Your code goes here...
 end

data/soulless.gemspec

@@ -4,26 +4,25 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'soulless/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'soulless'
+  spec.name          = "soulless"
   spec.version       = Soulless::VERSION
   spec.authors       = ['Anthony Smith']
   spec.email         = ['anthony@sticksnleaves.com']
-  spec.description   = %q{Rails models without a database (and Rails).}
-  spec.summary       = %q{Create Rails style models without the database.}
-  spec.homepage      = ''
+
+  spec.summary       = %q{Rails models without the database (and Rails)}
+  spec.description   = %q{Create Rails style models without the database (and Rails).}
+  spec.homepage      = 'https://github.com/anthonator/soulless'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'activesupport', '>= 3.2'
-  spec.add_runtime_dependency 'activemodel', '>= 3.2'
-  spec.add_runtime_dependency 'virtus', '>= 1.0'
+  spec.add_dependency 'activemodel', '>= 4.2.0', '< 5.1'
+  spec.add_dependency 'virtus' , '~> 1.0.0'
 
   spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'database_cleaner'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec', '~> 3.0'
 end