blaix

class MySqlDb(object):
  def run(self, query):
    # whatever...


# ----------------------------------------------------------------------
# Here, Foo can get bars, AND knows exactly what db implementation to use:

class Foo:
  def __init__(self):

blaix

What I want:

Single-purpose "action" objects.

I want to look at a project's file structure and see what it does. Something like actions/create_article.rb that has a CreateArticle class who's only job is to create articles.

No controllers/viewsets that handle an entire set of CRUD operations on a resource.

Don't push request/response stuff into the business logic layer.

blaix

# single-purpose objects for handling requests:
class CreateArticle
  attr_reader :repo, :validations
  
  def initialize(repo:, validator:)
    @repo = repo
    @validator = validator
  end
  
  def call(params)

blaix

# Let's say we have a service class:
class Service(object):
    def get_article(self, id):
        return requests.get('/articles/' + id).json

# For the model, something like this is what we've been doing:
class Article(object):
    def init(self, id)
        self.id = id
        self.data = {}

blaix

def my_decorator(some_argument):
    def my_decorator_implementation(func):
        @wraps(func)
        def wrapped_func(self, *args, **kwargs):
            # do stuff with func and some_argument
        return wrapped_func
    return my_decorator_implementation

blaix

require "wren/application"

# The simplest Wren application has a route and a handler:

class HelloApp
  extend Wren::Routing # provides get/put/post/etc methods
  extend Wren::Application # provides handle and mount methods
                           # and a rack-compatible call method

  handle get("/hello/:name"), with: -> (name:, request:, response:) {

blaix

by Jim Gay: http://confreaks.tv/videos/rubyconf2014-eastward-ho-a-clear-path-through-ruby-with-oo

1. Always return self.
2. Objects may (only) query themselves.
3. Factories are exempt (e.g. new)
4. Break the rules sparingly (e.g. value objects)

blaix

# consider this simple password hasher (over-simplified of course):

def password_hash(self, salt, password):
  return (salt + password).reverse

# the unit tests are simple input vs output style:

def test_password_hash_returns_reverse_concatenated_salt_and_password(self):
  hashed = password_hash('foo', 'bar')
  self.assertEqual(hashed, 'raboof')

blaix

class Factory
  def foo(**kwargs)
    kwargs[:bar] ||= bar
    Foo.new(**kwargs)
  end
  
  def bar(**kwargs)
    kwargs[:baz] ||= baz
    Bar.new(**kwargs)
  end

blaix

index 69fa316..932df6a 100644
--- a/tddjango/pages/tests/test_views.py
+++ b/tddjango/pages/tests/test_views.py
@@ -7,7 +7,9 @@ from pages.views import PageView
 class TestPageView(TestCase):
     def setUp(self):
         self.page_repository = Mock()
-        self.view = PageView.as_view(repository=self.page_repository)
+        self.page_presenter = Mock()
+        self.view = PageView.as_view(