hashme 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2663088632661682c045a62e2674257dd342c568
-  data.tar.gz: 24af504823c262c52ab5c951ecceb8fa17a8f2ec
+  metadata.gz: b1baf318f249321f9486052a01db0881479f461c
+  data.tar.gz: f5b623806198098e2d5e4d6fa42c60cb6137498e
 SHA512:
-  metadata.gz: ffec5164dd1d0920674d067e1b1c1c354ed6db3333a0c003850f4cf847ef564ef236e0516c698f15d82f36ea8e167ff5f3d4f67c4126e633df080e4f0248df50
-  data.tar.gz: 99637e30e2c635a4955c3f461eef856bd8d1ace88619eab3f83aa0e3d9705b6495248add82ba9fc7a9e1230cb29cdec76d894e0757dba655c71932bf6eda1678
+  metadata.gz: 9bdfc2fea9f19cccd974a2a8d0b8cfad142bb91af0f35d1ba40a91f0fe0049ae085633d48f1abf9e67f211f6bbdb811bb6961e2ebf491f5858bdfcbc4494933b
+  data.tar.gz: 9e1b4fb53dde4cafd41b9e5917a7a7e12ea22b036cd330ae3eebf79b749a89897afe3f18bb346ad1e524ceb91a27f0af9e1e3a5be1e65d255ce983a6f7ca26d2

data/.rspec

@@ -0,0 +1 @@
+--colour

data/README.md

@@ -33,16 +33,18 @@ class Cat
 
   property :name,        String
   property :description, String
+  property :dob,         Date
 end
 
 # Do something with it
-kitty = Cat.new(:name => "Catso", :description => "Meows a lot")
+kitty = Cat.new(:name => "Catso", :description => "Meows a lot", :dob => '2012-02-03')
 kitty.name     # Catso
-kitty.to_hash  # {:name => "Catso", :description => "Meows a lot"}
-kitty.to_json  # "{\"name\":\"Catso\",\"description\":\"Meows a lot\"}"
+kitty.to_hash  # {:name => "Catso", :description => "Meows a lot", :dob => "2012-02-03"}
+kitty.to_json  # "{\"name\":\"Catso\",\"description\":\"Meows a lot\",\"dob\":\"2012-02-03\"}"
 
 kitty2 = Cat.new(kitty.to_hash)
 kitty2.to_hash == kitty.to_hash  # true!
+kitty2.dob.is_a?(Date)           # true!
 ````
 
 Models can also be nested, which is probably the most useful part:
@@ -75,6 +77,24 @@ kennel = Kennel.new(store)
 kennel.cats.length == 2    # true!
 ````
 
+Active Model Validation is included out the box:
+
+````ruby
+class User
+  include Hashme
+
+  property :name,      String
+  property :email,     String
+
+  validates :name, :email, presence: true
+end
+
+u = User.new(name: "Sam")
+u.valid?           # false !
+u.errors.first     # [:email, "can't be blank"]
+````
+
+
 ## Contributing
 
 1. Fork it
@@ -89,10 +109,16 @@ kennel.cats.length == 2    # true!
 
 ## History
 
+### 0.2.0 - 2016-06-02
+
+ * Added support for advanced type casting, copy stuff from CouchRest Model.
+ * Upgrade to latest rspec version.
+ * Removed `Property#cast` and switch to just `Property#build`.
+
 ### 0.1.2 - 2014-03-10
 
  * Set default property values on object initialization.
- * Refactoring to use `class_atrribute` for properties hash for improved inheritance.
+ * Refactoring to use `class_attribute` for properties hash for improved inheritance.
 
 ### 0.1.1 - 2014-01-21
  

data/lib/hashme.rb

@@ -16,6 +16,7 @@ require "hashme/castable"
 require "hashme/casted_array"
 require "hashme/properties"
 require "hashme/property"
+require "hashme/property_casting"
 
 module Hashme
   extend ActiveSupport::Concern

data/lib/hashme/casted_array.rb

@@ -20,7 +20,7 @@ module Hashme
       :encode_json, :as_json, :to_json,
       :inspect, :any?
 
-    def initialize(owner, property, values = [])
+    def initialize(property, owner, values = [])
       @_array = []
       self.casted_by = owner
       self.casted_by_property = property
@@ -54,7 +54,7 @@ module Hashme
     protected
 
     def instantiate_and_build(obj)
-      casted_by_property.build(casted_by, obj)
+      casted_by_property.build(self, obj)
     end
 
   end

data/lib/hashme/properties.rb

@@ -16,7 +16,7 @@ module Hashme
       if property.nil?
         self[name.to_sym] = value
       else
-        self[property.name] = value.present? ?  property.cast(self, value) : value
+        self[property.name] = property.build(self, value)
       end
     end
 

data/lib/hashme/property.rb

@@ -1,24 +1,22 @@
 module Hashme
   class Property
 
-    attr_accessor :name, :type, :default
+    attr_reader :name, :type, :default, :array
 
     def initialize(name, type, opts = {})
-      self.name = name.to_sym
+      @name = name.to_sym
 
       # Always set type to base type
       if type.is_a?(Array) && !type.first.nil?
-        @_use_casted_array = true
-        klass = type.first
+        @array = true
+        @type = type.first
       else
-        @_use_casted_array = false
-        klass = type
+        @array = false
+        @type = type
       end
 
-      self.type = klass
-
       # Handle options
-      self.default = opts[:default]
+      @default = opts[:default]
     end
 
     def to_s
@@ -29,34 +27,13 @@ module Hashme
       name
     end
 
-    # Use cast method when we do not know if we may need to handle a
-    # casted array of objects.
-    def cast(owner, value)
-      if use_casted_array?
-        CastedArray.new(owner, self, value)
-      else
-        build(owner, value)
-      end
-    end
-
     # Build a new object of the type defined by the property.
-    # Will not deal create CastedArrays!
     def build(owner, value)
-      obj   = nil
-      if value.is_a?(type)
-        obj = value
-      elsif type == Date
-        obj = type.parse(value)
+      if array && value.is_a?(Array)
+        CastedArray.new(self, owner, value)
       else
-        obj = type.new(value)
+        PropertyCasting.cast(self, owner, value)
       end
-      obj.casted_by = owner if obj.respond_to?(:casted_by=)
-      obj.casted_by_property = self if obj.respond_to?(:casted_by_property=)
-      obj
-    end
-
-    def use_casted_array?
-      @_use_casted_array
     end
 
   end

data/lib/hashme/property_casting.rb

@@ -0,0 +1,194 @@
+module Hashme
+
+  # Special property casting for reveiving data from sources without Ruby types, such as query
+  # parameters from an API or JSON documents.
+  #
+  # Most of this code is stolen from CouchRest Model typecasting, with a few simplifications.
+  module PropertyCasting
+    extend self
+
+    CASTABLE_TYPES = [String, Symbol, TrueClass, Integer, Float, BigDecimal, DateTime, Time, Date, Class]
+
+    # Automatically typecast the provided value into an instance of the provided type.
+    def cast(property, owner, value)
+      return nil if value.nil?
+      type = property.type
+      if value.instance_of?(type) || type == Object
+        value
+      elsif CASTABLE_TYPES.include?(type)
+        send('typecast_to_'+type.to_s.downcase, value)
+      else
+        # Complex objects we don't know how to cast
+        type.new(value).tap do |obj|
+          obj.casted_by = owner if obj.respond_to?(:casted_by=)
+          obj.casted_by_property = property if obj.respond_to?(:casted_by_property=)
+        end
+      end
+    end
+
+    protected
+
+    # Typecast a value to an Integer
+    def typecast_to_integer(value)
+      typecast_to_numeric(value, :to_i)
+    end
+
+    # Typecast a value to a BigDecimal
+    def typecast_to_bigdecimal(value)
+      typecast_to_numeric(value, :to_d)
+    end
+
+    # Typecast a value to a Float
+    def typecast_to_float(value)
+      typecast_to_numeric(value, :to_f)
+    end
+
+    # Convert some kind of object to a number that of the type
+    # provided.
+    #
+    # When a string is provided, It'll attempt to filter out
+    # region specific details such as commas instead of points
+    # for decimal places, text units, and anything else that is
+    # not a number and a human could make out.
+    #
+    # Esentially, the aim is to provide some kind of sanitary
+    # conversion from values in incoming http forms.
+    #
+    # If what we get makes no sense at all, nil it.
+    def typecast_to_numeric(value, method)
+      if value.is_a?(String)
+        value = value.strip.gsub(/,/, '.').gsub(/[^\d\-\.]/, '').gsub(/\.(?!\d*\Z)/, '')
+        value.empty? ? nil : value.send(method)
+      elsif value.respond_to?(method)
+        value.send(method)
+      else
+        nil
+      end
+    end
+
+    # Typecast a value to a String
+    def typecast_to_string(value)
+      value.to_s
+    end
+
+    def typecast_to_symbol(value)
+      value.is_a?(Symbol) || !value.to_s.empty? ? value.to_sym : nil
+    end
+
+    # Typecast a value to a true or false
+    def typecast_to_trueclass(value)
+      if value.kind_of?(Integer)
+        return true  if value == 1
+        return false if value == 0
+      elsif value.respond_to?(:to_s)
+        return true  if %w[ true  1 t ].include?(value.to_s.downcase)
+        return false if %w[ false 0 f ].include?(value.to_s.downcase)
+      end
+      nil
+    end
+
+    # Typecasts an arbitrary value to a DateTime.
+    # Handles both Hashes and DateTime instances.
+    # This is slow!! Use Time instead.
+    def typecast_to_datetime(value)
+      if value.is_a?(Hash)
+        typecast_hash_to_datetime(value)
+      else
+        DateTime.parse(value.to_s)
+      end
+    rescue ArgumentError
+      nil
+    end
+
+    # Typecasts an arbitrary value to a Date
+    # Handles both Hashes and Date instances.
+    def typecast_to_date(value)
+      if value.is_a?(Hash)
+        typecast_hash_to_date(value)
+      elsif value.is_a?(Time) # sometimes people think date is time!
+        value.to_date
+      elsif value.to_s =~ /(\d{4})[\-|\/](\d{2})[\-|\/](\d{2})/
+        # Faster than parsing the date
+        Date.new($1.to_i, $2.to_i, $3.to_i)
+      else
+        Date.parse(value)
+      end
+    rescue ArgumentError
+      nil
+    end
+
+    # Typecasts an arbitrary value to a Time
+    # Handles both Hashes and Time instances.
+    def typecast_to_time(value)
+      case value
+      when Float # JSON oj already parses Time, FTW.
+        Time.at(value).utc
+      when Hash
+        typecast_hash_to_time(value)
+      else
+        typecast_iso8601_string_to_time(value.to_s)
+      end
+    rescue ArgumentError
+      nil
+    rescue TypeError
+      nil
+    end
+
+    def typecast_iso8601_string_to_time(string)
+      if (string =~ /(\d{4})[\-\/](\d{2})[\-\/](\d{2})[T\s](\d{2}):(\d{2}):(\d{2}(\.\d+)?)(Z| ?([\+\s\-])?(\d{2}):?(\d{2}))?/)
+        # $1 = year
+        # $2 = month
+        # $3 = day
+        # $4 = hours
+        # $5 = minutes
+        # $6 = seconds (with $7 for fraction)
+        # $8 = UTC or Timezone
+        # $9 = time zone direction
+        # $10 = tz difference hours
+        # $11 = tz difference minutes
+
+        if $8 == 'Z' || $8.to_s.empty?
+          Time.utc($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_r)
+        else
+          Time.new($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_r, "#{$9 == '-' ? '-' : '+'}#{$10}:#{$11}")
+        end
+      else
+        Time.parse(string)
+      end
+    end
+
+    # Creates a DateTime instance from a Hash with keys :year, :month, :day,
+    # :hour, :min, :sec
+    def typecast_hash_to_datetime(value)
+      DateTime.new(*extract_time(value))
+    end
+
+    # Creates a Date instance from a Hash with keys :year, :month, :day
+    def typecast_hash_to_date(value)
+      Date.new(*extract_time(value)[0, 3].map(&:to_i))
+    end
+
+    # Creates a Time instance from a Hash with keys :year, :month, :day,
+    # :hour, :min, :sec
+    def typecast_hash_to_time(value)
+      Time.utc(*extract_time(value))
+    end
+
+    # Extracts the given args from the hash. If a value does not exist, it
+    # uses the value of Time.now.
+    def extract_time(value)
+      now = Time.now
+      [:year, :month, :day, :hour, :min, :sec].map do |segment|
+        typecast_to_numeric(value.fetch(segment, now.send(segment)), :to_i)
+      end
+    end
+
+    # Typecast a value to a Class
+    def typecast_to_class(value)
+      value.to_s.constantize
+    rescue NameError
+      nil
+    end
+
+  end
+end

data/lib/hashme/version.rb

@@ -1,3 +1,3 @@
 module Hashme
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/spec/hashme/attributes_spec.rb

@@ -22,21 +22,20 @@ describe Hashme::Attributes do
     end
 
     it "should assign some of the basic hash methods" do
-      (@obj == @hash).should be_true
-      @obj.eql?(@hash).should be_true
-      @obj.keys.should eql(@hash.keys)
-      @obj.values.should eql(@hash.values)
-      @obj.to_hash.should eql(@hash)
+      expect(@obj == @hash).to be_truthy
+      expect(@obj.keys).to eql(@hash.keys)
+      expect(@obj.values).to eql(@hash.values)
+      expect(@obj.to_hash).to eql(@hash)
     end
   end
 
   describe "#[]=" do
     it "should assign values to attributes hash" do
       @obj[:akey] = "test"
-      attribs[:akey].should eql("test")
+      expect(attribs[:akey]).to eql("test")
       @obj['akey'] = "anothertest"
-      attribs[:akey].should eql("anothertest")
-      attribs['akey'].should be_nil
+      expect(attribs[:akey]).to eql("anothertest")
+      expect(attribs['akey']).to be_nil
     end
   end
 
@@ -44,7 +43,7 @@ describe Hashme::Attributes do
     it "should remove attribtue entry" do
       @obj[:key] = 'value'
       @obj.delete(:key)
-      @obj[:key].should be_nil
+      expect(@obj[:key]).to be_nil
     end
   end
 
@@ -52,7 +51,7 @@ describe Hashme::Attributes do
     it "should duplicate attributes" do
       @obj[:key] = 'value'
       @obj2 = @obj.dup
-      @obj2.send(:_attributes).object_id.should_not eql(@obj.send(:_attributes).object_id)
+      expect(@obj2.send(:_attributes).object_id).to_not eql(@obj.send(:_attributes).object_id)
     end
   end
 
@@ -60,7 +59,7 @@ describe Hashme::Attributes do
     it "should clone attributes" do
       @obj[:key] = 'value'
       @obj2 = @obj.clone
-      @obj2.send(:_attributes).object_id.should_not eql(@obj.send(:_attributes).object_id)
+      expect(@obj2.send(:_attributes).object_id).to_not eql(@obj.send(:_attributes).object_id)
     end
   end
 
@@ -70,7 +69,7 @@ describe Hashme::Attributes do
     it "should provide something useful" do
       @obj[:key1] = 'value1'
       @obj[:key2] = 'value2'
-      @obj.inspect.should match(/#<.+ key1: "value1", key2: "value2">/)
+      expect(@obj.inspect).to match(/#<.+ key1: "value1", key2: "value2">/)
     end
 
   end