simple_model 1.1.1 → 1.2.0

data/lib/simple_model/extend_core.rb

@@ -4,26 +4,13 @@ module SimpleModel
     require 'date'
     require 'bigdecimal'
     require 'bigdecimal/util'
-  
-    Object.class_eval do
-      
-      # Expects an array of symboles representing methods for casting the object 
-      # EX: "1".cast_to(:float) # => 1.0
-      def cast_to(methods=[])
-        val = self
-        methods.each do |method|
-          val = val.send(method)
-        end
-        val
-      end
-    end
     
-    Float.class_eval do
-    
-      # any value greater than 0.0 is true
+    Float.class_eval do   
+      # that does not equal 0.0 is true
       def to_b
-        self > 0.0
+        self != 0.0
       end
+      
       # Rounds float to the precision specified
       # 100.5235.round_to #=> 101.0
       # 100.5235.round_to(1) #=> 101.5
@@ -40,8 +27,7 @@ module SimpleModel
       end
 
       # Returns a string with representation of currency, rounded to nearest hundredth
-      def to_currency_s(symbol="$")
-       
+      def to_currency_s(symbol="$")      
         num = self.round_to(2).to_s
         neg = num.include?("-")
         while num.index('.') != (num.length-3)
@@ -59,9 +45,16 @@ module SimpleModel
         end
         num
       end
+      
+      def to_time
+        Time.at(self)
+      end
+      
+      def to_date
+        Time.at(self).to_date
+      end
     end
 
-
     #Extend Ruby String.rb
     String.class_eval do
 
@@ -70,21 +63,22 @@ module SimpleModel
         ['1',"true", "t"].include?(self)
       end
 
-
       # Takes known US formatted date/time strings (MM/DD/YYYY TIME) and converts
-      # them to international format (YYYY/MM/DD TIME)
+      # them to international format (YYYY/MM/DD TIME). Also cleans up C# JSON
+      # Date (really a time integer) value.
       #
-      # * safe_date_string("12/31/2010")          # => '2010-12-31'
-      # * safe_date_string("12/31/2010T23:30:25") # => '2010-12-31T23:30:25'
-      # * safe_date_string("12/31/2010 23:30:25") # => '2010-12-31 23:30:25'
+      # * safe_date_string("12/31/2010")              # => '2010-12-31'
+      # * safe_date_string("12/31/2010T23:30:25")     # => '2010-12-31T23:30:25'
+      # * safe_date_string("12/31/2010 23:30:25")     # => '2010-12-31 23:30:25'
+      # * safe_date_string("\/Date(1310669017000)\/") # => 
       def safe_datetime_string
-        date = self
-        date_string = ""
-        if date[0..9].match(/^(0[1-9]|[1-9]|1[012])[- \/.]([1-9]|0[1-9]|[12][0-9]|3[01])[- \/.][0-9][0-9][0-9][0-9]/)
-          if date.include?("/")
-            split = date.split("/")
+        safe_date = nil
+        if self[0..9].match(/^(0[1-9]|[1-9]|1[012])[- \/.]([1-9]|0[1-9]|[12][0-9]|3[01])[- \/.][0-9][0-9][0-9][0-9]/)
+          safe_date = ""
+          if self.include?("/")
+            split = self.split("/")
           else
-            split = date.split("-")
+            split = self.split("-")
           end
           time = ""
           if split[2].length > 4
@@ -92,108 +86,111 @@ module SimpleModel
             split[2] = split[2][0..3]
           end
           if split.length == 3 && split[2].length == 4
-            date_string << "#{split[2]}-#{split[0]}-#{split[1]}"
-            date_string << "#{time}" unless time.nil? || time.to_s.length == 0
+            safe_date << "#{split[2]}-#{split[0]}-#{split[1]}"
+            safe_date << "#{time}" unless time.nil? || time.to_s.length == 0
           end
+        elsif self.match(/^\/Date\(/)
+          safe_date = Time.at(((self.gsub(/(\/Date\()/,"")).gsub(/\)\/$/,"").to_f) / 1000).to_s
+        else
+          safe_date = self
         end
-        date_string = date if date_string.length == 0
-        date_string
+        safe_date
       end
       
       # Use safe_datetime_string help with those pesky US date formats in Ruby 1.9
+      # or to change an integer string to date
       def to_date
+        return safe_datetime_string.to_i.to_date if self.match(/^+d$/)
         Date.parse(safe_datetime_string)
       end
 
       # Use safe_datetime_string help with those pesky US date formats in Ruby 1.9
+      # or to change an integer string to date
       def to_time
+        return safe_datetime_string.to_i.to_time if self.match(/^+d$/)
         Time.parse(safe_datetime_string)
       end
 
-
-      alias :old_to_f :to_f
+      alias :core_to_f :to_f
 
       # Remove none numeric characters then run default ruby float cast
       def to_f
-        gsub(/[^0-9\.\+\-]/, '').old_to_f
+        gsub(/[^0-9\.\+\-]/, '').core_to_f
       end
-
-      # Cleans all none pertinent characters and returns a BigDecimal rounded to nearest hundredth
-      # Why decimal?..because precision matters when dealing with money ;)
-      def to_currency
-        gsub(/[^0-9\.\+\-]/, '').to_d.round(2)
+      
+      alias :core_to_d :to_d
+      
+      def to_d
+        gsub(/[^0-9\.\+\-]/, '').core_to_d
       end
-
+      alias :to_currency :to_d
+      
+    end
     
-      # Parse a full name into it's parts. http://pastie.org/867415
-      # Based on :http://artofmission.com/articles/2009/5/31/parse-full-names-with-ruby
-      #
-      # Options:
-      #   +name+
-      #   +seperate_middle_name+ defaults to true. if false, will combine middle name into last name.
-
-      def parse_name(seperate_middle_name=true)
-        str = self
-        if str.include?(',') # Rearrange names formatted as Doe, John C. to John C. Doe
-          temp = str.split(',')
-          temp << temp[0]
-          temp.delete_at(0)
-          str = temp.join(" ")
-
-        end
-        parts = str.split # First, split the name into an array
-
-        parts.each_with_index do |part, i|
-          # If any part is "and", then put together the two parts around it
-          # For example, "Mr. and Mrs." or "Mickey and Minnie"
-          if part=~/^(and|&)$/i && i > 0
-            parts[i-1] = [parts.delete_at(i+1), parts.at(i).downcase, parts.delete_at(i-1)].reverse * " "
-          end
-        end if self=~/\s(and|&)\s/i # optimize
-
-        { :prefix      => (parts.shift if parts[0]=~/^\w+\./),
-          :first_name  =>  parts.shift || "", # if name is "", then atleast first_name should be ""
-          :suffix      => (parts.pop   if parts[-1]=~/(\w+\.|[IVXLM]+|[A-Z]+\.|(?i)jr|(?i)sr )$/),
-          :last_name   => (seperate_middle_name ? parts.pop : parts.slice!(0..-1) * " "),
-          :middle_name => (parts * " " unless parts.empty?) }
+    BigDecimal.class_eval do
+      def to_currency_s(symbol="$")
+        self.to_f.to_currency_s(symbol)
+      end 
+      
+      def to_b
+        self != 0.0
       end
     end
     
-   BigDecimal.class_eval do
-    def to_currency_s(symbol="$")
-      self.to_f.to_currency_s(symbol)
-    end 
-   end
-    
     Fixnum.class_eval do
-      #Any value greater than 0 is true
-      def to_b
-        self > 0
+      def to_currency_s(symbol="$")
+        self.to_f.to_currency_s(symbol)
       end
       
-      def to_d
-        BigDecimal.new("#{self}.0")
+      unless Fixnum.instance_methods.include?(:to_b)
+        #Any value greater than 0 is true
+        def to_b
+          self > 0
+        end
+      end
+      
+      unless Fixnum.instance_methods.include?(:to_d)
+        def to_d
+          BigDecimal.new("#{self}.0")
+        end
+      end
+      
+      unless Fixnum.instance_methods.include?(:to_date)
+        def to_date
+          Time.at(self).to_date
+        end
+      end
+      unless Fixnum.instance_methods.include?(:to_time)
+        def to_time
+          Time.at(self)
+        end
       end
     end
 
     NilClass.class_eval do
-      def to_b
-        false
+      unless NilClass.instance_methods.include?(:to_b)
+        def to_b
+          false
+        end
       end
-
-      def to_d
-        BigDecimal.new("0.0")
+      unless NilClass.instance_methods.include?(:to_d)
+        def to_d
+          BigDecimal.new("0.0")
+        end
       end
     end
     TrueClass.class_eval do
-
-      def to_b
-        self
+      unless TrueClass.instance_methods.include?(:to_b)
+        def to_b
+          self
+        end
       end
     end
     FalseClass.class_eval do
-      def to_b
-        self
+      unless FalseClass.instance_methods.include?(:to_b)
+        def to_b
+          self
+        end
       end
     end
   end

data/lib/simple_model/version.rb

@@ -1,3 +1,3 @@
 module SimpleModel
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/lib/simple_model.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2010-2011 Joshua Thomas Mckinney
+# Copyright (c) 2010-2012 Joshua Thomas Mckinney
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -21,20 +21,30 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 module SimpleModel
-
-  #Get those rails goodies
   require 'active_support'
   require 'active_support/i18n'
+  require 'active_support/time'
+  require 'active_support/core_ext/class/attribute'
+  require 'active_support/core_ext/class/attribute_accessors'
+  require 'active_support/core_ext/class/delegating_attributes'
+  require 'active_support/core_ext/class/attribute'
+  require 'active_support/core_ext/array/extract_options'
+  require 'active_support/core_ext/hash/deep_merge'
+  require 'active_support/core_ext/hash/indifferent_access'
+  require 'active_support/core_ext/hash/slice'
+  require 'active_support/core_ext/string/behavior'
+  require 'active_support/core_ext/kernel/singleton_class'
+  require 'active_support/core_ext/module/delegation'
+  require 'active_support/core_ext/module/introspection'
+  require 'active_support/core_ext/object/duplicable'
+  require 'active_support/core_ext/object/blank'
   require 'active_model'
-
-  # Load as necessary
-  autoload :ExtendCore, "simple_model/extend_core"
-  autoload :Attributes, "simple_model/attributes"
-  autoload :ErrorHelpers, "simple_model/error_helpers"
-  autoload :Validation, "simple_model/validation"  
-  autoload :Base, "simple_model/base"
-
-  #Railtie
+  require "simple_model/extend_core"
+  require 'simple_model/exceptions'
+  require "simple_model/attributes"
+  require "simple_model/error_helpers"
+  require "simple_model/validation"
+  require "simple_model/base"
   require 'simple_model/simple_model_railtie.rb' if defined?(Rails)
-
+  
 end

data/simple_model.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'autotest'
+  s.add_development_dependency 'debugger'
 
   s.rubyforge_project = "simple_model"
 

data/spec/attributes_spec.rb

@@ -9,84 +9,159 @@ describe SimpleModel::Attributes do
     @init = TestInit.new(:test1 => "1", :test2 => '2')
   end
 
-
   it "should set provided attributes on initialize" do   
-
     @init.test1.should eql("1")
     @init.test2.should eql("2")
   end
 
   it "should include set attributes in attributes hash" do
-    @init.attributes.class.should eql(Hash)
+    @init.attributes.should be_kind_of(ActiveSupport::HashWithIndifferentAccess)
     @init.attributes[:test1].should eql("1")
     @init.attributes[:test2].should eql("2")
   end
-
-end
-describe SimpleModel::Attributes, 'define_reader_with_options' do
-  before(:each) do
-    class TestDefault
-      include SimpleModel::Attributes
-      attr_accessor :test
-      define_reader_with_options :test, :default => "test"
+  
+  context '#new_with_store'do
+    it "should use the provided object as the attribute store" do
+      my_store = {:test1 => 1,:test2 => 2}
+      new = TestInit.new_with_store(my_store)
+      new.test1 = 3
+      new.test1.should eql(3)
+      my_store[:test1].should eql(new.test1)
     end
   end
-
-  it "should define setter method with default value" do
-    default = TestDefault.new
-    default.test.should eql("test")
-  end
-  it "should not intefer with setting" do
-    default = TestDefault.new
-    default.test = "New"
-    default.test.should eql("New")
-  end
   
-  context 'default value is a symbol' do
-    it "should call the method it describes" do
+  context "AVAILABLE_ATTRIBUTE_METHODS" do
+    SimpleModel::Attributes::ClassMethods::AVAILABLE_ATTRIBUTE_METHODS.each do |m,options|
+      it "should respond to #{m}" do
+        TestInit.respond_to?(m).should be_true
+      end
+      it "should respond to alias #{options[:alias]}" do
+        TestInit.respond_to?(options[:alias]).should be_true
+      end
+    end
+  end
+
+  context '#has_attribute' do
+    before(:all) do
       class TestDefault
         include SimpleModel::Attributes
-        attr_accessor :test
-        define_reader_with_options :test, :default => :default_value
+        has_attribute :foo, :default => "foo", :allow_blank => false
+        has_attribute :bar, :default => :default_value
+        has_attribute :fab, :default => :some_symbol
+        has_attribute :hop, :default => :default_hop, :allow_blank => false
+        has_attribute :tip, :default => "2", :initialize => false, :allow_blank => false
+        has_attribute :nap
+        has_attribute :my_array, :default => []
         def default_value
-          "test"
+          "bar"
+        end
+        
+        def default_hop
+          "hop" if nap
         end
       end
-      
-      default = TestDefault.new
-      default.test.should eql("test")
     end
-  end
-  
+    
+    before(:each) do
+      @default = TestDefault.new
+    end
 
-end
-describe SimpleModel::Attributes, 'has_booleans' do
-  before(:all) do
-    class TestBoolean
-      include SimpleModel::Attributes
-      has_booleans :test
+    it "should define setter method" do
+      @default.respond_to?(:foo=).should be_true
+    end
+  
+    it "should define reader/getter method" do
+      @default.respond_to?(:foo).should be_true
+    end
+    
+    context ':initialize => false' do
+      it "should not initialize with the default value" do
+        @default.attributes[:tip].should be_nil
+        @default.tip.should eql("2")
+      end
+      context "allow_blank => false"do
+        it "should not initialize, but should set the value on get" do
+          @default.attributes[:tip].should be_nil
+          @default.tip.should eql("2")
+        end
+      end
     end
+    
+    it "should call the method it describe by the default value if it exists" do 
+      @default.attributes[:bar].should eql("bar")
+    end
+    
+    it "should set the defaul to the supplied symbol, if the method does not exist" do 
+      @default.attributes[:fab].should eql(:some_symbol)
+    end
+    
+    it "should allow default value to be an empty array" do
+      @default.my_array.should eql([])
+    end
+    
+    it "should create a boolean? method for each attribute" do
+      @default.respond_to?(:foo?).should be_true
+    end
+    
+    it "should return !blank?" do
+      @default.my_array.should eql([]) # blank array
+      @default.my_array?.should be_false
+      @default.my_array << 1
+      @default.my_array?.should be_true
+    end
+    
+    it "should not allow blank if set" do
+      @default.foo.should eql("foo")
+      @default.foo = ""
+      @default.foo.should eql("foo")
+      @default.foo = "not blank"
+      @default.foo.should eql("not blank")
+    end
+    
+    it "should try for the default if its blank on get" do
+      @default.hop.blank?.should be_true
+      @default.nap = "yep"
+      @default.hop.should eql("hop")
+    end
+    
+    
   end
-
-  it "should add setter=, getter and getter? methods" do
-    methods = TestBoolean.new.methods
-    union = methods | [:test, :test=, :test?]
-    union.should eql(methods)
+  
+  context "on get" do
+    it "should perform on_get when set" do
+      class OnGet
+        include SimpleModel::Attributes
+        has_attribute :foo, :on_get => lambda{|obj,attr| (attr.blank? ? obj.send(:foo_default) : attr)}
+        
+        def foo_default
+          "test"
+        end
+      end
+      
+      new = OnGet.new
+      new.foo.should eql("test")
+      new.foo = "foo"
+      new.foo.should eql("foo")
+    end
   end
-
-end
-describe SimpleModel::Attributes, 'has_attributes' do
-  before(:all) do
-    class TestBoolean
-      include SimpleModel::Attributes
-      has_attributes :my_array, :default => []
+  
+  context 'if supplied value can be cast' do
+    it "should throw an exception" do  
+      class TestThrow
+        include SimpleModel::Attributes
+        has_booleans :boo
+      end 
+      
+      lambda{TestThrow.new(:boo => [])}.should raise_error(SimpleModel::ArgumentError)
     end
+        
   end
-
-  it "should allow default value to be an empty array" do
-    test = TestBoolean.new
-    test.my_array.should eql([])
+  
+  
+  after(:all) do
+    Object.send(:remove_const,:TestThrow)
+    Object.send(:remove_const,:OnGet)
+    Object.send(:remove_const,:TestDefault)
+    Object.send(:remove_const,:TestInit)
   end
-
-end
-
+end