mongoid-serializers 0.0.1.pre.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1cc56d2a1203878b42381e89515905fdbda3451a
+  data.tar.gz: 4fe3de42f00ecaff330e806b9730ad5064c210ef
+SHA512:
+  metadata.gz: eebe627e1b2d4c15ef87326f28b2821783998b11d0661e0e125f1e979978f5408b1bf9fc4bf3518042b42783a457a5ca9c31793666db8a714711db722b972b85
+  data.tar.gz: daf5a3e227eaef0f4df5a24193991af0be84a8b4f0a66be48757f9390c04c4eb79db892a6d943be667a63ae440555dc5cb2c303c338447b087e5d64cfa978a34

data/.gitignore

@@ -0,0 +1,15 @@
+git /.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+*.gem
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Giovanni Bonetti
+
+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,36 @@
+# Mongoid::Serializers
+
+A few useful serializers for Mongoid Attributes, like Date (YYYY-MM-DD) and Time (HH:mm)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mongoid-serializers'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mongoid-serializers
+
+## Usage
+
+In your model, specify the field like this:
+
+```ruby
+  field :date,  type: Mongoid::Serializers::Date
+  field :time,  type: Mongoid::Serializers::Time
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/giovannibonetti/mongoid-serializers/fork )
+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 a new Pull Request

data/Rakefile

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

data/lib/mongoid/serializers.rb

@@ -0,0 +1,18 @@
+# require "action_view/helpers"
+require "mongoid"
+require "mongoid/serializers/version"
+require "mongoid/serializers/date"
+require "mongoid/serializers/duration"
+require "mongoid/serializers/money"
+require "mongoid/serializers/percentage"
+require "mongoid/serializers/time"
+
+module Mongoid
+  module Serializers
+    # Nothing happens here -> each Serializer is independent
+    # eager_autoload do
+    #   autoload :Date
+    # end
+
+  end
+end

data/lib/mongoid/serializers/date.rb

@@ -0,0 +1,45 @@
+module Mongoid
+  module Serializers
+    class Date < ::Date
+
+      def mongoize
+        # puts "Instance.mongoize(#{self})"
+        self.strftime("%Y-%m-%d")
+      end
+
+      def to_s
+        self.strftime("%Y-%m-%d")
+      end
+
+      def as_json(*args)
+        self.strftime("%Y-%m-%d")
+      end
+
+      class << self
+        def mongoize(object)
+          # puts "Class.mongoize(#{object})"
+          case object
+          when self then object.mongoize
+          when String then
+            begin
+              self.parse(object).mongoize
+            rescue ArgumentError
+              nil
+            end
+          when Date then self.parse(object.to_s).mongoize
+          end
+        end
+
+        def demongoize(object)
+          # puts "Class.demongoize(#{object})"
+          self.parse(object) if object
+        end
+
+        def evolve(object)
+          mongoize(object)
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/serializers/duration.rb

@@ -0,0 +1,78 @@
+require 'mongoid/serializers/helpers'
+
+module Mongoid
+  module Serializers
+    class Duration
+
+      attr_reader :minutes
+
+      def initialize(minutes)
+        # puts "Class.initialize(#{minutes})"
+        @minutes = case minutes
+          when String then hhmm_to_minutes(minutes)
+          else minutes.to_i
+          end
+      end
+
+      def to_s
+        minutes.minutes.to_hhmm
+      end
+
+      def as_json(*args)
+        minutes
+      end
+
+      def seconds
+        (minutes * 60).seconds
+      end
+
+      def mongoize
+        # puts "Instance.mongoize(#{self})"
+        minutes
+      end
+
+      def nonzero?
+        minutes > 0
+      end
+
+      ## Arithmetic operators, Fixnum conversion
+      def coerce(other)
+        if other.is_a?(Fixnum)
+          [other, self.seconds]
+        else
+          super
+        end
+      end
+
+      # def +(other)
+      #   self.seconds + other
+      # end
+
+      class << self
+        def mongoize(object)
+          # puts "Class.mongoize(#{object})"
+          case object
+          when self then object.mongoize
+          else self.new(object).mongoize
+          end
+        end
+
+        def demongoize(object)
+          # puts "Class.demongoize(#{object})"
+          self.new(object) if object
+        end
+
+        def evolve(object)
+          mongoize(object)
+        end
+      end
+
+    private
+
+      def method_missing(method, *args, &block)
+        self.seconds.send(method, *args, &block)
+      end
+
+    end
+  end
+end

data/lib/mongoid/serializers/helpers.rb

@@ -0,0 +1,58 @@
+require 'active_support/core_ext/numeric' # from gem 'activesupport'
+# Nas funções abaixo, onde está escrito "seconds" você pode ler ActiveSupport do tipo (10.hours + 30.minutes)
+# pois o Active Support converte, por exemplo, 1.hour no número inteiro (Fixnum) 3600
+
+def hhmm_to_number(hhmm)
+  digits = hhmm.to_s.gsub(/\D/,"").gsub(/^0+/,"")
+  # Remoção de digitos demais do lado direito
+  digits = digits.slice(0, 4) if (digits.length > 4)
+  hours  = digits[0..-3].to_i
+  minutes = digits[-2..-1].to_i
+  hours * 3600 + minutes * 60
+end
+
+def hhmm_to_minutes(hhmm)
+  (hhmm_to_number(hhmm) / 60).to_i
+end
+
+def hhmm_to_seconds(hhmm)
+  hhmm_to_number(hhmm).seconds
+end
+
+def time_to_borel_interval(start_time=0, end_time=0, allow_night_shift=false)
+  start_time = hhmm_to_seconds(start_time) unless start_time.is_a? Fixnum
+  end_time = hhmm_to_seconds(end_time) unless end_time.is_a? Fixnum
+  raise Exception if (start_time > 24 * 3600) || (end_time > 24 * 3600) || (start_time < 0) || (end_time < 0)
+
+  # A duração do intervalo (.width) será sempre um número em (0.hours, 24.hours] (aberto no 0, fechado no 24)
+  if start_time < end_time
+    Interval[start_time.to_i, end_time.to_i]
+  elsif (start_time >= end_time) && allow_night_shift
+    Interval[start_time.to_i, (end_time.to_i + 24 * 3600)]
+  elsif (start_time == end_time) && (start_time == 0)
+    Interval[0, 24 * 3600] # Dia inteiro
+  else
+    return Interval[]
+  end
+end
+
+# Gera uma semana 'em torno de' date
+# Por padrão, a semana começa na segunda-feira
+def week_containing(date,start_on=1)
+  date = Date.parse(date) if date.is_a? String
+  week_start = date - (date.wday - start_on) % 7
+  # week_start = (date - start_on) - (date.wday - start_on) % 7
+  week = (0..6).map{|i| week_start + i}
+end
+
+# Gera um objeto DateTime a partir de um objeto Date/string e outro Time/string
+def DateTimefrom(dt,tm,utc=nil)
+  dt = Date.parse(dt) if dt.is_a?(String)
+  tm = Time.zone.parse(tm) if tm.is_a?(String)
+  _ = [dt.year, dt.month, dt.day, tm.hour, tm.min, tm.sec].map(&:to_i)
+  if utc
+    DateTime.new(*_, utc)
+  else
+    Time.zone.local(*_)
+  end
+end

data/lib/mongoid/serializers/money.rb

@@ -0,0 +1,112 @@
+# require 'action_view/helpers'
+
+module Mongoid
+  module Serializers
+    class Money
+      # include ActionView::Helpers::NumberHelper
+      include ::Comparable
+      attr_reader :money
+
+      def initialize(money)
+        @money =
+          case money
+          when Integer then money
+          when Float then (100 * money).round
+          when String then money.gsub(/\D/,'').gsub(/^0+(.*)/,'\1').to_i
+          else 0
+          end
+      end
+
+      # def to_s
+      #   number_to_currency(money / 100.0)
+      # end
+
+      def to_f
+        money / 100.0
+      end
+
+      def as_json(*args)
+        # In Javascript all numbers are floating point
+        money / 100.0
+      end
+
+      def mongoize
+        # puts "Instance.mongoize(#{self})"
+        money
+      end
+
+      def zero?
+        money == 0
+      end
+
+      def nonzero?
+        money > 0
+      end
+
+      ## Arithmetic operators
+      def coerce(other)
+        if other.is_a?(Numeric)
+          [other, self.money / 100.0]
+        else
+          super
+        end
+      end
+
+      def +(other)
+        self.class.new(self.to_f + other.to_f)
+      end
+
+      def -(other)
+        self.class.new(self.to_f - other.to_f)
+      end
+
+      def *(other)
+        if other.is_a?(Numeric) || other.is_a?(Mongoid::Serializers::Percentage)
+          self.class.new(self.to_f * other.to_f)
+        else
+          self.to_f * other.to_f
+        end
+      end
+
+      def /(other)
+        if other.is_a?(Numeric) || other.is_a?(Mongoid::Serializers::Percentage)
+          self.class.new(self.to_f / other.to_f)
+        else
+          self.to_f / other.to_f
+        end
+      end
+
+      def <=> (other)
+        self.to_f <=> other.to_f
+      rescue
+        nil
+      end
+
+      class << self
+        def mongoize(object)
+          # puts "Class.mongoize(#{object})"
+          case object
+          when self then object.mongoize
+          else self.new(object).mongoize
+          end
+        end
+
+        def demongoize(object)
+          # puts "Class.demongoize(#{object})"
+          self.new(object) if object
+        end
+
+        def evolve(object)
+          mongoize(object)
+        end
+      end
+
+    private
+
+      def method_missing(method, *args, &block)
+        self.new money.send(method, *args, &block)
+      end
+
+    end
+  end
+end

data/lib/mongoid/serializers/percentage.rb

@@ -0,0 +1,99 @@
+module Mongoid
+  module Serializers
+    class Percentage
+      attr_reader :percentage
+
+      def initialize(percentage)
+        @percentage =
+          case percentage
+          when Numeric then percentage
+          when String then 100 * eval( percentage.gsub(/[^\d\,\.%]/, '').gsub(',', '.').gsub('%', "/100.0") ).to_f
+          else 0
+          end
+
+        # Floating-point precision: 1 digit
+        @percentage = (10 * @percentage).round / 10.0
+      end
+
+      def to_s
+        "#{'%.1f' % percentage} %"
+      end
+
+      def to_f
+        percentage / 100.0
+      end
+
+      def as_json(*args)
+        percentage
+      end
+
+      def mongoize
+        # puts "Instance.mongoize(#{self})"
+        percentage
+      end
+
+      def nonzero?
+        percentage > 0
+      end
+
+      ## Arithmetic operators
+      def coerce(other)
+        if other.is_a?(Numeric)
+          [other, self.to_f]
+        else
+          super
+        end
+      end
+
+      def +(other)
+        if other.is_a?(self.class)
+          self.class.new(self.percentage + other.percentage)
+        else
+          other + self.to_f
+        end
+      end
+
+      def -(other)
+        self.class.new(100.0 * (self.to_f - other.to_f))
+      end
+
+      def *(other)
+        if other.is_a?(self.class) || other.is_a?(Numeric)
+          self.class.new(self.percentage * other.to_f)
+        else
+          other * self.to_f
+        end
+      end
+
+      def /(other)
+        self.class.new(100.0 * (self.to_f / other.to_f))
+      end
+
+      class << self
+        def mongoize(object)
+          # puts "Class.mongoize(#{object})"
+          case object
+          when self then object.mongoize
+          else self.new(object).mongoize
+          end
+        end
+
+        def demongoize(object)
+          # puts "Class.demongoize(#{object})"
+          self.new(object) if object
+        end
+
+        def evolve(object)
+          mongoize(object)
+        end
+      end
+
+    private
+
+      def method_missing(method, *args, &block)
+        self.class.new percentage.send(method, *args, &block)
+      end
+
+    end
+  end
+end

data/lib/mongoid/serializers/time.rb

@@ -0,0 +1,74 @@
+require 'mongoid/serializers/helpers'
+
+module Mongoid
+  module Serializers
+    class Time < ::Time
+      # Para obter os comportamentos Time.zone o ideal talvez fosse herdar de ActiveSupport::TimeWithZone
+
+      def mongoize
+        # puts "Instance.mongoize(#{self})"
+        self.strftime("%H:%M")
+      end
+
+      ## Arithmetic operators
+      def +(other)
+        if other.is_a?(Mongoid::Serializers::Duration)
+          self.class.parse (self.seconds + other.seconds).to_hhmm
+        elsif other.is_a?(Fixnum) # ActiveSupport -> duration -> seconds
+          self.class.parse (self.seconds + other).to_hhmm
+        else
+          super
+        end
+      end
+
+      def -(other)
+        if other.is_a?(self.class)
+          Mongoid::Serializers::Duration.new(self.minutes - other.minutes)
+        elsif other.is_a?(Mongoid::Serializers::Duration)
+          self.class.parse (self.seconds - other.seconds).to_hhmm
+        elsif other.is_a?(Fixnum) # ActiveSupport -> duration -> seconds
+          self.class.parse (self.seconds - other).to_hhmm
+        else
+          super
+        end
+      end
+
+      class << self
+        def mongoize(object)
+          # puts "Class.mongoize(#{object})"
+          case object
+          when self then object.mongoize
+          when String then self.parse(object).mongoize
+          when Time then self.parse(object.strftime("%H:%M")).mongoize
+          end
+        end
+
+        def demongoize(object)
+          # puts "Class.demongoize(#{object})"
+          self.parse(object) if object
+        end
+
+        def evolve(object)
+          mongoize(object)
+        end
+      end
+
+      def to_s
+        self.strftime("%H:%M")
+      end
+
+      def as_json(*args)
+        self.strftime("%H:%M")
+      end
+
+      def minutes
+        hhmm_to_minutes(self.to_s)
+      end
+
+      def seconds
+        hhmm_to_seconds(self.to_s)
+      end
+
+    end
+  end
+end

data/lib/mongoid/serializers/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module Serializers
+    VERSION = "0.0.1-rc1"
+  end
+end

data/mongoid-serializers.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongoid/serializers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mongoid-serializers"
+  spec.version       = Mongoid::Serializers::VERSION
+  spec.authors       = ["Giovanni Bonetti"]
+  spec.email         = ["giovanni.bonetti@gmail.com"]
+  spec.summary       = %q{A few useful serializers for Mongoid Attributes, like Date (YYYY-MM-DD) and Time (HH:mm).}
+  spec.description   = %q{If Mongoid default serializers for Date and Time don't work for you, try this out!}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.add_dependency 'mongoid', '>= 3.0'
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-serializers
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre.rc1
+platform: ruby
+authors:
+- Giovanni Bonetti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: If Mongoid default serializers for Date and Time don't work for you,
+  try this out!
+email:
+- giovanni.bonetti@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mongoid/serializers.rb
+- lib/mongoid/serializers/date.rb
+- lib/mongoid/serializers/duration.rb
+- lib/mongoid/serializers/helpers.rb
+- lib/mongoid/serializers/money.rb
+- lib/mongoid/serializers/percentage.rb
+- lib/mongoid/serializers/time.rb
+- lib/mongoid/serializers/version.rb
+- mongoid-serializers.gemspec
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A few useful serializers for Mongoid Attributes, like Date (YYYY-MM-DD) and
+  Time (HH:mm).
+test_files: []