Done by @yonbergman and @avihut

SCIL 7 - DSL Exercise.py

# SCIL 7 - DSL Exercise in python
# done by @yonbergman and @avihut

# Usage:
# c = Cart()
# c.items()
# => [<foo(100)>,<bar(50)>]
# c.run_rules()
# c.items()
# => WIN


class Cart:
    def __init__(self):
        self.items = [Item('foo',100),Item('bar',50)]
        self.customer = 'vip'
    def run_rules(self):
        Rule(self).for_customers(['vip','not_vip']).discount(Percent(2))
        Rule(self).for_customers(['vip']).if_product('bar').for_product('foo').discount(Percent(25))
        Rule(self).for_customers(['not_vip']).discount(Percent(3))
        Rule(self).when_total(BiggerThan(100)).discount(Percent(5))

class Item:
    def __init__(self,name,price):
        self.name = name
        self.price = price

    def __repr__(self):
        return "<%s (%s)>" % (self.name,self.price)

class NullRule:
    def __getattr__(self, attr_name):
        def flimsy_func(*args,**kwargs):
            return self
        return flimsy_func

class Rule:
    def __init__(self,cart):
        self.cart = cart
        self.items = cart.items

    def for_customers(self, customer_list):
        if not self.cart.customer in customer_list:
            return NullRule()
        return self

    def discount(self, discount):
        for item in self.items:
            discount.run(item)
        return self

    def for_product(self, product_name):
        self.items = filter(lambda item: item.name == product_name, self.items)
        return self

    def if_product(self, product_name):
        if not product_name in map(lambda item: item.name, self.items):
            return NullRule()
        return self

    def when_total(self, conditional):
        if conditional.is_valid_for(sum([item.price for item in self.items])):
            return self
        return NullRule()


class Percent:
    def __init__(self,percent):
        self.percent = percent

    def run(self,product):
        product.price = product.price * (100-self.percent)/100

class Amount:
    def __init__(self,amount):
        self.amount = amount
    def run(self,product):
        product.price -= self.amount

class BiggerThan:
    def __init__(self, amount):
        self.amount = amount

    def is_valid_for(self, number):
        return number > self.amount