unit4-checkout 0.1.3 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83982e7ddae1c09934ca1125ae9cfb0b0b8b845638fbce0eb19472137057652b
-  data.tar.gz: fb8982c906834e642dcaedbd81cdb89f258555c1dcbab7f73dc1387a9cd609fa
+  metadata.gz: 8fffe71c0723cfa6a79cc0061c0dd84bf59b2da58a5355a6711a4c4411f6e498
+  data.tar.gz: a7270ea6bcfdb6333afe24f16ed101962237bba4ff0c5c749add5cbe921f6a80
 SHA512:
-  metadata.gz: 514d5a25a55f090eb87ebcd5d49ce013b7638efa885e79dd59270c361bcb0462f929140706413d04624a5bfdfdad757f07648dc8403f188d72b07fe36b48bee3
-  data.tar.gz: 1721ec7136a1c447903ffbfdbad3ce2c7d0fea7ff11c19eed5ca57a5adfcdd3895b16d930d3a34a910dfd2a21ccf5dc08cf7d200f2945872ceb80502fa74b4da
+  metadata.gz: 4149594b3b6a036a6c3bea54bc01e900f49989e4a71ec10a79d2d05a8e2ee97a9a959fb3877d82791c27658b7bff6a59b286460dd2636c4c79e2683eeb5d5eb8
+  data.tar.gz: a805ebc11314abbf80714c132cae8f77b914c5918abd3c3d42e6284045603e845c4d00e57f894dbba7b7308a570f4b2a8377120f342da064bba06d0281e628f6

data/.rubocop.yml

@@ -11,3 +11,6 @@ Style/StringLiteralsInInterpolation:
 
 Layout/LineLength:
   Max: 120
+
+Metrics/BlockLength:
+  IgnoredMethods: ['describe', 'context']

data/Gemfile.lock

@@ -1,7 +1,9 @@
 PATH
   remote: .
   specs:
-    unit4-checkout (0.1.2)
+    unit4-checkout (0.2.2)
+      activerecord (~> 7.0.3)
+      erb
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,9 +1,3 @@
-# Unit4::Checkout
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/unit4/checkout`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
-
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -16,14 +10,48 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-TODO: Write usage instructions here
+Please note the gem relies on a database connection to the "products" table. Please make sure you have that table created and products have the 'price' attribute (float, non-nil).
+
+Create a Checkout instance with OPTIONAL promotional rules:
+
+```
+co = Checkout.new(promotional_rules)
+```
+The promotional rules need to have the following structure (note the "=>" after the item id that is used for a key):
+
+```
+promotional_rules = { product_discounts: { "001" => { count: 2, price: 8.50 } },
+                          total_price_discount: { price: 60.00, percent: 10 } }
+```
+
+Scanning items:
+
+```
+co.scan("001")
+```
+
+Access the total price:
+
+```
+co.total
+```
+
+## Testing
+
+The gem has its own database config and database for testing that complies with the requested format
+
+To run the test suite in the console using RSpec, run
+
+```
+rspec
+```
 
-## Development
+## Future work
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Use a user supplied database instead of the "products" one. Different attribute names for price can be incorporated too.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Test the gem thoroughly against a plain Ruby project. Environment will either be (most likely) non-existent there so some changes in the `Connection.non_rails_db_config` will be needed.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/unit4-checkout.
+Bug reports and pull requests are welcome on GitHub at https://github.com/BoyanGeorgiev96/unit4-checkout.

data/config/database.yml

@@ -0,0 +1,25 @@
+# SQLite. Versions 3.8.0 and up are supported.
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem "sqlite3"
+#
+default: &default
+  adapter: sqlite3
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  timeout: 5000
+
+development:
+  <<: *default
+  database: db/development.sqlite3
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  <<: *default
+  database: db/test.sqlite3
+
+production:
+  <<: *default
+  database: db/production.sqlite3

data/lib/unit4/checkout/basket.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
+# basket should probably be separated from the checkout, hence this class
 class Basket
   attr_accessor :items
 
   def initialize
     @items = {}
   end
-end
+end

data/lib/unit4/checkout/checkout.rb

@@ -1,72 +1,122 @@
 # frozen_string_literal: true
 
-require "active_record"
-require "erb"
-
+# the main class that is used for scaning the items and applying the discounts
 class Checkout
-  attr_reader :promotional_rules, :total, :basket, :price_discount_applied_flag, :result
+  attr_reader :total
 
-  # {product_discounts: {001: {count:2, price: 3.25}, 004: {count:2, price: 3.25}}, total_price_discount: $50}
-  def initialize(promotional_rules)
-    # maybe raise another error if keys aren't ids or total price, possibly total_item_count
-    raise TypeError, "expected a Hash, got #{promotional_rules.class.name}" unless promotional_rules.is_a? Hash
+  def initialize(promotional_rules = {})
+    # custom exceptions for incorrect Checkout.new({...}) parameters
+    raise PromotionalRulesTypeError, promotional_rules.class.name unless promotional_rules.is_a? Hash
+    raise PromotionalRulesForbiddenKeys unless correct_keys?(promotional_rules)
 
     @promotional_rules = promotional_rules
     @total = 0
     @basket = Basket.new
-    establish_connection
+    @saved_prices = {}
+    create_db_connection
   end
 
-  # maybe facilitate scanning multiple items at once
-  # no structure for item given, assumed id
+  # no structure for the item variable item given, assumed id from sample data input
   def scan(item)
-    # check for item id
     add_to_basket(item)
     calculate_total(item)
-    puts "#{item.capitalize} has been added to the basket successfully!"
+    puts "Item with ID '#{item}' has been added to the basket successfully!"
+  end
+
+  private
+
+  def correct_keys?(promotional_rules)
+    (promotional_rules.keys - %i[product_discounts total_price_discount]).empty?
   end
 
+  def create_db_connection
+    Connection.new
+  end
+
+  # add to total according to several criteria:
+  # is the total already discounted, is the item eligible for a discount based on the number of times it got scanned
+  # the function also decides whether both discounts or only one is required
+
   def calculate_total(item)
-    find_item_price(item)
-    item_price = 3
-    new_discount_available?(item) ? apply_discounts : @total += item_price
-    @total
+    item_price = item_price(item)
+    # use a hash to store seen non-discounted prices so the database is not queried when we already have the info
+    @saved_prices[item] ||= item_price
+    if @total_price_discount_applied_flag
+      item_discounted?(item) ? apply_item_and_total_discount(item, item_price) : apply_total_discount_on_item(item_price)
+    else
+      item_discounted?(item) ? apply_item_discount(item, item_price) : @total += item_price
+      # apply total discount if the last item moved the price sent the discount threshold
+      apply_total_discount if total_price_discounted?
+    end
+    @total = @total.round(2)
   end
 
-  def find_item_price(item)
-    query = "SELECT * FROM 'users' WHERE 'users'.'id' = ?"
-    sanitized_query = ActiveRecord::Base.sanitize_sql_array([query, item])
-    execute_statement(sanitized_query)
+  def item_price(item)
+    # Future work: facilitate DB table name different from products, i.e. ask gem user for db name
+    PriceQuery.new(item).find_price(@saved_prices)
   end
 
-  def apply_discounts; end
+  # apply both types of discounts at the same time
+  def apply_item_and_total_discount(item, item_price)
+    item_prom_rules = @promotional_rules[:product_discounts][item]
+    item_basket_count = @basket.items[item]
+    total_discount = (1 - @promotional_rules[:total_price_discount][:percent] / 100.00)
+    @total += item_and_total(item_basket_count, item_prom_rules, total_discount, item_price)
+  end
 
-  def new_discount_available?(item); end
+  # if it is the first time the specific item has been discounted we discount all its other instances
+  # no need to keep track of every item in-memory, so we just use the total count of the item to remove
+  # the old sum for this specific item and add the new discounted one
+  def item_and_total(item_basket_count, item_prom_rules, total_discount, item_price)
+    if item_basket_count == item_prom_rules[:count]
+      (item_basket_count * item_prom_rules[:price] - (item_basket_count - 1) * item_price) * total_discount
+    else
+      item_basket_count * item_prom_rules[:price] * total_discount
+    end
+  end
 
-  def execute_statement(sql)
-    results = ActiveRecord::Base.connection.exec_query(sql)
-    @result = results if results.present?
+  # used when only total discount is needed for a non-discounted scanned item, e.g. when the total sum is over $60.00
+  def apply_total_discount_on_item(item_price)
+    @total += item_price * (1 - @promotional_rules[:total_price_discount][:percent] / 100.00)
   end
 
-  def establish_connection
-    db_config = setup_db_config
-    ActiveRecord::Base.establish_connection(adapter: db_config["adapter"], database: db_config["database"])
+  # if item is not in the promotional rules returns false
+  # otherwise check if the item count in the basket is higher than the promotional rules threshold
+  def item_discounted?(item)
+    return false unless item_in_discounts?(item)
+
+    @basket.items[item] >= @promotional_rules[:product_discounts][item][:count]
   end
 
-  def setup_db_config
-    defined?(Rails) && defined?(Rails.env) ? rails_db_config : non_rails_db_config
+  def item_in_discounts?(item)
+    @promotional_rules[:product_discounts] && @promotional_rules[:product_discounts][item]
   end
 
-  def rails_db_config
-    Rails.application.config.database_configuration[Rails.env]
+  # only applies the specific item discount. same reasoning as the "item_and_total" function.
+  def apply_item_discount(item, item_price)
+    item_prom_rules = @promotional_rules[:product_discounts][item]
+    item_basket_count = @basket.items[item]
+    @total += if item_basket_count == item_prom_rules[:count]
+                item_basket_count * item_prom_rules[:price] - (item_basket_count - 1) * item_price
+              else
+                item_prom_rules[:price]
+              end
   end
 
-  def non_rails_db_config
-    # TODO: use current database instead of development
-    YAML.safe_load(ERB.new(File.read("./config/database.yml")).result, aliases: true)["development"]
+  def total_price_discounted?
+    return false unless total_price_in_discounts?
+
+    @total >= @promotional_rules[:total_price_discount][:price]
   end
 
-  # maybe add remove item function
+  def total_price_in_discounts?
+    @promotional_rules[:total_price_discount] && @promotional_rules[:total_price_discount][:price]
+  end
+
+  def apply_total_discount
+    @total *= (1 - @promotional_rules[:total_price_discount][:percent] / 100.00)
+    @total_price_discount_applied_flag = true
+  end
 
   def add_to_basket(item)
     @basket.items[item] ? @basket.items[item] += 1 : @basket.items[item] = 1

data/lib/unit4/checkout/connection.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "erb"
+
+# creates the connection for both Rails and non-Rails applications
+class Connection
+  def initialize
+    db_config = setup_db_config
+    ActiveRecord::Base.establish_connection(adapter: db_config["adapter"], database: db_config["database"])
+  end
+
+  def setup_db_config
+    # decide whether the application that uses the gem is a Rails one or a plain Ruby
+    defined?(Rails) && defined?(Rails.env) ? rails_db_config : non_rails_db_config
+  end
+
+  def rails_db_config
+    Rails.application.config.database_configuration[Rails.env]
+  end
+
+  def non_rails_db_config
+    # plain Ruby doesn't really have a sense of environments (unless a custom one has been set up)
+    # the development key will most likely be changed when the gem is used by a plain Ruby application
+    # the database db and config used here are samples from a Rails application, but this works with plain Ruby too
+    # Future work: test thoroughly on plain Ruby applications
+    YAML.safe_load(ERB.new(File.read("./config/database.yml")).result, aliases: true)["development"]
+  end
+end

data/lib/unit4/checkout/exceptions.rb

@@ -0,0 +1,16 @@
+# custom exception for when the user does not provide a hash
+class PromotionalRulesTypeError < TypeError
+  def initialize(class_name, msg = "expected a Hash, got ", exception_type = "custom")
+    msg << class_name
+    @exception_type = exception_type
+    super(msg)
+  end
+end
+
+# custom exception for when the hash has unaccceptable keys
+class PromotionalRulesForbiddenKeys < TypeError
+  def initialize(msg = "expected Hash with optional keys 'product_discounts' and 'total_price_discount", exception_type = "custom")
+    @exception_type = exception_type
+    super(msg)
+  end
+end

data/lib/unit4/checkout/price_query.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# used for querying the database for the non-discounted product price
+class PriceQuery
+  def initialize(item)
+    @sanitized_query = prepare_sql_statement(item)
+    @item = item
+  end
+
+  def prepare_sql_statement(item)
+    # Future work: facilitate DB table name different from products, i.e. ask gem user for db name
+    ActiveRecord::Base.sanitize_sql_array(["SELECT 'products'.'price' FROM 'products' WHERE 'products'.'id' = ?", item])
+  end
+
+  def find_price(saved_prices)
+    # grab the price from the hash if available
+    return saved_prices[@item] if saved_prices[@item]
+
+    results = ActiveRecord::Base.connection.exec_query(@sanitized_query)
+    results.rows.first.first if results.present?
+  end
+end

data/lib/unit4/checkout/version.rb

@@ -2,6 +2,6 @@
 
 module Unit4
   module Checkout
-    VERSION = "0.1.3"
+    VERSION = "0.2.2"
   end
 end

data/lib/unit4/checkout.rb

@@ -3,10 +3,11 @@
 require_relative "checkout/version"
 require_relative "checkout/checkout"
 require_relative "checkout/basket"
+require_relative "checkout/connection"
+require_relative "checkout/price_query"
+require_relative "checkout/exceptions"
 
 module Unit4
-  module Checkout
-    class Error < StandardError; end
-    # Your code goes here...
-  end
+  # the main module for the gem, no code really needed here with the current structure
+  module Checkout; end
 end

metadata

@@ -1,16 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: unit4-checkout
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.2
 platform: ruby
 authors:
 - Boyan Georgiev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-21 00:00:00.000000000 Z
-dependencies: []
-description: Initial commit
+date: 2022-07-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.3
+- !ruby/object:Gem::Dependency
+  name: erb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+description: A Ruby gem that helps the user implement a checkout system by supplying
+  only the promotional rules
 email:
 - bbgeorgiev96@gmail.com
 executables: []
@@ -23,13 +52,19 @@ files:
 - Gemfile.lock
 - README.md
 - Rakefile
+- config/database.yml
+- db/development.sqlite3
 - lib/unit4/checkout.rb
 - lib/unit4/checkout/basket.rb
 - lib/unit4/checkout/checkout.rb
+- lib/unit4/checkout/connection.rb
+- lib/unit4/checkout/exceptions.rb
+- lib/unit4/checkout/price_query.rb
 - lib/unit4/checkout/version.rb
 - sig/unit4/checkout.rbs
 homepage: https://github.com/BoyanGeorgiev96/unit4-checkout
-licenses: []
+licenses:
+- MIT
 metadata:
   allowed_push_host: https://rubygems.org/
   homepage_uri: https://github.com/BoyanGeorgiev96/unit4-checkout
@@ -52,5 +87,5 @@ requirements: []
 rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
-summary: Initial commit
+summary: Checkout gem for Unit4 technical task
 test_files: []