recurify 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f67467f617bc9f0301b2adea071f0399f6764157
-  data.tar.gz: b1406f9990dc5ce45a8b176b623f7ade80d0c2de
+  metadata.gz: 4307b3688528bbcb1af64ae77bf4280a234add0e
+  data.tar.gz: e299a294802143fafa24566269bb99ff30e6cff7
 SHA512:
-  metadata.gz: 2866e6d97a2077b9161075adb1212aa83c6524f06a241b3803dd069c4c9c8a8c2e1d897834ffa612482689c662db88518fbf201174e0733d484320ae87b661c2
-  data.tar.gz: 41175f2ce891a1dbc2e3b522ebdba54f0d10cacfbbed277fd2454fe6ab4776cd2ccf36a6d9f49f0592c5322c12561b01791ce559a5170426187581aa2f18b107
+  metadata.gz: f5fc6cac84aab3d11c52258492b3fe5848cfa25be00157c6f9ecb8a46f2b66caf2a8df44e8f7c3c2784d48a0f54c266320dfcc43398b0d441d103004e981a6b7
+  data.tar.gz: 54ed94321f48ed1a6a6340b9f2851f2974d9633622e7be2a4d03a8f1adef3af57d2ccc32caee9b887f2e87e036166db44c99952e81152b6e831e3356a84fbb8e

data/README.md

@@ -7,8 +7,9 @@
 **Recurify is very much "work in progress" and shoudn't be used yet.**
 
 Recurify is a simple, light-weight, evaluator for Recurrence Rules. It takes a
-Recurrence Rule as input and returns an [`Enumerable`][enumerable], containing
-all [`Date`][date] objects resulting from this Rule in chronlogical order.
+`Rule` as input and returns an [`Enumerable`][enumerable], yielding all
+occurrences (i.e. simple [`Date`][date] objects) resulting from the `Rule`'s
+evaluation in chronlogical order.
 
 [enumerable]: http://ruby-doc.org/core-2.2.3/Enumerable.html
 [date]: http://ruby-doc.org/stdlib-2.2.3/libdoc/date/rdoc/Date.html
@@ -23,11 +24,11 @@ all [`Date`][date] objects resulting from this Rule in chronlogical order.
    * `F` - **F**eature commits with functional changes.  
      Example commit message: `F implement Rule#normalize`.
    * `B` - **B**ugfix commits for fixing broken stuff.  
-     Example commit message: `B consider Rule#count in Rule#==`
+     Example commit message: `B consider Rule#count in Rule#==`.
    * `R` - **R**efactoring commits without functional changes.  
      Example commit message: `R memoize Rule#normalize for performance`.
    * `C` - **C**hore commits are for everything else.  
-     Example commit message: `C upgrade to latest version of rubocop`.
+     Example commit message: `C bump version to 1.0.0`.
 
 Prefixed commit messages may seem a bit strange at first. The intention is
 simply to keep functional and non-functional changes clearly apart. Therefore,

data/lib/recurify/rule.rb

@@ -73,7 +73,7 @@ module Recurify
     # @param other [Rule]
     # @return [Boolean]
     def ==(other)
-      normalize.attributes == other.normalize.attributes
+      normalized_attributes == other.normalized_attributes
     end
 
     # Convert +self+ to a +Hash+, representing the same +Rule+. Note, that

data/lib/recurify/rule_analysis.rb

@@ -7,7 +7,7 @@ module Recurify
     #
     # @return [Boolean]
     def normalized?
-      Rule::BASE_FREQUENCIES.include?(frequency)
+      attributes == normalized_attributes
     end
 
     # Returns +true+ if +self+ is denormalized. By definition, a +Rule+ is
@@ -42,6 +42,13 @@ module Recurify
       !finite?
     end
 
+    # Returns +true+ if and only if +self+ evaluates to a single occurrence.
+    #
+    # @return [Boolean]
+    def one?
+      starts_on == normalized_ends_on
+    end
+
     # Returns +true+ if +self+ starts before or on +upper+. If +upper == nil+,
     # it is interpreted as "positive infinity". In that case, +#starts_before?+
     # always returns +true+, because all +Rule+ objects must have a finite

data/lib/recurify/rule_translation.rb

@@ -4,68 +4,78 @@ module Recurify
   module RuleTranslation # :nodoc:
     extend Forwardable
 
-    NORMALIZATION_MATRIX = {
-      # Normalization is a no-op for base-frequencies ...
+    # Applicable frequency minimizations grouped by +#frequency+ ...
+    FREQUENCY_MINIMIZATION_MATRIX = {
       'daily' =>     { target_frequency: 'daily',   interval_multiplier:  1 },
       'monthly' =>   { target_frequency: 'monthly', interval_multiplier:  1 },
-      # But, it is more interesting for sugar-frequencies ...
       'weekly' =>    { target_frequency: 'daily',   interval_multiplier:  7 },
       'quarterly' => { target_frequency: 'monthly', interval_multiplier:  3 },
       'yearly' =>    { target_frequency: 'monthly', interval_multiplier: 12 }
     }.freeze
 
-    DENORMALIZATION_MATRIX = {
+    # Applicable frequency maximizations grouped by +#frequency+ and ordered by
+    # decreasing preferability ...
+    FREQUENCY_MAXIMIZATION_MATRIX = {
       'daily' => [
-        # Applicable denormalizitions ordered by decreasing preferability ...
         { target_frequency: 'weekly',    interval_divisor:  7 },
         { target_frequency: 'daily',     interval_divisor:  1 }
       ],
       'weekly' => [
-        # Applicable denormalizitions ordered by decreasing preferability ...
         { target_frequency: 'weekly',    interval_divisor:  1 }
       ],
       'monthly' => [
-        # Applicable denormalizitions ordered by decreasing preferability ...
         { target_frequency: 'yearly',    interval_divisor: 12 },
         { target_frequency: 'quarterly', interval_divisor:  3 },
         { target_frequency: 'monthly',   interval_divisor:  1 }
       ],
       'quarterly' => [
-        # Applicable denormalizitions ordered by decreasing preferability ...
         { target_frequency: 'yearly',    interval_divisor:  4 },
         { target_frequency: 'quarterly', interval_divisor:  1 }
       ],
       'yearly' => [
-        # Applicable denormalizitions ordered by decreasing preferability ...
         { target_frequency: 'yearly',    interval_divisor:  1 }
       ]
     }.freeze
 
-    # Creates a new +Rule+, similar to +self+, but normalized. Note that
-    # +#normalize+ is idempotent.
+    # Creates a new +Rule+, similar to +self+, but with minimized +#frequency+.
+    # Note that +#minimize_frequency+ is idempotent.
     #
-    # Normalization means that +Rule+s with +#frequency+ ...
+    # Frequency minimization means that +Rule+s with +#frequency+ ...
     # * ... "weekly" are translated to +Rule+s with +#frequency+ "daily".
     # * ... "quarterly" are translated to +Rule+s with +#frequency+ "monthly".
     # * ... "yearly" are translated to +Rule+s with +#frequency+ "monthly".
     #
     # Additional translations may be added in the future.
     #
+    # @see FREQUENCY_MINIMIZATION_MATRIX
+    #
+    # @return [Rule]
+    def minimize_frequency
+      translate_with = FREQUENCY_MINIMIZATION_MATRIX[frequency]
+
+      substitute(
+        frequency: translate_with[:target_frequency],
+        interval:  interval * translate_with[:interval_multiplier]
+      )
+    end
+
+    # Creates a new +Rule+, similar to +self+, but normalized. Note that
+    # +#normalize+ is idempotent.
+    #
     # @todo This method is not yet complete, because +#normalize+ should also
-    #   minify the +#ends_on+ and +#count+ attributes (if possible).
+    #   minimize +#ends_on+ and +#count+ (if possible).
     #
     # @return [Rule]
     def normalize
-      @_normalized_rule ||= begin
-        translate_with = NORMALIZATION_MATRIX[frequency]
-
-        substitute(
-          frequency: translate_with[:target_frequency],
-          interval:  interval * translate_with[:interval_multiplier]
-        )
-      end
+      @_normalized_rule ||= minimize_frequency
     end
 
+    # @!method normalized_attributes
+    #   @see Rule#attributes
+    #   @see #normalize
+    #   @return [Hash<Symbol,Object>]
+    def_delegator :normalize, :attributes, :normalized_attributes
+
     # @!method normalized_frequency
     #   @see Rule#frequency
     #   @see #normalize
@@ -90,32 +100,48 @@ module Recurify
     #   @return [Date, nil]
     def_delegator :normalize, :ends_on, :normalized_ends_on
 
-    # Creates a new +Rule+, similar to +self+, but denormalized. Note that
-    # +#denormalized+ is idempotent.
+    # Creates a new +Rule+, similar to +self+, but with maximized +#frequency+.
+    # Note that +#maximize_frequency+ is idempotent.
     #
-    # Denormalizion means that +Rule+s with +#frequency+ ...
+    # Frequency maximization means that +Rule+s with +#frequency+ ...
     # * ... "daily" are translated to +Rule+s with +#frequency+ "weekly".
     # * ... "monthly" are translated to +Rule+s with +#frequency+ "yearly".
     # * ... "monthly" are translated to +Rule+s with +#frequency+ "quarterly".
     #
     # Additional translations may be added in the future.
     #
-    # Why +#denormalize+ at all? The idea is that denormalized +Rule+s are
-    # easier to parse for humans. For instance, "every 7th week" is easier to
-    # understand than "every 49th day".
+    # Why maximize the +#frequency+ at all? The idea is that frequency-maximized
+    # +Rule+s are easier to parse for humans. For instance, "every 7th week" is
+    # easier to understand than "every 49th day".
+    #
+    # @see FREQUENCY_MAXIMIZATION_MATRIX
     #
     # @return [Rule]
-    def denormalize
-      @_denormalized_rule ||= begin
-        translate_with = find_best_denormalization
-
-        substitute(
-          frequency: translate_with[:target_frequency],
-          interval:  interval / translate_with[:interval_divisor]
-        )
+    def maximize_frequency
+      translate_with = FREQUENCY_MAXIMIZATION_MATRIX[frequency].find do |c|
+        interval % c[:interval_divisor] == 0
       end
+
+      substitute(
+        frequency: translate_with[:target_frequency],
+        interval:  interval / translate_with[:interval_divisor]
+      )
+    end
+
+    # Creates a new +Rule+, similar to +self+, but denormalized. Note that
+    # +#denormalized+ is idempotent.
+    #
+    # @return [Rule]
+    def denormalize
+      @_denormalized_rule ||= maximize_frequency
     end
 
+    # @!method denormalized_attributes
+    #   @see Rule#attributes
+    #   @see #denormalize
+    #   @return [Hash<Symbol,Object>]
+    def_delegator :denormalize, :attributes, :denormalized_attributes
+
     # @!method denormalized_frequency
     #   @see Rule#frequency
     #   @see #denormalize
@@ -139,15 +165,5 @@ module Recurify
     #   @see #denormalize
     #   @return [Date, nil]
     def_delegator :denormalize, :ends_on, :denormalized_ends_on
-
-    private
-
-    # @see DENORMALIZATION_MATRIX
-    # @return [Hash<Symbol, Object>]
-    def find_best_denormalization
-      DENORMALIZATION_MATRIX[frequency].find do |contender|
-        normalize.interval % contender[:interval_divisor] == 0
-      end
-    end
   end
 end

data/lib/recurify/version.rb

@@ -1,3 +1,3 @@
 module Recurify # :nodoc:
-  VERSION = '0.0.2'.freeze
+  VERSION = '0.0.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: recurify
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Christoph Schiessl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-02 00:00:00.000000000 Z
+date: 2015-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec