prezzo 0.5.1 → 1.0.0.pre.rc

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e9332660f2522054b623e1ba93eb6bce0d543d9
-  data.tar.gz: 7abe8f70afd7380d704db3dc114cefc4a71e5328
+  metadata.gz: 4409631f03de4a6dff3ebfbb48f25a0e4e9dcac4
+  data.tar.gz: ff6c4ec10622aeb9e924cbbe6b4c9b95dbd4a12d
 SHA512:
-  metadata.gz: aff27c50f0d088a92a1bb8bae5e077c3a662bccf045e4face9f48a4ca9c22bd2b0c64ddbb411695018d440a62fe1159dfc344698b3613ca783bffb148fe89415
-  data.tar.gz: 480cb54b37ee78b7428908025b3d580b74c8cd82feed2d47d65fbc50391f6793ff8a5d6771da90d2dc392d22ad753940a7b8543866b173e64cc8bd63648b77af
+  metadata.gz: 40cb9eead217c8009abbc86225913d3d099dc603a98a4c421d832d021267986d3995bc44033aff88856ee41fb7b378ba4e80ca3127390bdcc514656eda4f81aa
+  data.tar.gz: 1201e28ad3e1aa9e2a76c238c4b702e41038a12aa4088560aee8ca79bde0df99a060930023ec4b8a5c531692baf1d7524927a29740eaf64189c7e1719cd26c81

data/README.md

@@ -23,215 +23,223 @@ $ gem install prezzo
 
 ## Usage
 
-### Prezzo::Context
+### The calculation context
 
-
-The `Prezzo::Context` is a source of data for your calculators. Basically, it receives a hash of params and it validates its content, in order to make the calculations safe.
+`Prezzo::Context` is a source of data for your calculators. It receives a hash
+of params and makes them available to calculators.
 
 e.g.:
 
 ```ruby
-module Uber
-  class Context
-    include Prezzo::Context
-    CATEGORIES = ["UberX", "UberXL", "UberBlack"].freeze
-
-    validations do
-      required(:category).filled(included_in?: CATEGORIES)
-      required(:distance).filled(:float?)
-      required(:total_cars).filled(:int?)
-      required(:available_cars).filled(:int?)
-    end
-  end
-end
+context = Prezzo::Context.new(category: "Expensive", distance: 10.0)
+```
 
-context = Uber::Context.new(category: "UberBlack", ...)
+### Simple calculators
 
-# when valid
-context.valid?
-#=> true
+`Prezzo::Calculator` is the top level concept to describe calculations. Define
+a `formula` method that describe the calculation you want to perform and call
+the `calculate` method.
 
-# when invalid
-context.valid?
-#=> false
+e.g.:
+
+```ruby
+require "prezzo"
 
-context.errors
-# { distance: ["must be a float"]}
+class StaticCalculator
+  include Prezzo::Calculator
+
+  def formula
+    2 * 5
+  end
+end
+
+StaticCalculator.new.calculate
+#=> 10
 ```
 
-### Prezzo::Calculator
+### Accessing context params
 
-The `Prezzo::Calculator` is a simple interface for injecting dependencies on your calculators and calculating the price. Basically, it makes it possible to receive the context, an Hash of parameters containing the necessary information to calculate your price or a Prezzo::Context.
+Use the `param` dsl to create methods that read data from the context.
 
 e.g.:
 
 ```ruby
 require "prezzo"
 
-module Uber
-  class PricePerDistanceCalculator
-    include Prezzo::Calculator
-
-    def calculate
-      price_per_kilometer * distance
-    end
+class Multiplier
+  include Prezzo::Calculator
 
-    def price_per_kilometer
-      1.30
-    end
+  param :arg1
+  param :arg2
 
-    def distance
-      context.fetch(:distance)
-    end
+  def formula
+    arg1 * arg2
   end
 end
 
-context = Uber::Context.new(distance: 10.0)
-Uber::PricePerDistanceCalculator.new(context).calculate
+context = Prezzo::Context.new(arg1: 2, arg2: 10.0)
+Multiplier.new(context).calculate
 #=> 20.0
 ```
 
-**Context Validation**
+### Default params
 
-If you initialize the context with a hash, it will skip the validation, however, any object that responds to `.valid?` will attempt a validation, and it will fail if valid? returns false.
-
-### Prezzo::Composable
-
-The `Prezzo::Composable` module is an abstraction that provides a nice way of injecting other calculators define how the price will be composed with all of those calculators.
+The `param` dsl accepts a default value:
 
 e.g.:
 
 ```ruby
 require "prezzo"
 
-module Uber
-  class RidePriceCalculator
-    include Prezzo::Calculator
-    include Prezzo::Composable
+class OptionalCalculator
+  include Prezzo::Calculator
 
-    composed_by base_fare: BaseFareCalculator,
-                price_per_distance: PricePerDistanceCalculator,
+  param :optional, default: 10.0
 
-    def calculate
-      base_fare + price_per_distance
-    end
+  def formula
+    optional * 3
   end
 end
 
-context = Uber::Context.new(distance: 10.0)
-Uber::RidePriceCalculator.new(context).calculate
-#=> 47.3
+context = Prezzo::Context.new(arg1: 2, arg2: 10.0)
+OptionalCalculator.new(context).calculate
+#=> 30.0
 ```
 
-### Prezzo::Explainable
+### Nested context params
 
-The `Prezzo::Explainable` module is an abstraction that provides a nice way of representing how the price was composed.
+The `param` dsl can take a block to access nested data in the context.
 
 e.g.:
 
 ```ruby
 require "prezzo"
 
-module Uber
-  class RidePriceCalculator
-    include Prezzo::Calculator
-    include Prezzo::Composable
-    include Prezzo::Explainable
+class NestedCalculator
+  include Prezzo::Calculator
 
-    composed_by base_fare: BaseFareCalculator,
-                price_per_distance: PricePerDistanceCalculator,
-    explain_with :base_fare, :price_per_distance
+  param :level1 do
+    param :level2
+  end
 
-    def calculate
-      base_fare + price_per_distance
-    end
+  def formula
+    level1.level2 * 2
   end
 end
 
-context = Uber::Context.new(distance: 10.0)
-Uber::RidePriceCalculator.new(context).explain
-#=> { total: 25.6, components: { base_fare: 4.3, price_per_distance: 21.3 } }
+context = Prezzo::Context.new(level1: { level2: 10.0 })
+NestedCalculator.new(context).calculate
+#=> 20.0
 ```
 
-#### Multiline `explain_with`
+### Composing calculators
 
-`explain_with` can be splitted into several lines.
+Calculators provide the `component` dsl method to make it easy to compose
+calculators. Each calculator will be defined as a method in the calculator.
+They will receive the whole context on instantiation.
+
+e.g.:
 
 ```ruby
-class RidePriceCalculator
-  include Prezzo::Explainable
+require "prezzo"
+
+class ComposedCalculator
+  include Prezzo::Calculator
+
+  component :calculator1, StaticCalculator
+  component :calculator2, Multiplier
 
-  explain_with :base_fare
-  explain_with :price_per_distance
+  def formula
+    calculator1 + calculator2
+  end
 end
+
+context = Prezzo::Context.new(arg1: 2, arg2: 10.0)
+ComposedCalculator.new(context).calculate
+#=> 30.0
 ```
 
-#### ` explain_with` with the `recursive: false` option
+### Restricting the context
+
+You can restrict the context of each calculator by providing a third argument
+to `components`:
+
+e.g.:
 
 ```ruby
-class FooCalculator
+require "prezzo"
+
+class RestrictedCalculator
   include Prezzo::Calculator
-  include Prezzo::Explainable
 
-  explain_with :bar, :baz
+  component :calculator1, Multiplier, :side1
+  component :calculator2, Multiplier, :side2
 
-  def calculate
-    bar + baz
+  def formula
+    calculator1 + calculator2
   end
+end
 
-  def bar
-    10
-  end
+context = Prezzo::Context.new(side1: { arg1: 2, arg2: 10.0 }, side2: { arg1: 3, arg2: 20.0 })
+RestrictedCalculator.new(context).calculate
+#=> 80.0
+```
 
-  def baz
-    20
-  end
-end
+### Explanations
 
-class QuxCalculator
-  include Prezzo::Calculator
-  include Prezzo::Composable
-  include Prezzo::Explainable
+The `explain` method provides a nice way of representing how the price was
+composed. It will include all params and components defined in the calculator.
 
-  composed_by foo: FooCalculator
+e.g.:
 
-  explain_with :foo, recursive: false
+```ruby
+require "prezzo"
+
+class ExplainableCalculator
+  include Prezzo::Calculator
 
-  def calculate
-    foo + 5
+  param :value
+  component :calculator1, StaticCalculator
+  component :calculator2, Multiplier
+
+  def formula
+    value + calculator1 + calculator2
   end
 end
+
+context = Prezzo::Context.new(value: 3, arg1: 2, arg2: 10.0)
+ExplainableCalculator.new(context).explain
+#=> { total: 33.0, context: { value: 3 }, components: { calculator1: { ... }, calculator2: { ... } } }
 ```
 
-`QuxCalculator#explain` now produces
+### Transient values
+
+Intermediate calculation values that you would like to appear on the
+explanation can be defined with the `transient` dsl:
 
 ```ruby
-{
-  total: 35,
-  components: {
-    foo: 30
-  }
-}
-```
+require "prezzo"
 
-but not
+class TransientCalculator
+  include Prezzo::Calculator
 
-```ruby
-{
-  total: 35,
-  components: {
-    foo: {
-      total: 30,
-      components: {
-        bar: 10,
-        baz: 20
-      }
-    }
-  }
-}
-```
+  param :arg1
+  param :arg2
+  param :arg3
+
+  transient :intermediate do
+    arg1 + arg2
+  end
 
-Check the full [Uber pricing](/spec/integration/uber_pricing_spec.rb) for more complete example with many calculators and factors.
+  def formula
+    arg3 * intermediate
+  end
+end
+
+context = Prezzo::Context.new(arg1: 1, arg2: 2, arg3: 3)
+TransientCalculator.new(context).explain
+#=> { total: 9, context: { arg1: 1, arg2: 2, arg3: 3 }, transients: { intermediate: 3 } }
+```
 
 ## Development
 

data/lib/prezzo.rb

@@ -2,7 +2,9 @@ require "prezzo/version"
 
 module Prezzo
   autoload :Calculator, "prezzo/calculator"
-  autoload :Composable, "prezzo/composable"
+  autoload :ParamsDSL, "prezzo/params_dsl"
+  autoload :ComponentsDSL, "prezzo/components_dsl"
+  autoload :TransientDSL, "prezzo/transient_dsl"
   autoload :Context, "prezzo/context"
   autoload :Explainable, "prezzo/explainable"
 end

data/lib/prezzo/calculator.rb

@@ -1,22 +1,28 @@
 module Prezzo
   module Calculator
+    def self.included(base)
+      base.class_eval do
+        base.include(ParamsDSL)
+        base.include(ComponentsDSL)
+        base.include(TransientDSL)
+        base.include(Explainable)
+      end
+    end
+
     def initialize(context = {})
-      @context = validated!(context)
+      @context = context
     end
 
     def calculate
-      raise "Calculate not implemented"
+      @total ||= formula
+    end
+
+    def formula
+      raise "Formula not implemented"
     end
 
     private
 
     attr_reader :context
-
-    def validated!(context)
-      raise "Empty Context" if context.nil?
-      raise "Invalid Context" if context.respond_to?(:valid?) && !context.valid?
-
-      context
-    end
   end
 end

data/lib/prezzo/components_dsl.rb

@@ -0,0 +1,46 @@
+module Prezzo
+  module ComponentsDSL
+    def self.included(base)
+      base.class_eval do
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      def component(name, klass, sub_context_name = nil)
+        components << name
+
+        define_method(name) do
+          cached_components[name] ||=
+            begin
+              c = sub_context_name ? context.fetch(sub_context_name) : context
+
+              instance = klass.new(c)
+              instance.sub_context(sub_context_name) if sub_context_name
+              instance
+            end
+
+          cached_components[name].calculate
+        end
+      end
+
+      def components
+        @components ||= []
+      end
+    end
+
+    def compile_components
+      self.class.components.reduce({}) do |acc, name|
+        public_send(name) # force component cache
+        acc[name] = cached_components[name].explain
+        acc
+      end
+    end
+
+    private
+
+    def cached_components
+      @cached_components ||= {}
+    end
+  end
+end

data/lib/prezzo/context.rb

@@ -1,37 +1,23 @@
-require "hanami-validations"
-
 module Prezzo
-  module Context
-    def self.included(base)
-      base.class_eval do
-        base.include(Hanami::Validations)
-      end
-    end
-
-    def valid?
-      validation.success?
-    end
+  class Context
+    include ParamsDSL
 
-    def errors
-      validation.errors
+    def initialize(attributes)
+      @attributes = attributes
     end
 
     def fetch(key, default = nil)
-      if default.nil?
-        attributes.fetch(key)
+      value = @attributes.fetch(key, default)
+
+      if value.is_a?(Hash)
+        Class.new(Context).new(value)
       else
-        attributes.fetch(key, default) || default
+        value
       end
     end
 
-    def attributes
-      validation.output
-    end
-
-    private
-
-    def validation
-      @_validation ||= validate
+    def context
+      self
     end
   end
 end

data/lib/prezzo/explainable.rb

@@ -1,39 +1,18 @@
 module Prezzo
   module Explainable
-    def self.included(base)
-      base.class_eval do
-        base.extend(ClassMethods)
-      end
-    end
-
-    module ClassMethods
-      def explain_with(*component_names, **options)
-        @explained_components ||= {}
-        component_names.each do |component_name|
-          @explained_components[component_name] = options
-        end
-      end
-
-      attr_reader :explained_components
-    end
-
     def explain
-      explained_components = self.class.explained_components || {}
-
       explanation = {
         total: calculate,
-        components: {},
       }
 
-      explained_components.each do |component, options|
-        value = send(component)
-        if self.class.respond_to?(:components) && self.class.components.include?(component)
-          value = cached_components[component]
-        end
-        value = value.explain if value.respond_to?(:explain) && options.fetch(:recursive, true)
-        value = value.calculate if value.respond_to?(:calculate)
-        explanation[:components][component] = value
-      end
+      components = compile_components
+      explanation[:components] = components unless components.empty?
+
+      context = compile_params
+      explanation[:context] = context unless context.empty?
+
+      transients = compile_transients
+      explanation[:transients] = transients unless transients.empty?
 
       explanation
     end

data/lib/prezzo/params_dsl.rb

@@ -0,0 +1,55 @@
+module Prezzo
+  module ParamsDSL
+    def self.included(base)
+      base.class_eval do
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      def param(name, options = {}, &block)
+        params << name
+
+        define_method(name) do
+          cached_params[name] ||=
+            begin
+              value = context.fetch(name, options[:default])
+              value.class.class_eval(&block) if block
+              value
+            end
+        end
+      end
+
+      def params
+        @params ||= []
+      end
+    end
+
+    def compile_params
+      params = self.class.params.reduce({}) do |acc, name|
+        value = public_send(name)
+        value = value.compile_params if value.respond_to?(:compile_params)
+        acc[name] = value
+        acc
+      end
+
+      if @sub_context_name
+        {
+          @sub_context_name => params,
+        }
+      else
+        params
+      end
+    end
+
+    def sub_context(name)
+      @sub_context_name = name
+    end
+
+    private
+
+    def cached_params
+      @cached_params ||= {}
+    end
+  end
+end

data/lib/prezzo/transient_dsl.rb

@@ -0,0 +1,37 @@
+module Prezzo
+  module TransientDSL
+    def self.included(base)
+      base.class_eval do
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      def transient(name)
+        transients << name
+
+        define_method(name) do
+          cached_transients[name] ||= yield
+        end
+      end
+
+      def transients
+        @transients ||= []
+      end
+    end
+
+    def compile_transients
+      self.class.transients.reduce({}) do |acc, name|
+        public_send(name) # force transient cache
+        acc[name] = cached_transients[name]
+        acc
+      end
+    end
+
+    private
+
+    def cached_transients
+      @cached_transients ||= {}
+    end
+  end
+end

data/lib/prezzo/version.rb

@@ -1,3 +1,3 @@
 module Prezzo
-  VERSION = "0.5.1".freeze
+  VERSION = "1.0.0-rc".freeze
 end

data/prezzo.gemspec

@@ -17,7 +17,6 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "hanami-validations", "~> 1.0"
   spec.add_development_dependency "bundler", "~> 1.13"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: prezzo
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 1.0.0.pre.rc
 platform: ruby
 authors:
 - Marcelo Boeira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-17 00:00:00.000000000 Z
+date: 2017-06-20 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: hanami-validations
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -173,9 +159,11 @@ files:
 - bin/setup
 - lib/prezzo.rb
 - lib/prezzo/calculator.rb
-- lib/prezzo/composable.rb
+- lib/prezzo/components_dsl.rb
 - lib/prezzo/context.rb
 - lib/prezzo/explainable.rb
+- lib/prezzo/params_dsl.rb
+- lib/prezzo/transient_dsl.rb
 - lib/prezzo/version.rb
 - prezzo.gemspec
 homepage: http://github.com/marceloboeira/prezzo
@@ -192,12 +180,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Toolbox to create complex pricing models

data/lib/prezzo/composable.rb

@@ -1,33 +0,0 @@
-module Prezzo
-  module Composable
-    def self.included(base)
-      base.class_eval do
-        base.extend(ClassMethods)
-      end
-    end
-
-    module ClassMethods
-      def composed_by(options)
-        options.each do |name, klass|
-          components << name
-
-          define_method(name) do
-            cached_components[name] ||= klass.new(context)
-
-            cached_components[name].calculate
-          end
-        end
-      end
-
-      def components
-        @components ||= []
-      end
-    end
-
-    private
-
-    def cached_components
-      @cached_components ||= {}
-    end
-  end
-end