motion-duration 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4cbcecf706355f4e25da91d2fb26273343e0dc5c
+  data.tar.gz: 5c27161964749bbcc3ddfd0a036ad8fb11e47a53
+SHA512:
+  metadata.gz: bcc4a70e1b9a18e8df7b374121a4d2fae377bdd20e265d381db0f202f67abd098f3a884c4f1e4987327cf30e497175b23f579b3f9c449464d9d5e353cda7a6ce
+  data.tar.gz: ee785e180abdd260d40080b06f41971d04794d087dc47b3881e5bf3dc34d33eb3e89654223e50a905dea1fa3876e2b9fe90266fb9105b29aea2d478d489f047a

data/README.md

@@ -0,0 +1,61 @@
+# motion-duration
+
+[![Build Status](https://travis-ci.org/OTGApps/motion-duration.svg)](https://travis-ci.org/OTGApps/motion-duration)
+
+Motion::Duration is an immutable type that represents some amount of time with accuracy in seconds.
+
+It was adapted for RubyMotion from [ruby-duration](https://github.com/peleteiro/ruby-duration) by Jose Peleteiro since it required ActiveRecord, iso8601, and i18n.
+
+This version currently lacks i18n, iso8601, and formatting support.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'motion-duration'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install motion-duration
+
+## Usage
+
+```ruby
+Duration.new(100) => #<Duration: minutes=1, seconds=40, total=100>
+Duration.new(:hours => 5, :minutes => 70) => #<Duration: hours=6, minutes=10, total=22200>
+```
+
+## 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
+
+## Original License
+
+Copyright (c) 2010 Jose Peleteiro
+
+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/lib/motion-duration.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+lib_dir_path = File.dirname(File.expand_path(__FILE__))
+Motion::Project::App.setup do |app|
+  app.files.unshift(Dir.glob(File.join(lib_dir_path, "project/**/*.rb")))
+end

data/lib/project/ext.rb

@@ -0,0 +1,5 @@
+class Integer
+  def duration_comparable_bool
+    self == 0
+  end
+end

data/lib/project/motion-duration.rb

@@ -0,0 +1,191 @@
+class Motion
+  class Duration
+    UNITS = [:seconds, :minutes, :hours, :days, :weeks]
+
+    MULTIPLES = {:seconds => 1,
+                 :minutes => 60,
+                 :hours   => 3600,
+                 :days    => 86400,
+                 :weeks   => 604800,
+                 :second  => 1,
+                 :minute  => 60,
+                 :hour    => 3600,
+                 :day     => 86400,
+                 :week    => 604800}
+
+    attr_reader :weeks, :days, :hours, :minutes, :seconds, :total
+
+    # Initialize a duration. 'args' can be a hash or anything else.  If a hash is
+    # passed, it will be scanned for a key=>value pair of time units such as those
+    # listed in the Duration::UNITS array or Duration::MULTIPLES hash.
+    #
+    # If anything else except a hash is passed, #to_i is invoked on that object
+    # and expects that it return the number of seconds desired for the duration.
+    def initialize(args = 0)
+      if args.kind_of?(Hash)
+        @seconds = 0
+        MULTIPLES.each do |unit, multiple|
+          unit = unit.to_sym
+          @seconds += args[unit].to_i * multiple if args.key?(unit)
+        end
+      # elsif args.kind_of?(String) and args[0] == 'P'
+      #   @seconds = ISO8601::Duration.new(args).to_seconds
+      else
+        @seconds = args.to_i
+      end
+
+      calculate!
+    end
+
+    # Compare this duration to another (or objects that respond to #to_i)
+    def <=>(other)
+      return false unless other.is_a?(Duration)
+      (@total <=> other.to_i).duration_comparable_bool
+    end
+
+    def +(other)
+      Duration.new(@total + other.to_i)
+    end
+
+    def -(other)
+      Duration.new(@total - other.to_i)
+    end
+
+    def *(other)
+      Duration.new(@total * other.to_i)
+    end
+
+    def /(other)
+      Duration.new(@total / other.to_i)
+    end
+
+    def %(other)
+      Duration.new(@total % other.to_i)
+    end
+
+    %w(minutes hours days).each do |meth|
+      define_method("total_#{meth}") { @total / MULTIPLES[meth.to_sym] }
+    end
+
+    # @return true if total is 0
+    def blank?
+      @total == 0
+    end
+
+    # @return true if total different than 0
+    def present?
+      !blank?
+    end
+
+    def negative?
+      @negative
+    end
+
+    # Format a duration into a human-readable string.
+    #
+    #   %w   => weeks
+    #   %d   => days
+    #   %h   => hours
+    #   %m   => minutes
+    #   %s   => seconds
+    #   %td  => total days
+    #   %th  => total hours
+    #   %tm  => total minutes
+    #   %ts  => total seconds
+    #   %t   => total seconds
+    #   %MP  => minutes with UTF-8 prime
+    #   %SP  => seconds with UTF-8 double-prime
+    #   %MH  => minutes with HTML prime
+    #   %SH  => seconds with HTML double-prime
+    #   %H   => zero-padded hours
+    #   %M   => zero-padded minutes
+    #   %S   => zero-padded seconds
+    #   %~s  => locale-dependent "seconds" terminology
+    #   %~m  => locale-dependent "minutes" terminology
+    #   %~h  => locale-dependent "hours" terminology
+    #   %~d  => locale-dependent "days" terminology
+    #   %~w  => locale-dependent "weeks" terminology
+    #   %tdu => total days with locale-dependent unit
+    #   %thu => total hours with locale-dependent unit
+    #   %tmu => total minutes with locale-dependent unit
+    #   %tsu => total seconds with locale-dependent unit
+    #
+    #
+    # def format(format_str)
+    #   identifiers = {
+    #     'w'  => @weeks,
+    #     'd'  => @days,
+    #     'h'  => @hours,
+    #     'm'  => @minutes,
+    #     's'  => @seconds,
+    #     'td' => Proc.new { total_days },
+    #     'th' => Proc.new { total_hours },
+    #     'tm' => Proc.new { total_minutes },
+    #     'ts' => @total,
+    #     't'  => @total,
+    #     'MP' => Proc.new { "#{@minutes}′"},
+    #     'SP' => Proc.new { "#{@seconds}″"},
+    #     'MH' => Proc.new { "#{@minutes}&#8242;"},
+    #     'SH' => Proc.new { "#{@seconds}&#8243;"},
+    #     'H'  => @hours.to_s.rjust(2, '0'),
+    #     'M'  => @minutes.to_s.rjust(2, '0'),
+    #     'S'  => @seconds.to_s.rjust(2, '0'),
+    #     '~s' => i18n_for(:second),
+    #     '~m' => i18n_for(:minute),
+    #     '~h' => i18n_for(:hour),
+    #     '~d' => i18n_for(:day),
+    #     '~w' => i18n_for(:week),
+    #     'tdu'=> Proc.new { "#{total_days} #{i18n_for(:total_day)}"},
+    #     'thu'=> Proc.new { "#{total_hours} #{i18n_for(:total_hour)}"},
+    #     'tmu'=> Proc.new { "#{total_minutes} #{i18n_for(:total_minute)}"},
+    #     'tsu'=> Proc.new { "#{total} #{i18n_for(:total)}"},
+    #   }
+
+    #   format_str.gsub(/%?%(w|d|h|m|s|t([dhms]u?)?|MP|SP|MH|SH|H|M|S|~(?:s|m|h|d|w))/) do |match|
+    #     match['%%'] ? match : (identifiers[match[1..-1]].class == Proc ? identifiers[match[1..-1]].call : identifiers[match[1..-1]])
+    #   end.gsub('%%', '%')
+    # end
+
+    alias_method :to_i, :total
+    # alias_method :strftime, :format
+
+  private
+
+    # Calculates the duration from seconds and figures out what the actual
+    # durations are in specific units.  This method is called internally, and
+    # does not need to be called by user code.
+    def calculate!
+      multiples = [MULTIPLES[:weeks], MULTIPLES[:days], MULTIPLES[:hours], MULTIPLES[:minutes], MULTIPLES[:seconds]]
+      units     = []
+      @negative = @seconds < 0
+      @total    = @seconds.abs.to_f.round
+      multiples.inject(@total) do |total, multiple|
+        # Divide into largest unit
+        units << total / multiple
+        total % multiple # The remainder will be divided as the next largest
+      end
+
+      # Gather the divided units
+      @weeks, @days, @hours, @minutes, @seconds = units
+    end
+
+    # def i18n_for(singular)
+    #   if singular == :total
+    #     fn_name = :total
+    #     singular = :second
+    #     plural = 'seconds'
+    #   elsif singular.to_s.start_with?('total_')
+    #     fn_name = "#{singular}s"
+    #     singular = singular.to_s['total_'.length..-1]
+    #     plural = "#{singular}s"
+    #   else
+    #     plural = "#{singular}s"
+    #     fn_name = plural
+    #   end
+    #   label = send(fn_name) == 1 ? singular : plural
+
+    #   I18n.t(label, :scope => :ruby_duration, :default => label.to_s)
+    # end
+
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: motion-duration
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mark Rickert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-02 00:00:00.000000000 Z
+dependencies:
+- !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'
+description: Motion::Duration is an immutable type that represents some amount of
+  time with accuracy in seconds.
+email:
+- mark@otgapps.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/motion-duration.rb
+- lib/project/ext.rb
+- lib/project/motion-duration.rb
+homepage: https://github.com/otgapps/motion-duration
+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.2.0
+signing_key: 
+specification_version: 4
+summary: Motion::Duration is an immutable type that represents some amount of time
+  with accuracy in seconds.
+test_files: []