model-x 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cef24d01b17c87ee5b6410ec90b970cb312b2fba
+  data.tar.gz: 2c254c395e2ef7148d051ad449038c92cf2f1c2b
+SHA512:
+  metadata.gz: f7b9fcf347aaca60c5fa0a04469be335ed32bacb86535db13bfb066d2b55ae4ec1f10fcf1c5fe860a8b3c23ec42fe1f43a34eafda5f6a6e0420abfe8d674fb12
+  data.tar.gz: 744b333045ddacd09bc565ff41c6417ef8976d5c299a34074ac3c6f99d3cbdae445c6bfbe241d4ca47de0e5b630157d647bda624be29723ab90cadc715e29bb1

data/.gitignore

@@ -0,0 +1,29 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore .DS_Store
+.DS_Store
+
+# Ignore the output files.
+/pkg
+
+# Ignore bundler and database config and precompiled assets
+/.bundle
+/.env
+
+# Ignore all logfiles and tempfiles.
+/tmp
+
+# Ignore TextMate projects
+*.tmproj
+*.sublime-project
+*.sublime-workspace
+
+# Documentation files and other stuff
+.yardoc
+/doc
+/nbproject
+/coverage

data/.ruby-gemset

@@ -0,0 +1 @@
+flux

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.0.0-p247

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in model-x.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,45 @@
+PATH
+  remote: .
+  specs:
+    model-x (0.0.1)
+      activemodel
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.0.3)
+      activesupport (= 4.0.3)
+      builder (~> 3.1.0)
+    activesupport (4.0.3)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    atomic (1.1.15)
+    builder (3.1.4)
+    diff-lcs (1.2.4)
+    i18n (0.6.9)
+    minitest (4.7.5)
+    multi_json (1.9.0)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+    thread_safe (0.2.0)
+      atomic (>= 1.1.7, < 2)
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  model-x!
+  rake
+  rspec (~> 2.14)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Joost Lubach
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Model::X
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'model-x'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install model-x
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/model-x.rb

@@ -0,0 +1,2 @@
+# File added so users can require 'model-x'
+require 'model_x'

data/lib/model_x.rb

@@ -0,0 +1,18 @@
+require 'active_support'
+require 'active_model'
+
+module ModelX
+
+  extend ActiveSupport::Autoload
+
+  class AttributeAlreadyDefined < Exception; end
+  class AttributeNotFound < RuntimeError; end
+
+  autoload :Base
+  autoload :Mixin
+  autoload :Attributes
+  autoload :Associations
+  autoload :Boolean
+  autoload :Percentage
+
+end

data/lib/model_x/associations.rb

@@ -0,0 +1,104 @@
+module ModelX
+
+  # Adds rudimentary 'associations' support to simple models. As there is no real database connection to
+  # another object, it is merely simulated by creating two attributes: +<name>+ and +<name>_id+. They work
+  # together so that a database association is simulated.
+  module Associations
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      ######
+      # Association definition methods
+
+        # Define a belongs_to association.
+        #
+        # @param [Symbol|String] association The name of the association.
+        # @option options [String] :class_name The class name of the associated object.
+        # @option options [#to_s] :foreign_key The foreign key to use.
+        def belongs_to(association, options = {})
+          class_name = options[:class_name] || association.to_s.camelize
+          foreign_key = options[:foreign_key] || "#{association}_id"
+
+          attribute foreign_key
+
+          # Define attribute readers and writers for the ID attribute.
+          class_eval <<-RUBY, __FILE__, __LINE__+1
+
+            def #{foreign_key}
+              read_attribute(:#{foreign_key}) || @#{association}.try(:id)
+            end
+
+            def #{foreign_key}=(value)
+              value = nil if value.blank?
+              write_attribute :#{foreign_key}, value
+              @#{association} = nil
+            end
+
+            def #{association}(reload = false)
+              id = #{foreign_key}
+              if reload
+                @#{association} = ::#{class_name}.find_by_id(id) if id
+              else
+                @#{association} ||= ::#{class_name}.find_by_id(id) if id
+              end
+            end
+
+            def #{association}=(value)
+              value = nil if value.blank?
+              @#{association} = value
+              write_attribute :#{foreign_key}, nil
+            end
+
+          RUBY
+
+        end
+
+        # Defines a has_many association.
+        def has_many(association, options = {})
+          attribute association
+
+          class_name = options[:class_name] || association.to_s.singularize.camelize
+          foreign_key = options[:foreign_key] || "#{association.to_s.singularize}_id"
+          ids_attribute = foreign_key.pluralize
+
+          attribute ids_attribute
+
+          # Define attribute readers and writers for the ID attribute.
+          class_eval <<-RUBY, __FILE__, __LINE__+1
+
+            def #{ids_attribute}
+              read_attribute(:#{ids_attribute}) || read_attribute(:#{association}).try(:id)
+            end
+
+            def #{ids_attribute}=(value)
+              value = nil if value.blank?
+              write_attribute :#{ids_attribute}, value
+              @#{association} = nil
+            end
+
+            def #{association}(reload = false)
+              ids = #{ids_attribute}
+              if reload
+                @#{association} = ::#{class_name}.where(:id => ids) if ids
+              else
+                @#{association} ||= ::#{class_name}.where(:id => ids) if ids
+              end
+            end
+
+            def #{association}=(value)
+              value = nil if value.blank?
+              @#{association} = value
+              write_attribute :#{ids_attribute}, nil
+            end
+
+          RUBY
+
+        end
+
+
+    end
+
+  end
+
+end

data/lib/model_x/attributes.rb

@@ -0,0 +1,158 @@
+module ModelX
+
+  # Provides attribute DSL methods.
+  #
+  # == Defaults && types
+  #
+  # For each attribute, you can set a default which is returned if the virtual attribute would otherwise
+  # be +nil+.
+  #
+  # You may also specify a 'type' for the virtual attribute. This does nothing more than evaluate the line
+  # <tt>&lt;type&gt; :&lt;attribute&gt;</tt> into the model, e.g.
+  #
+  #   attribute :has_price, :type => :boolean
+  #
+  # is equivalent to
+  #
+  #   attribute :has_price
+  #   boolean :has_price
+  module Attributes
+    extend ActiveSupport::Concern
+
+    # Attributes hash. Builds an attributes hash from current instance variables.
+    def attributes
+      @attributes ||= self.class.attributes.inject({}) do |attrs, name|
+        next attrs if name == :'attributes'
+        attrs[name.to_sym] = send(name)
+        attrs
+      end
+    end
+
+    # Assigns the attributes hash by setting all given values through attribute writers.
+    #
+    # @raise [AttributeNotFound] if a certain attribute is not found.
+    def attributes=(values)
+      assign_attributes values
+    end
+
+    # Assigns the model's attributes with the values from the given hash.
+    #
+    # @option options [Symbol] :missing (:raise)
+    #   Specify the behavior for missing attributes. +:raise+ raises an exception, +:ignore+
+    #   ignores the missing attributes.
+    def assign_attributes(values, options = {})
+      raise ArgumentError, "hash required" unless values.is_a?(Hash)
+
+      options = options.symbolize_keys
+      options.assert_valid_keys :missing
+
+      values.each do |key, value|
+        if respond_to?(:"#{key}=")
+          send :"#{key}=", value
+        elsif options[:missing] == :raise
+          raise AttributeNotFound, "attribute :#{key} not found"
+        end
+      end
+      self
+    end
+
+    # Reads an attribute value.
+    def read_attribute(attribute)
+      instance_variable_get("@#{attribute}")
+    end
+    protected :read_attribute
+
+    # Reads an attribute value.
+    def [](attribute)
+      read_attribute attribute
+    end
+
+    # Writes an attribute value
+    def write_attribute(attribute, value)
+      @attributes = nil
+      instance_variable_set "@#{attribute}", value
+    end
+    protected :write_attribute
+
+    module ClassMethods
+
+      # @!attribute [r] attributes
+      # @return [Array] An array of defined attribute names.
+      def attributes
+        @attributes ||= []
+      end
+
+      # @!method attribute(*attributes, options = {})
+      # DSL method to define attributes.
+      #
+      # @option options :default
+      #   A default value for the attribute.
+      # @option options [Symbol] :type
+      #   A type for the attribute.
+      def attribute(*attributes)
+        options = attributes.extract_options!
+
+        @_model_x_defaults ||= {}
+        @_model_x_types ||= {}
+
+        attributes.each do |attribute|
+          attribute = attribute.to_sym
+
+          if instance_methods.include?(attribute)
+            raise AttributeAlreadyDefined, "attribute :#{attribute} is already defined on #{self.name}"
+          end
+          self.attributes << attribute
+
+          @_model_x_defaults[attribute] = options[:default] if options.key?(:default)
+          @_model_x_types[attribute] = options[:type]
+
+          class_eval <<-RUBY, __FILE__, __LINE__+1
+
+            def #{attribute}
+              value = read_attribute(:#{attribute})
+              value = self.class.send(:_model_x_default, :#{attribute}) if value.nil?
+              value
+            end
+
+            def #{attribute}=(value)
+              write_attribute :#{attribute}, value
+            end
+
+          RUBY
+
+          if options[:type]
+            class_eval <<-RUBY, __FILE__, __LINE__+1
+              #{options[:type]} :#{attribute}
+            RUBY
+          end
+
+        end
+      end
+
+      private
+
+        def _model_x_default(attribute)
+          if @_model_x_defaults && @_model_x_defaults.key?(attribute)
+            @_model_x_defaults[attribute]
+          elsif superclass.private_methods.include?(:_model_x_default)
+            superclass.send :_model_x_default, attribute
+          end
+        end
+
+        def _model_x_convert(attribute, value)
+          if @_model_x_types[attribute]
+            if ModelX.const_defined?(@_model_x_types[attribute].to_s.camelize)
+              ModelX.const_get(@_model_x_types[attribute].to_s.camelize).convert(value)
+            else
+              raise "no converter found for type #{@_model_x_types[attribute]}"
+            end
+          else
+            value
+          end
+        end
+
+    end
+
+  end
+
+end

data/lib/model_x/base.rb

@@ -0,0 +1,19 @@
+module ModelX
+
+  # Base ModelX class. Does nothing more than include {ModelX::Mixin} and define
+  # a constructor.
+  class Base
+
+    include Mixin
+
+    # Initializes the ModelX class by assigning all specified attributes.
+    #
+    # @yield [self] Yields the new model if a block is given
+    def initialize(attributes = {})
+      self.attributes = attributes if attributes.present?
+      yield self if block_given?
+    end
+
+  end
+
+end

data/lib/model_x/boolean.rb

@@ -0,0 +1,68 @@
+module ModelX
+
+  # Adds boolean attribute accessors to any object, allowing boolean-ish values to be set as well.
+  #
+  # == Usage
+  #
+  #   class MyObject
+  #     include ModelX::Boolean
+  #
+  #     attr_accessor :my_attribute
+  #     boolean :my_attribute
+  #   end
+  #
+  # Now, the following can be used:
+  #
+  #   object = MyObject.new
+  #   object.my_attribute = false
+  #   object.my_attribute? # => false
+  #
+  #   object.my_attribute = '0'
+  #   object.my_attribute? # => false
+  #   object.my_attribute = '1'
+  #   object.my_attribute? # => true
+  #   object.my_attribute = 'false'
+  #   object.my_attribute? # => false
+  #
+  # Note that an existing attribute writer *must* exist.
+  #
+  # The values '0', 0, 'off', 'no' and 'false', and all values that Ruby considers false are deemed to be false.
+  # All other values are true.
+  module Boolean
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def boolean(*attributes)
+        attributes.each do |attribute|
+
+          # An attribute must already exist.
+          unless instance_methods.include?(:"#{attribute}=")
+            raise ArgumentError, "cannot add boolean attribute #{attribute} - no existing attribute exists"
+          end
+
+          # Override the writer and add a ? version.
+          class_eval <<-RUBY, __FILE__, __LINE__+1
+
+            def #{attribute}_with_model_x_boolean=(value)
+              self.#{attribute}_without_model_x_boolean = ModelX::Boolean.convert(value)
+            end
+            alias_method_chain :#{attribute}=, :model_x_boolean
+            alias_method :#{attribute}?, :#{attribute}
+
+          RUBY
+
+        end
+      end
+
+    end
+
+    # Converts a boolean attribute. This is used mostly for toggle buttons that
+    # enable or disable an input section.
+    def self.convert(value)
+      value.present? && value != '0' && value != 0 && value != 'off' && value != 'no' && value != 'false'
+    end
+
+  end
+
+end

data/lib/model_x/mixin.rb

@@ -0,0 +1,24 @@
+module ModelX
+  module Mixin
+    extend ActiveSupport::Concern
+
+    # Include standard activemodel stuff.
+    include ActiveModel::Naming
+    include ActiveModel::Validations
+    include ActiveModel::Serialization
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Translation
+
+    included { extend ActiveModel::Callbacks }
+    include ActiveModel::Validations::Callbacks
+
+    include ModelX::Attributes
+    include ModelX::Associations
+    include ModelX::Boolean
+    include ModelX::Percentage
+
+    def persisted?() false end
+    def to_key() false end
+
+  end
+end

data/lib/model_x/percentage.rb

@@ -0,0 +1,102 @@
+module ModelX
+
+  # Adds percentage attribute accessors to any object. These are attribute accessors with a '_percentage' suffix
+  # which simply accept a number multiplied by 100.
+  module Percentage
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Adds percentage attributes for the given attribute. Per specified attribute, the following are added:
+      #
+      # +:<attribute>_percentage+::
+      #   Retrieves or accepts the value of the original times 100.
+      #
+      # == Usage
+      #
+      #   class MyObject
+      #     include ModelX::Percentage
+      #
+      #     attr_accessor :my_attribute
+      #     percentage :my_attribute
+      #   end
+      #
+      # Now, the following holds true:
+      #
+      #   object = MyObject.new
+      #
+      #   object.my_attribute = 0.5
+      #   object.my_attribute_percentage # => 50
+      #
+      #   object.my_attribute_percentage = 10
+      #   object.my_attribute # => 0.1
+      #
+      # Note that an existing attribute reader *must* exist. For the writer to be defined, an existing attribute
+      # writer must exist.
+      def percentage(*attributes)
+        attributes.each do |attribute|
+
+          # An attribute must already exist.
+          unless instance_methods.include?(:"#{attribute}") || instance_methods.include?(:read_attribute)
+            raise ArgumentError, "cannot add percentage attribute #{attribute} - no existing attribute exists"
+          end
+
+          define_writer = instance_methods.include?(:"#{attribute}=") || private_instance_methods.include?(:write_attribute)
+
+          # Create a *_percentage reader and writer.
+          class_eval <<-RUBY, __FILE__, __LINE__+1
+
+            def #{attribute}_multiplier
+              1 - (#{attribute}.to_f || 0)
+            end
+
+            def #{attribute}_increase_multiplier
+              1 + (#{attribute}.to_f || 0)
+            end
+
+            alias_method  :#{attribute}_decrease_multiplier, :#{attribute}_multiplier
+
+            def #{attribute}_percentage
+              @#{attribute}_percentage ||= if #{attribute}.present?
+                #{attribute}.to_f * 100
+              else
+                nil
+              end
+            end
+
+            def self.human_attribute_name(attribute, options = {})
+              if attribute =~ /_percentage$/
+                super $`, options
+              else
+                super
+              end
+            end
+
+          RUBY
+
+          if define_writer
+            validates_numericality_of :"#{attribute}_percentage", :allow_blank => true
+
+            class_eval <<-RUBY, __FILE__, __LINE__+1
+
+              def #{attribute}_percentage=(value)
+                if value.present?
+                  @#{attribute}_percentage = value
+                  self.#{attribute} = value.to_f / 100
+                else
+                  @#{attribute}_percentage = nil
+                  self.#{attribute} = nil
+                end
+              end
+
+            RUBY
+          end
+
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/model_x/version.rb

@@ -0,0 +1,3 @@
+module ModelX
+  VERSION = "0.0.1"
+end

data/model-x.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'model_x/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "model-x"
+  spec.version       = ModelX::VERSION
+  spec.authors       = ["Joost Lubach"]
+  spec.email         = ["joost@yoazt.com"]
+  spec.description   = %q[ Base class that includes many ActiveModel mixins as well as attribute behavior. ]
+  spec.summary       = %q[ Base class that includes many ActiveModel mixins as well as attribute behavior. ]
+  spec.homepage      = ""
+  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{^spec/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activemodel"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14"
+end

data/spec/model_x/associations_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+# Define this class top-level, because it will be accessed as a constant.
+class ModelXTestRecord
+  attr_reader :id
+  def initialize(id)
+    @id = id
+  end
+end
+
+describe ModelX::Associations do
+
+  let(:model_x_test_model_class) do
+    Class.new(ModelX::Base) do
+      belongs_to :model_x_test_record
+    end
+  end
+
+  let(:model) { model_x_test_model_class.new }
+  let(:records) { [ ModelXTestRecord.new(0), ModelXTestRecord.new(1) ] }
+
+  before do
+    allow(ModelXTestRecord).to receive(:find_by_id) { |id| records[id] }
+  end
+
+  context "trying to access a non-existent association" do
+    specify { expect{ model.something }.to raise_error(NoMethodError) }
+    specify { expect{ model.something_id }.to raise_error(NoMethodError) }
+  end
+
+  context "trying to access an existent association" do
+    specify { expect{ model.model_x_test_record }.not_to raise_error }
+    specify { expect{ model.model_x_test_record_id }.not_to raise_error }
+  end
+
+  context 'foreign key' do
+    context "specifying nil" do
+      before { model.model_x_test_record_id = nil }
+      specify { expect(model.model_x_test_record_id).to be_nil }
+    end
+    context "specifying a non-existing ID" do
+      before { model.model_x_test_record_id = 2 }
+      specify { expect(model.model_x_test_record_id).to eql(2) }
+    end
+    context "specifying an existing ID" do
+      before { model.model_x_test_record_id = 1 }
+      specify { expect(model.model_x_test_record_id).to eql(1) }
+    end
+    context "specifying a related object" do
+      before { model.model_x_test_record = records[0] }
+      specify { expect(model.model_x_test_record_id).to eql(0) }
+    end
+  end
+
+  context 'association' do
+    context "without an ID" do
+      specify { expect(model.model_x_test_record).to be_nil }
+    end
+    context "with a nonexisting ID" do
+      before { model.model_x_test_record_id = 2 }
+      specify { expect(model.model_x_test_record).to be_nil }
+    end
+    context "with an existing ID" do
+      before { model.model_x_test_record_id = 1 }
+      specify { expect(model.model_x_test_record).to be(records[1]) }
+    end
+    context "with an existing object" do
+      before { model.model_x_test_record = records[1] }
+      specify { expect(model.model_x_test_record).to be(records[1]) }
+    end
+
+    it "should convert to nil if any blank value is passed" do
+      model.model_x_test_record = ""
+      expect(model.model_x_test_record).to be_nil
+    end
+
+    it "should invalidate a cached record if the id changes" do
+      model.model_x_test_record = records[1]
+      model.model_x_test_record_id = 0
+      expect(model.model_x_test_record).to be(records[0])
+    end
+
+    it "should honour a reload parameter" do
+      model.model_x_test_record = records[1]
+      model.instance_variable_set '@model_x_test_record_id', 0
+
+      expect(model.model_x_test_record).to be(records[1])
+      expect(model.model_x_test_record(true)).to be(records[0])
+    end
+  end
+
+  describe "option overrides" do
+    context "with another foreign key" do
+      before do
+        class ::ModelXTestRecord2; end
+
+        allow(ModelXTestRecord2).to receive(:find_by_id) { ModelXTestRecord2.new }
+        model_x_test_model_class.class_eval { belongs_to :model_x_test_record2, :foreign_key => :related_object_id }
+      end
+
+      specify { expect(model).to respond_to(:model_x_test_record2) }
+      specify { expect(model).to respond_to(:model_x_test_record2=) }
+      specify { expect(model).to_not respond_to(:model_x_test_record2_id) }
+      specify { expect(model).to_not respond_to(:model_x_test_record2_id=) }
+      specify { expect(model).to respond_to(:related_object_id) }
+      specify { expect(model).to respond_to(:related_object_id=) }
+
+      it "should use the corresponding foreign key" do
+        expect(ModelXTestRecord2).to receive(:find_by_id).with(1)
+        model.related_object_id = 1
+        model.model_x_test_record2
+      end
+      it "should use the corresponding association name" do
+        related_object = ModelXTestRecord2.new
+        expect(related_object).to receive(:id).and_return(5)
+        model.model_x_test_record2 = related_object
+        expect(model.related_object_id).to eql(5)
+      end
+    end
+
+    context "with another class name" do
+      it "should use the correct class" do
+        expect(ModelXTestRecord).to receive(:find_by_id).with(1)
+        model_x_test_model_class.class_eval { belongs_to :again_model_x_test_record, :class_name => 'ModelXTestRecord' }
+        model.again_model_x_test_record_id = 1
+        model.again_model_x_test_record
+      end
+    end
+
+  end
+
+  # TODO: has_many
+
+end

data/spec/model_x/attributes_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module ModelX
+  class TestModel < ModelX::Base
+    attribute :status
+  end
+  class DerivedModel < TestModel
+  end
+end
+
+describe ModelX::Attributes do
+
+  let(:model) { ModelX::TestModel.new }
+
+  context "trying to access a non-existent attribute" do
+    specify { expect{ model.some_attribute = 'test' }.to raise_error(NoMethodError) }
+    specify { expect{ model.some_attribute }.to raise_error(NoMethodError) }
+    specify { expect(model[:some_attribute]).to be_nil }
+  end
+
+  context "trying to access an existent attribute" do
+    specify { expect{ model.status = 'test' }.not_to raise_error }
+    specify { expect{ model.status }.not_to raise_error }
+    specify { model.status = 'test'; expect(model.status).to eql('test') }
+    specify { model.status = 'test'; expect(model[:status]).to eql('test') }
+  end
+
+  it "should not allow an attribute to be defined more than once" do
+    expect{ ModelX::TestModel.class_eval{ attribute :status } }.to raise_error(ModelX::AttributeAlreadyDefined)
+  end
+
+  describe '#attributes' do
+    specify { expect(model.attributes).to eql(:status => nil) }
+    context "with a value" do
+      before { model.status = :one }
+      specify { expect(model.attributes).to eql(:status => :one) }
+    end
+
+    it "should stay updated" do
+      model.status = :one
+      model.attributes
+      model.status = :two
+      expect(model.attributes).to eql(:status => :two)
+    end
+  end
+
+  describe '#attributes=' do
+    before { model.attributes = { :status => :one } }
+    specify { expect(model.status).to be(:one) }
+  end
+
+  context "default value" do
+    before(:all) do
+      ModelX::TestModel.class_eval { attribute :type, :default => :post }
+    end
+
+    specify { expect(model.type).to be(:post) }
+    specify { model.type = :attachment; expect(model.type).to be(:attachment) }
+    specify { expect(ModelX::DerivedModel.new.type).to be(:post) }
+  end
+
+end

data/spec/model_x/boolean_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module ModelX::Boolean
+  class TestModel < ModelX::Base
+  end
+end
+
+describe ModelX::Boolean do
+
+  let(:model) { ModelX::Boolean::TestModel.new }
+  before(:all) do
+    ModelX::Boolean::TestModel.class_eval { attribute :archived, :type => :boolean }
+  end
+
+  specify { expect(model).to respond_to(:archived?) }
+  specify { model.archived = true; expect(model.archived).to be_true }
+  specify { model.archived = true; expect(model.archived?).to be_true }
+  specify { model.archived = false; expect(model.archived).to be_false }
+  specify { model.archived = false; expect(model.archived?).to be_false }
+
+  specify { model.archived = '0'; expect(model.archived).to be_false }
+  specify { model.archived = 0; expect(model.archived).to be_false }
+  specify { model.archived = ''; expect(model.archived).to be_false }
+  specify { model.archived = 'false'; expect(model.archived).to be_false }
+  specify { model.archived = 'off'; expect(model.archived).to be_false }
+  specify { model.archived = 'no'; expect(model.archived).to be_false }
+
+  specify { model.archived = '1'; expect(model.archived).to be_true }
+  specify { model.archived = 1; expect(model.archived).to be_true }
+  specify { model.archived = '1'; expect(model.archived).to be_true }
+  specify { model.archived = 'true'; expect(model.archived).to be_true }
+  specify { model.archived = 'on'; expect(model.archived).to be_true }
+  specify { model.archived = 'yes'; expect(model.archived).to be_true }
+  specify { model.archived = 'something'; expect(model.archived).to be_true }
+
+end

data/spec/model_x/percentage_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe ModelX::Percentage do
+
+  let(:klass) do
+    Class.new(ModelX::Base) do
+      def self.name
+        'PercentageExample'
+      end
+
+      attr_accessor :discount
+      percentage :discount
+
+      attr_reader :other
+      percentage :other
+    end
+  end
+  let(:object) { klass.new }
+
+  it "should add a _percentage reader and writer" do
+    expect(object).to respond_to(:discount_percentage)
+    expect(object).to respond_to(:discount_percentage=)
+  end
+
+  it "should not add a writer on an object that doesn't have an existing writer" do
+    expect(object).to_not respond_to(:other_percentage=)
+  end
+
+  describe "percentage writer" do
+
+    it "should set the value / 100" do
+      object.discount_percentage = 80
+      expect(object.discount).to eql(0.8)
+    end
+
+    it "should set any non-present value to nil" do
+      object.discount_percentage = false
+      expect(object.discount).to be_nil
+
+      object.discount_percentage = nil
+      expect(object.discount).to be_nil
+
+      object.discount_percentage = ''
+      expect(object.discount).to be_nil
+    end
+
+  end
+
+  describe 'validation' do
+
+    it "should accept any number" do
+      object.discount_percentage = 10
+      expect(object).to be_valid
+      object.discount_percentage = 110
+      expect(object).to be_valid
+      object.discount_percentage = -10
+      expect(object).to be_valid
+    end
+
+    it "should not accept anything else" do
+      object.discount_percentage = 'abcd'
+      expect(object).to_not be_valid
+      expect(object.errors[:discount_percentage]).to_not be_nil
+    end
+
+    it "should allow blank values" do
+      object.discount_percentage = ''
+      expect(object).to be_valid
+    end
+
+  end
+
+  describe "percentage reader" do
+
+    it "should report the value * 100" do
+      object.discount = 0.5
+      expect(object.discount_percentage).to eql(50.0)
+    end
+
+    it "should report nil upon any non-present attribute value" do
+      object.discount = false
+      expect(object.discount_percentage).to be_nil
+
+      object.discount = nil
+      expect(object.discount_percentage).to be_nil
+
+      object.discount = ''
+      expect(object.discount_percentage).to be_nil
+    end
+
+  end
+
+  describe "#human_attribute_name override" do
+
+    it "should translate the name of the attribute without _percentage" do
+      expect(klass.human_attribute_name(:discount_percentage)).to eql(klass.human_attribute_name(:discount))
+    end
+
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'model-x'
+require 'rspec/autorun'
+
+# require 'simplecov'
+# SimpleCov.start do
+#   add_filter "_spec.rb"
+#   add_filter "spec/"
+#   add_group "Libs", "../libs/"
+# end
+
+RSpec.configure do |config|
+
+  config.mock_with :rspec do |config|
+    config.syntax = :expect
+  end
+
+end
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f}

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: model-x
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joost Lubach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: ' Base class that includes many ActiveModel mixins as well as attribute
+  behavior. '
+email:
+- joost@yoazt.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/model-x.rb
+- lib/model_x.rb
+- lib/model_x/associations.rb
+- lib/model_x/attributes.rb
+- lib/model_x/base.rb
+- lib/model_x/boolean.rb
+- lib/model_x/mixin.rb
+- lib/model_x/percentage.rb
+- lib/model_x/version.rb
+- model-x.gemspec
+- spec/model_x/associations_spec.rb
+- spec/model_x/attributes_spec.rb
+- spec/model_x/boolean_spec.rb
+- spec/model_x/percentage_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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.1.4
+signing_key: 
+specification_version: 4
+summary: Base class that includes many ActiveModel mixins as well as attribute behavior.
+test_files:
+- spec/model_x/associations_spec.rb
+- spec/model_x/attributes_spec.rb
+- spec/model_x/boolean_spec.rb
+- spec/model_x/percentage_spec.rb
+- spec/spec_helper.rb
+has_rdoc: