zillion 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 97bd070693be154816a594da56bcbd34e3b301d9
+  data.tar.gz: 4056c680b9d5daa7f370ded1082fd29a8b3223d2
+SHA512:
+  metadata.gz: c9518fc1995e843a57fb144abecb227d48465edd39e72101600b20fe595aa75b676952be2e4b29d79e3ed165e7c8bcc6926cae354687c25ef7aa9ce25163ed6f
+  data.tar.gz: b79c43fc71310b60779a092dafe9ba3c5d23ff764f6069abf191858105307e4a83adf46daebbab3e7c961adfdbb01fbaf2ce48de497fc0ef5c54c5edf4c31f15

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/mapper.rb

@@ -0,0 +1,203 @@
+require_relative './plan'
+
+module Zillion
+
+class PlanFinder
+
+  def self.init(mapper)
+    @mapper = mapper
+    self
+  end
+
+  def self.mapper
+    @mapper
+  end
+
+  def self.available_plans_for(counts)
+    mapper.all.select { |key, plan| plan.available_for?(counts) }
+  end
+
+  def self.unavailable_plans_for(counts)
+    mapper.all.select { |key, plan| !plan.available_for?(counts) }
+  end
+
+  def initialize(counts)
+    raise "Mapper not set!" if self.class.mapper.nil?
+    @counts = counts
+  end
+
+  def is_upgrade?(from, to)
+    compare(from, to, '<')
+  end
+
+  def is_downgrade?(from, to)
+    compare(from, to, '>')
+  end
+
+  def available_plans
+    # @available_plans ||=
+    self.class.available_plans_for(@counts)
+  end
+
+  def sorted_available_plans
+    sorted_keys = available_plans.keys.sort do |a,b|
+      mapper.get(a).monthly_fee_for(@counts) <=> mapper.get(b).monthly_fee_for(@counts)
+    end
+
+    sorted_keys.map { |key| mapper.get(key) }
+  end
+
+  def best_plan
+    return nil if available_plans.empty?
+    sorted_available_plans.first
+  end
+
+  private
+
+  def mapper
+    self.class.mapper
+  end
+
+  def compare(one, two, direction)
+    one = PlanMapper.get(one) unless one.is_a?(Plan)
+    two = PlanMapper.get(two) unless two.is_a?(Plan)
+    one.monthly_fee_for(@counts).send(direction, two.monthly_fee_for(@counts))
+  end
+
+end
+
+class PlanMapper
+
+  attr_accessor :plans
+
+  def initialize(specs, opts = {})
+    @plans = {}
+    specs.each do |key, spec|
+      add(key, Plan.factory({ name: key }.merge(deep_symbolize_keys(spec))))
+    end
+    plans.keys
+  end
+
+  def all
+    raise "Plans not loaded yet!" if plans.empty?
+    plans
+  end
+
+  def keys
+    plans.keys
+  end
+
+  def add(key, plan)
+    @plans[key.to_sym] = plan
+  end
+
+  def del(key)
+    plans.delete(key.to_sym)
+  end
+
+  def get(key)
+    raise "Please load first. No need to be an ass." if plans.empty?
+    plans[key.to_sym]
+  end
+
+  def exists?(key)
+    !!plans[key.to_sym]
+  end
+
+  def all_free
+    all.select { |plan| plan.is_a?(FreePlan) }
+  end
+
+  def all_paid
+    all.select { |plan| !plan.is_a?(FreePlan) }
+  end
+
+  private
+
+  def symbolize_keys(obj)
+    obj.inject({}) { |h, (k,v)| h[k.to_sym] = v; h }
+  end
+
+  def deep_symbolize_keys(obj)
+    symbolize_keys(obj).reduce({}) do |h, (k,v)|
+      new_val = v.is_a?(Hash) ? deep_symbolize_keys(v) : v
+      h.merge({k => new_val})
+    end
+  end
+
+=begin
+
+  def self.init(defs, levels = nil, mappings = {})
+    raise 'Already initialized!' if @defs
+    @levels, @mappings = levels, mappings
+    @defs   = deep_symbolize_keys(defs)
+    @levels = @defs.keys if @levels.nil?
+  end
+
+  def self.defs
+    @defs
+  end
+
+  def self.levels
+    @levels
+  end
+
+  def self.mappings
+    @mappings || {}
+  end
+
+  def self.all
+    @list ||= levels.collect { |key| self.get(key) }
+  end
+
+  def self.all_free
+    all.select { |plan| plan.is_a?(FreePlan) }
+  end
+
+  def self.all_paid
+    all.select { |plan| !plan.is_a?(FreePlan) }
+  end
+
+  def self.exists?(key)
+    !!index_of(key)
+  end
+
+  def self.is_upgrade?(from, to)
+    # Plan.new(from) < Plan.new(to)
+    index_of(from) < index_of(to)
+  end
+
+  def self.is_downgrade?(from, to)
+    # Plan.new(from) > Plan.new(to)
+    index_of(from) > index_of(to)
+  end
+
+  def self.get(key)
+    raise "Please initialize first" if @defs.nil?
+    key = map(key)
+
+    @@instances[key] ||= lambda do
+      raise "Plan not found: #{key}" if @defs[key].nil?
+      type = @defs[key][:type] || 'fixed'
+
+      klass = TYPES[type.to_s] or raise "Invalid type!"
+      Kernel.const_get('PlanMapper::' + klass).new(key, @defs[key])
+    end.call
+  end
+
+  private
+
+  def self.index_of(key)
+    levels.index(map(key))
+  end
+
+  # returns mapped plan key for older plans
+  def self.map(key)
+    mappings[key.to_sym] || key.to_sym
+  end
+
+=end
+
+end
+
+end

data/lib/plan.rb

@@ -0,0 +1,270 @@
+module Zillion
+
+class Plan
+
+  class PlanArgumentError < ArgumentError; end
+  class MissingCountError < PlanArgumentError; end
+  class OverLimitsError < PlanArgumentError; end
+  class InvalidFeeError < PlanArgumentError; end
+  class InvalidCountError < PlanArgumentError; end
+
+  class TierError < PlanArgumentError; end
+  class TierNotFoundError < TierError; end
+  class MultipleTiersFoundError < TierError; end
+
+  TYPES = {
+    'free'          => 'FreePlan',
+    'fixed'         => 'FixedPlan',
+    'custom'        => 'CustomPlan',
+    'tiered'        => 'TieredPlan',
+    'metered'       => 'MeteredPlan',
+    'fixed-metered' => 'FixedMeteredPlan'
+  }
+
+  def self.factory(spec)
+    unless type = spec[:type]
+      fee = spec[:monthly_fee].to_i
+      type = fee == 0 ? 'free' : fee > 0 ? 'fixed' : 'unknown'
+
+      type = 'fixed-metered' if type == 'fixed' && spec[:tiers]
+    end
+
+    klass = TYPES[type.to_s] or raise "Invalid type: #{type}"
+    Kernel.const_get('Zillion::' + klass).new(spec)
+  end
+
+  def initialize(spec = {})
+    @spec = spec
+  end
+
+  def name
+    spec[:name]
+  end
+
+  def has?(feature)
+    features.include?(feature.to_s) # features is an array of strings
+  end
+
+  def limit_for(what)
+    limits[what.to_sym]
+  end
+
+  def <=>(other_plan)
+    # other_plan = Plan.factory(other_plan) unless other_plan.is_a?(Plan)
+    self.monthly_fee <=> other_plan.monthly_fee
+  end
+
+  def amounts_for(counts)
+    { monthly_fee: monthly_fee }
+  end
+
+  def monthly_fee_for(counts)
+    ensure_available!(counts)
+    sum(amounts_for(counts))
+  end
+
+  def available_for?(counts)
+    limits.each do |key, limit|
+      val = counts[key] or raise MissingCountError.new("Count required for #{key}")
+      raise InvalidCountError.new("Negative count for #{key}: #{val}") if val.to_i < 0
+
+      return false if limit.to_i < val.to_i
+    end
+    true
+  end
+
+  def features
+    spec[:features] || []
+  end
+
+  def limits
+    spec[:limits] || {}
+  end
+
+  private
+
+  attr_reader :spec
+
+  def ensure_available!(counts)
+    unless available_for?(counts)
+      raise OverLimitsError.new("This plan has lower limits than: #{counts}")
+    end
+  end
+
+  def sum(amounts)
+    total = 0
+    amounts.each { |what, fee| total += fee }
+    total
+  end
+
+end
+
+class FreePlan < Plan
+
+  def monthly_fee
+    0
+  end
+
+end
+
+class FixedPlan < Plan
+
+  def monthly_fee
+    unless spec[:monthly_fee].is_a?(Numeric)
+      raise InvalidFeeError.new("Invalid monthly_fee: #{spec[:monthly_fee]}")
+    end
+
+    spec[:monthly_fee].to_f
+  end
+
+end
+
+class TieredPlan < Plan
+
+  def amounts_for(counts)
+    tier = matching_tier_for(counts)
+    obj = {}
+    obj[tier.last.to_sym] = tier[1]
+    obj
+  end
+
+  def matching_tier_for(counts)
+    if tiers = matching_tiers_for(counts) and tiers.any?
+      # raise "More than one tier matches for #{counts}" if tiers.count > 1
+      tiers.first
+    else
+      raise "No matching tiers found for #{counts.inspect} in #{name} plan."
+    end
+  end
+
+  def available_for?(counts)
+    super
+    matching_tiers_for(counts).any?
+  end
+
+  private
+
+  def matching_tiers_for(counts)
+    # sort by amount (format is [range, monthly_cost, index, type])
+    get_matching_tiers(counts).sort { |a, b| b[1] <=> a[1] }
+  end
+
+  def find_tier_for(tiers, units)
+    # raise "Units not set!" unless units
+    arr = tiers.select { |t| t[0].include?(units) }
+
+    if arr.empty?
+      raise TierNotFoundError.new("No matching tiers found for #{units} units.")
+    elsif arr.count > 1
+      raise MultipleTiersFoundError.new("Unit count is in more than one tier!")
+    end
+
+    arr.first # + [tiers.index(arr.first)]
+  end
+
+  def tier_groups
+    spec[:tiers].each_with_object({}) do |(key, list), obj|
+      obj[key] = list.map do |t|
+        h = symbolize_keys(t)
+        [ h[:from]..h[:to], h[tier_cost_key] ]
+      end
+    end
+  end
+
+  def tier_cost_key
+    :monthly_cost
+  end
+
+  def get_matching_tiers(counts)
+    tier_groups.map do |key, tiers|
+      units = counts[key] or raise "Unit count required for #{key}"
+      find_tier_for(tiers, units.to_i) + [key]
+    end.compact
+  end
+
+  def symbolize_keys(obj)
+    obj.inject({}) { |h, (k,v)| h[k.to_sym] = v; h }
+  end
+
+end
+
+class MeteredPlan < TieredPlan
+
+  def amounts_for(counts)
+    obj = {}
+    matching_tiers_for(counts).map do |tier|
+      units = units_for(tier.last, counts)
+      obj[tier.last.to_sym] = units * tier[1]
+    end
+
+    obj
+  end
+
+  def units_for(type, counts)
+    counts[type]
+  end
+
+  def tier_cost_key
+    :monthly_unit_cost
+  end
+
+end
+
+class FixedMeteredPlan < MeteredPlan
+
+  def amounts_for(counts)
+    obj = super
+    obj[:base_fee] = spec[:monthly_fee] ? spec[:monthly_fee].to_f : 0
+    obj
+  end
+
+  # a fixed tiered plan is available either if the count is below the fixed limit, or,
+  # if above that limit but a tier exists for that type
+  def available_for?(counts)
+    limits.each do |key, limit|
+      val = counts[key] or raise MissingCountError.new("Count required for #{key}")
+
+      # above limit, so see if a matching tier is found
+      if val.to_i <= limit.to_i # below limit
+        next
+      elsif tiers = tier_groups[key]
+        begin
+          find_tier_for(tiers, val.to_i)
+          next # tier found, so next one please
+        rescue TierError => e
+         # no tier found
+        end
+      end
+
+      return false
+    end
+
+    true
+  end
+
+  def units_for(type, counts)
+    units = counts[type]
+
+    # if a hard limit exists for that type, it means it's included
+    # so we should reduce the count of actual units
+    units -= limits[type] if limits[type]
+
+    units
+  end
+
+  def tier_cost_key
+    :monthly_unit_cost
+  end
+
+  def get_matching_tiers(counts)
+    tier_groups.map do |key, tiers|
+      units = counts[key] or raise "Unit count required for #{key}"
+      next if limits[key] and limits[key] > units.to_i
+
+      find_tier_for(tiers, units.to_i) + [key]
+    end.compact
+  end
+
+end
+
+end

data/spec/mapper_spec.rb

@@ -0,0 +1,77 @@
+require_relative '../lib/mapper'
+
+describe 'PlanMapper' do
+
+  describe '.load' do
+
+    it 'initializes plans and builds a map' do
+      specs = {
+        small: { monthly_fee: 0, limits: { products: 100 } },
+        large: { monthly_fee: 10, limits: { products: 200 } }
+      }
+
+      mapper = PlanMapper.new(specs)
+      expect(mapper.keys).to eql([:small, :large])
+    end
+
+  end
+
+end
+
+describe 'PlanFinder' do
+
+  let (:mapper) {
+    PlanMapper.new({
+      small: { monthly_fee: 0, limits: { products: 100 } },
+      large: { monthly_fee: 10, limits: { products: 200 } }
+    })
+  }
+
+  it 'explodes if no mapper set' do
+    expect { PlanFinder.new({}) }.to raise_error # MissingCountError
+  end
+
+  describe '#available_plans' do
+
+    it 'explodes if no limits passed' do
+      finder = PlanFinder.init(mapper).new({})
+      expect { finder.available_plans }.to raise_error Plan::MissingCountError
+    end
+
+    it 'explodes if limit doesnt match' do
+      finder = PlanFinder.init(mapper).new({ foo: 123 })
+      expect { finder.available_plans }.to raise_error Plan::MissingCountError
+    end
+
+    it 'returns empty object if over all limits' do
+      finder = PlanFinder.init(mapper).new({ products: 250 })
+      expect(finder.available_plans).to eql({})
+    end
+
+    it 'returns array with higher plan if over within both of them' do
+      finder = PlanFinder.init(mapper).new({ products: 150 })
+      expect(finder.available_plans).to eql({ large: mapper.get(:large) })
+    end
+
+    it 'returns array with both plans if under the lowest limit' do
+      finder = PlanFinder.init(mapper).new({ products: 50 })
+      expect(finder.available_plans).to eql(mapper.all)
+    end
+
+  end
+
+  describe '#best_plan' do
+
+    it 'returns nil if over all limits' do
+      finder = PlanFinder.init(mapper).new({ products: 250 })
+      expect(finder.best_plan).to eql(nil)
+    end
+
+    it 'returns lower plan if under the lowest limit' do
+      finder = PlanFinder.init(mapper).new({ products: 50 })
+      expect(finder.best_plan).to eql(mapper.get(:small))
+    end
+
+  end
+
+end

data/spec/plans_spec.rb

@@ -0,0 +1,489 @@
+require_relative '../lib/plan'
+include Zillion
+
+RSpec::Expectations.configuration.on_potential_false_positives = :nothing
+
+describe 'FreePlan' do
+
+  let(:plan) { FreePlan.new }
+
+  describe '#monthly_fee' do
+
+    it 'returns 0 as monthly_fee' do
+      expect(plan.monthly_fee).to eql(0)
+    end
+
+  end
+
+  describe '#monthly_fee_for(counts)' do
+
+    it 'returns 0 if no limits' do
+      expect(plan.monthly_fee_for({ apples: 10 })).to eql(0)
+    end
+
+    it 'returns 0 if within limits' do
+      other = FreePlan.new(limits: { bananas: 10 })
+      expect(other.monthly_fee_for({ bananas: 10 })).to eql(0)
+    end
+
+    it 'raises if not within limits' do
+      other = FreePlan.new(limits: { bananas: 10 })
+      expect { other.monthly_fee_for({ bananas: 11 }) }.to raise_error
+    end
+
+    it 'raises if not all counts present' do
+      other = FreePlan.new(limits: { bananas: 10, apples: 10 })
+      expect { other.monthly_fee_for({ apples: 5 }) }.to raise_error
+    end
+
+  end
+
+  describe '#available_for?(counts)' do
+
+    it 'returns true if no limits' do
+      expect(plan.available_for?({ bananas: 100 }) ).to eql(true)
+    end
+
+    it 'raises not all units for limits are fed' do
+      other = FreePlan.new(limits: { bananas: 10 })
+      expect { other.available_for?({ apples: 10 }) }.to raise_error
+    end
+
+    it 'returns false if limits/units match, but over the limit' do
+      other = FreePlan.new(limits: { bananas: 10 })
+      expect(other.available_for?({ bananas: 20 })).to eql(false)
+    end
+
+    it 'returns true if limits/units match, and within the limit' do
+      other = FreePlan.new(limits: { bananas: 10, apples: 10 })
+      expect(other.available_for?({ bananas: 5, apples: 2 })).to eql(true)
+    end
+
+  end
+
+end
+
+describe 'FixedPlan' do
+
+  let(:plan) { FixedPlan.new(monthly_fee: 10) }
+
+  describe '#monthly_fee' do
+
+    it 'raises if monthly_fee not set' do
+      other = FixedPlan.new(limits: { bananas: 10 })
+      expect { other.monthly_fee }.to raise_error
+    end
+
+    it 'returns monthly_fee, if present' do
+      expect(plan.monthly_fee).to eql(10.0)
+    end
+
+  end
+
+  describe '#monthly_fee_for(counts)' do
+
+    it 'returns monthly_fee if no limits' do
+      expect(plan.monthly_fee_for({ apples: 10 })).to eql(10.0)
+    end
+
+    it 'returns monthly_fee if within limits' do
+      other = FixedPlan.new(monthly_fee: 10, limits: { bananas: 10 })
+      expect(other.monthly_fee_for({ bananas: 10 })).to eql(10.0)
+    end
+
+    it 'raises if not within limits' do
+      other = FixedPlan.new(monthly_fee: 10, limits: { bananas: 10 })
+      expect { other.monthly_fee_for({ bananas: 11 }) }.to raise_error
+    end
+
+    it 'raises if not all counts present' do
+      other = FixedPlan.new(monthly_fee: 10, limits: { bananas: 10, apples: 10 })
+      expect { other.monthly_fee_for({ apples: 5 }) }.to raise_error
+    end
+
+  end
+
+  describe '#available_for?(counts)' do
+
+    it 'returns true if no limits' do
+      expect(plan.available_for?({ bananas: 100 }) ).to eql(true)
+    end
+
+    it 'raises not all units for limits are fed' do
+      other = FixedPlan.new(monthly_fee: 10, limits: { bananas: 10 })
+      expect { other.available_for?({ apples: 10 }) }.to raise_error
+    end
+
+    it 'returns false if limits/units match, but over the limit' do
+      other = FixedPlan.new(monthly_fee: 10, limits: { bananas: 10 })
+      expect(other.available_for?({ bananas: 20 })).to eql(false)
+    end
+
+    it 'returns true if limits/units match, and within the limit' do
+      other = FixedPlan.new(monthly_fee: 10, limits: { bananas: 10, apples: 10 })
+      expect(other.available_for?({ bananas: 5, apples: 2 })).to eql(true)
+    end
+
+  end
+
+end
+
+
+describe 'TieredPlan', 'Single tier' do
+
+  let(:plan) {
+    TieredPlan.new(
+      limits: { bananas: 10 },
+      tiers: {
+        products: [
+          { from: 0, to: 100, monthly_cost: 20 },
+          { from: 101, to: 200, monthly_cost: 30 },
+        ]
+      })
+  }
+
+  describe '#monthly_fee' do
+
+    it 'does not respond to it' do
+      expect { plan.monthly_fee }.to raise_error(NameError)
+    end
+
+  end
+
+  describe '#monthly_fee_for(counts)' do
+
+    it 'raises if missing unit for tier' do
+      expect { plan.monthly_fee_for({ bananas: 5 }) }.to raise_error
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.monthly_fee_for({ products: 25 }) }.to raise_error
+    end
+
+    it 'raises if not within limits' do
+      expect { plan.monthly_fee_for({ bananas: 5, products: -5 }) }.to raise_error
+    end
+
+    it 'returns monthly fee for tier if within its limit' do
+      expect(plan.monthly_fee_for({ bananas: 5, products: 25 })).to eql(20)
+    end
+
+  end
+
+  describe '#available_for?(counts)' do
+
+    it 'raises if missing unit for tier' do
+      expect { plan.available_for?({ bananas: 5 }) }.to raise_error
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.available_for?({ products: 25 }) }.to raise_error
+    end
+
+    it 'raises if not within limits' do
+      expect { plan.available_for?({ bananas: 5, products: -5 }) }.to raise_error
+    end
+
+    it 'returns monthly fee for tier if within its limit' do
+      expect(plan.available_for?({ bananas: 5, products: 25 })).to eql(true)
+    end
+
+  end
+
+end
+
+describe 'TieredPlan', 'Multiple tiers' do
+
+  let(:plan) {
+    TieredPlan.new(
+      limits: { bananas: 10 },
+      tiers: {
+        orders: [
+          { from: 0, to: 10, monthly_cost: 15 },
+          { from: 11, to: 20, monthly_cost: 35 }
+        ],
+        products: [
+          { from: 0, to: 100, monthly_cost: 20 },
+          { from: 101, to: 200, monthly_cost: 30 }
+        ]
+      })
+  }
+
+  describe '#monthly_fee' do
+
+    it 'does not respond to it' do
+      expect { plan.monthly_fee }.to raise_error(NameError)
+    end
+
+  end
+
+  describe '#monthly_fee_for(counts)' do
+
+    it 'raises if missing unit for tier' do
+      expect { plan.monthly_fee_for({ bananas: 5, products: 25 }) }.to raise_error
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.monthly_fee_for({ products: 25 }) }.to raise_error
+    end
+
+    it 'raises if not within limits' do
+      expect { plan.monthly_fee_for({ bananas: 5, products: -5 }) }.to raise_error
+    end
+
+    it 'returns monthly fee for tier if within its limit' do
+      expect(plan.monthly_fee_for({ bananas: 1, orders: 5, products: 25 })).to eql(20)
+    end
+
+  end
+
+  describe '#available_for?(counts)' do
+
+    it 'raises if missing unit for tier' do
+      expect { plan.available_for?({ bananas: 5 }) }.to raise_error
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.available_for?({ products: 25 }) }.to raise_error
+    end
+
+    it 'raises if not within limits' do
+      expect { plan.available_for?({ bananas: 5, products: -5 }) }.to raise_error
+    end
+
+    it 'returns monthly fee for tier if within its limit' do
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: 25 })).to eql(true)
+    end
+
+  end
+
+end
+
+describe 'MeteredPlan', 'Single tier' do
+
+  let(:plan) {
+    MeteredPlan.new(
+      limits: { bananas: 10 },
+      tiers: {
+        products: [
+          { from: 0, to: 100, monthly_unit_cost: 2 },
+          { from: 101, to: 200, monthly_unit_cost: 1.5 }
+        ]
+      })
+  }
+
+  describe '#monthly_fee' do
+
+    it 'does not respond to it' do
+      expect { plan.monthly_fee }.to raise_error(NameError)
+    end
+
+  end
+
+  describe '#monthly_fee_for(counts)' do
+
+    it 'raises if missing unit for tier' do
+      expect { plan.monthly_fee_for({ bananas: 5 }) }.to raise_error
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.monthly_fee_for({ products: 25 }) }.to raise_error
+    end
+
+    it 'raises if not within limits' do
+      expect { plan.monthly_fee_for({ bananas: 5, products: -5 }) }.to raise_error
+    end
+
+    it 'returns monthly fee for tier if within its limit' do
+      expect(plan.monthly_fee_for({ bananas: 5, products: 25 })).to eql(50)
+    end
+
+  end
+
+  describe '#available_for?(counts)' do
+
+    it 'raises if missing unit for tier' do
+      expect { plan.available_for?({ bananas: 5 }) }.to raise_error
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.available_for?({ products: 25 }) }.to raise_error
+    end
+
+    it 'raises if not within limits' do
+      expect { plan.available_for?({ bananas: 5, products: -5 }) }.to raise_error
+    end
+
+    it 'returns monthly fee for tier if within its limit' do
+      expect(plan.available_for?({ bananas: 5, products: 25 })).to eql(true)
+    end
+
+  end
+
+
+end
+
+describe 'MeteredPlan', 'Multiple tiers' do
+
+  let(:plan) {
+    MeteredPlan.new(
+      limits: { bananas: 10 },
+      tiers: {
+        orders: [
+          { from: 0, to: 10, monthly_unit_cost: 3 },
+          { from: 11, to: 20, monthly_unit_cost: 1 }
+        ],
+        products: [
+          { from: 0, to: 100, monthly_unit_cost: 2 },
+          { from: 101, to: 200, monthly_unit_cost: 1.5 }
+        ]
+      })
+  }
+
+  describe '#monthly_fee' do
+
+    it 'does not respond to it' do
+      expect { plan.monthly_fee }.to raise_error(NameError)
+    end
+
+  end
+
+  describe '#monthly_fee_for(counts)' do
+
+    it 'raises if missing unit for tier' do
+      expect { plan.monthly_fee_for({ bananas: 5 }) }.to raise_error
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.monthly_fee_for({ products: 25 }) }.to raise_error
+    end
+
+    it 'raises if not within limits' do
+      expect { plan.monthly_fee_for({ bananas: 5, products: -5 }) }.to raise_error
+    end
+
+    it 'returns monthly fee for tier if within its limit' do
+      expect(plan.monthly_fee_for({ bananas: 5, orders: 5, products: 25 })).to eql(65)
+    end
+
+  end
+
+  describe '#available_for?(counts)' do
+
+    it 'raises if missing unit for tier' do
+      expect { plan.available_for?({ bananas: 5 }) }.to raise_error
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.available_for?({ products: 25 }) }.to raise_error
+    end
+
+    it 'raises if not within limits' do
+      expect { plan.available_for?({ bananas: 5, products: -5 }) }.to raise_error
+    end
+
+    it 'returns monthly fee for tier if within its limit' do
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: 25 })).to eql(true)
+    end
+
+  end
+
+end
+
+describe 'FixedMeteredPlan' do
+
+  let(:plan_opts) {
+    obj = {
+      monthly_fee: 10,
+      limits: { bananas: 10, orders: 10, products: 10 },
+      tiers: {
+        orders: [
+          { from: 10, to: 15, monthly_unit_cost: 3 },
+          { from: 16, to: 20, monthly_unit_cost: 1 }
+        ],
+        products: [
+          { from: 5, to: 100, monthly_unit_cost: 2 },
+          { from: 101, to: 200, monthly_unit_cost: 1.5 }
+        ]
+      }
+    }
+  }
+
+  let(:plan) { FixedMeteredPlan.new(plan_opts) }
+
+  describe '#monthly_fee' do
+
+    it 'does not respond to it' do
+      expect { plan.monthly_fee }.to raise_error(NameError)
+    end
+
+  end
+
+  describe '#monthly_fee_for(counts)' do
+
+    it 'raises if missing unit for tier' do
+      expect { plan.monthly_fee_for({ bananas: 5 }) }.to raise_error
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.monthly_fee_for({ products: 5 }) }.to raise_error
+    end
+
+    it 'doent explode if negative key for tiered count, but under fixed limit' do
+      expect(plan.monthly_fee_for({ bananas: 5, orders: 5, products: -5 })).to eql(10.0)
+    end
+
+    it 'returns monthly fee for tier if below fixed limits' do
+      expect(plan.monthly_fee_for({ bananas: 5, orders: 5, products: 5 })).to eql(10.0)
+    end
+
+    it 'returns monthly fee for tier if within its limit' do
+      expect(plan.monthly_fee_for({ bananas: 5, orders: 5, products: 25 })).to eql(40.0)
+    end
+
+    it 'returns monthly fee for tier if within its limit' do
+      expect(plan.monthly_fee_for({ bananas: 5, orders: 15, products: 25 })).to eql(55.0)
+    end
+
+  end
+
+  describe '#available_for?(counts)' do
+
+    it 'raises if missing units for tier' do
+      expect { plan.available_for?({ bananas: 5 }) }.to raise_error
+    end
+
+    it 'raises if missing unit for fixed limit' do
+      expect { plan.available_for?({ products: 25 }) }.to raise_error
+    end
+
+    it 'doent explode if negative key for limit with tier' do
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: -5 })).to eql(true)
+    end
+
+    it 'returns true if below fixed limits' do
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: 5 })).to eql(true)
+    end
+
+    it 'returns true if below fixed limits, even if no matching tier exists' do
+      plan_opts[:tiers].delete(:products)
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: 5 })).to eql(true)
+    end
+
+    it 'returns false if above fixed limit and no tier found' do
+      plan_opts[:tiers].delete(:products)
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: 15 })).to eql(false)
+    end
+
+    it 'returns true if within its limit' do
+      expect(plan.available_for?({ bananas: 5, orders: 5, products: 15 })).to eql(true)
+    end
+
+    it 'returns true if within its limit' do
+      expect(plan.available_for?({ bananas: 5, orders: 15, products: 25 })).to eql(true)
+    end
+
+  end
+
+end
+

data/zillion.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+# require File.expand_path("../lib/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "zillion"
+  s.version     = '0.0.1'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Tomás Pollak']
+  s.email       = ['tomas@forkhq.com']
+  # s.homepage    = "https://github.com/tomas/zillion"
+  s.summary     = "A model for SaaS plans with fixed, tiered and metered pricing."
+  s.description = "A model for SaaS plans with fixed, tiered and metered pricing."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rspec", '~> 3.0', '>= 3.0.0'
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: zillion
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tomás Pollak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: A model for SaaS plans with fixed, tiered and metered pricing.
+email:
+- tomas@forkhq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/mapper.rb
+- lib/plan.rb
+- spec/mapper_spec.rb
+- spec/plans_spec.rb
+- zillion.gemspec
+homepage: 
+licenses: []
+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.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: A model for SaaS plans with fixed, tiered and metered pricing.
+test_files: []
+has_rdoc: