https://github.com/ruby2elixir/plugin
Plugin helps you to structure your business logic in composable blocks
https://github.com/ruby2elixir/plugin
Last synced: 9 months ago
JSON representation
Plugin helps you to structure your business logic in composable blocks
- Host: GitHub
- URL: https://github.com/ruby2elixir/plugin
- Owner: ruby2elixir
- Created: 2016-01-16T08:18:23.000Z (about 10 years ago)
- Default Branch: master
- Last Pushed: 2016-02-19T09:53:45.000Z (almost 10 years ago)
- Last Synced: 2025-03-28T02:05:20.785Z (10 months ago)
- Language: Elixir
- Homepage:
- Size: 25.4 KB
- Stars: 4
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# `Plugin` helps you to structure your business logic in composable blocks.
[](https://travis-ci.org/ruby2elixir/plugin)
[](https://hex.pm/packages/plugin)
Basically a light version of [Plug](https://github.com/elixir-lang/plug). Most of the code is a straight copy from Plug,
Think:
- `Plug` without web-specific logic and without a typed `Conn`.
## Story
After having structured my business logic with `middleware` pattern recently to keep it simple, testable and composable I came to like that pattern very much.
If you take a look at [Phoenix](github.com/phoenixframework/phoenix/) you see how far this pattern can be pushed and how reusable your bits of logic become.
So, I'd like to have a small library to help me build small modules that can be stacked together and composed in each other. I looked on Github and found this package: https://github.com/liveforeverx/plugin.git. It's mostly a copy-paste from Plug with some changes.
It gave me the initial direction, but it had no unit tests and was quite unusable.
So, I rewrote some bits and here we are.
## Installation
1. Add plugin to your list of dependencies in `mix.exs`:
def deps do
[{:plugin, "~> 0.1.0"}]
end
## Usage
All the rules how you structure/implement Plugs apply here:
- Module Plugins
- Function Plugins
- Builder Plugins
Example for Builder plugins:
```elixir
defmodule Plugin1 do
use Plugin.Builder
plugin :first_fn
def first_fn(acc, _) do
Map.put(acc, :first_fn_passed, true)
end
end
defmodule Plugin2 do
use Plugin.Builder
plugin :second_fn
def second_fn(acc, _) do
Map.put(acc, :second_fn_passed, true)
end
end
defmodule Plugin3 do
use Plugin.Builder
plugin Plugin1
plugin Plugin2
end
acc = Plugin.call(Plugin3, %{})
true = Map.get(acc, :first_fn_passed)
true = Map.get(acc, :second_fn_passed)
```
Module Plugin:
```elixir
defmodule PluginWithConfig do
use Plugin.Helpers # small convenience helpers
def init(opts) do
Keyword.put(opts, :current_ip, "0.0.0.0")
end
def call(acc, opts) do
acc
|> assign(:from, Keyword.get(opts, :current_ip) )
|> assign(:extra, Keyword.get(opts, :extra_info))
end
end
defmodule BuilderUsesPlugingWithConfig do
use Plugin.Builder
plugin PluginWithConfig, extra_info: "some_info"
end
acc = Plugin.call(BuilderUsesPlugingWithConfig, %{})
%{assigns: %{from: "0.0.0.0"}} = acc
%{assigns: %{extra: "some_info"}} = acc
```
To learn more about Plug please watch following freshly (2016/01) released videos:
- [Elixir Louisville: Plug, Friend of Web Developers](https://www.youtube.com/watch?v=-gev84S9_-c)
- [Elixir Louisville: Plug, Friend of Web Developers - Demo](https://www.youtube.com/watch?v=tfRD_e-yvOE)
- [Elixir Plug unveiled - 2015/09](https://medium.com/@kansi/elixir-plug-unveiled-bf354e364641#.phulhbtrd)
## Most of the code is taken directly from `plug`.
License for part of codes:
Copyright (c) 2013 Plataformatec.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
## Some links why you might consider "Middleware Pattern" as a general solution pattern even outside of web request / response cycle:
- https://twitter.com/mitchellh/status/237389160976101377
- https://twitter.com/mitchellh/status/235211110087786496
- http://programmers.stackexchange.com/questions/203314/what-is-the-middleware-pattern
- http://blog.carbonfive.com/2014/12/14/composing-data-pipelines-mostly-stateless-web-applications-in-clojure/
- https://speakerdeck.com/swlaschin/railway-oriented-programming-a-functional-approach-to-error-handling