lux-fw 0.5.32 → 0.5.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 809c29122351db4ad4bd4de489f14f54c263b8911cc6d41b91d411beeaffe959
-  data.tar.gz: f4912bd49fbe63229dbccab2582c13cdf308299e4194a001c150e5e54765e7ae
+  metadata.gz: 3d0b06d65d3e76de965f29a418513ce4f7cae994353e31d072cbeb5224057996
+  data.tar.gz: 42158b78a77c6bcbdd001804c57752f6e2d35fd809d6bdfe324193019d8aef8f
 SHA512:
-  metadata.gz: d919b51494836f5e12af3fe372689ed721607205d92bc2668dc075f795b65cb867bd0b642b228bf98cdca30e071acaf4fbaf10c68dc5057a2ddfc43ef88ea660
-  data.tar.gz: 2e514b0713c9d3dd9ad2e7c4ff91386a30fc839335a60ffa7c10d504eea8a2b1b8f76785c2568d2bd0ecc8f697d6ba5c6d674bf59fe45c502cf3b510b90490c4
+  metadata.gz: bb2144cef763d0bc2ee5532bd2be220f1deb232c9d9aaf21dfe4ededf13114f0007bb63f96deee4f7f2600e1d6e4740197929aa125988a7dd2fa526f499ea2a5
+  data.tar.gz: 40567507bed00de677822736bfa49efef2414ebe1c4751720eda24c27c694a990307fc4cabb834dd1249b6a0b43ea9b01ffbdd08106ff04b03c6d0dbee2fae46

data/.version

@@ -1 +1 @@
-0.5.32
+0.5.33

data/lib/README.md

@@ -0,0 +1,30 @@
+# LUX - ruby web framework
+
+![Lux logo](https://i.imgur.com/Zy7DLXU.png)
+
+* rack based
+* explicit, avoid magic when possible
+
+created by @dux in 2017
+
+## How to start
+
+First, make sure you have `ruby 2.x+`, `npm 6.x+` and `yarn 1.x+` installed.
+
+Install Lux framework.
+
+`gem install lux-fw`
+
+Create new template for lux app
+
+`lux new my-app`
+
+Start the app
+
+`lux s`
+
+Look at the generated code and play with it.
+
+## Lux components
+
+

data/lib/lux/README.md

@@ -0,0 +1,10 @@
+# Page render flow
+
+## Example config ru
+```
+$lux_start_time = Time.now
+require './config/application'
+Lux.serve self
+```
+
+* if you define `$lux_start_time` you will get speed load statistics

data/lib/lux/application/README.md

@@ -0,0 +1,147 @@
+## Lux::Application - main application controller and router
+
+* can capture errors with `on_error` instance method
+* calls `before`, `routes` and `after` class filters on every request
+* routes requests to controllers via `map`, `root` and `call` methods
+
+### Instance methods
+
+#### root
+
+executes if nav.root is empty
+
+#### map
+
+map specific nav root to Controller and calls if root mathes
+
+for example if path is /blogs
+
+`map blogs: Main::BlogController`
+
+will call instance method call with @path expanded
+
+`Main::BlogController.new.call(*@path)`
+
+more examples
+
+* `map blog: BlogController` will call `BlogController.action(:blog)`
+* `map blog: 'blog#single'` will call `BlogController.action(:single)`
+* `map blog: -> { BlogController.custom(:whatever) }`
+
+### call
+
+Calls specific controller action inside call.
+
+```ruby
+  call 'main/links#index'
+  call [Main::LinksController, :index]
+  call -> { [200, {}, ['OK']]}
+```
+
+### Router example
+
+For Lux routing you need to know only few things
+
+* taget can be 5 object variants, look at root example
+* "root" method calls object if nav.root is blank?
+* "map" method calls object if nav.first == match
+* "namespace" method accepts block that wraps map calls.
+
+```ruby
+Lux.app do
+
+  def api_router
+    error :forbiden, 'Only POST requests are allowed' if Lux.prod? && !post?
+    Lux::Api.call nav.path
+  end
+
+  before do
+    check_subdomain
+  end
+
+  after do
+    error 404
+  end
+
+  ###
+
+  routes do
+    # we show on root method, that target can be multiple object types, 5 variants
+    root [RootController, :index] # calls RootController#index
+    root 'root#call'              # calls RootController#call
+    root :call_root               # calls "call_root" method in current scope
+    root 'root'                   # calls RootController#index
+    root 'root#foo'               # calls RootController#foo
+
+    # we can route based on the user status
+    root User.current ? 'main/root' : 'guest'
+
+    # map "/api" to "api_router" method
+    map api: :api_router
+
+    # with MainController
+    # map MainController do
+    map 'main' do
+      map :search      # map "/search" to MainController#search
+      map '/login'     # map "/login" to MainController#login
+    end
+
+    # map "/foo/dux/baz" route to MainController#foo with params[:bar] == 'dux'
+    map '/foo/:bar/baz'  => 'main#foo'
+
+    # if method "city" in current scope returns true
+    namespace :city do
+      # call MainController#city if request.method == 'GET'
+      map 'main#city' if get?
+    end
+
+    # if we match '/foo' route
+    namespace 'foo' do
+      # call MainController#foo with params[:bar] == '...'
+      map '/baz/:bar' => 'main#foo'
+    end
+  end
+end
+```
+
+### Router rescues example
+
+```ruby
+Lux.app do
+  def on_error error
+
+    message = case error
+      when PG::ConnectionBad
+        msg = error.message || 'DB connection error, please refresh page.'
+        msg = "PG: #{msg}"
+        Lux.logger(:db_error).error msg
+        msg
+
+      when Lux::Error
+        # for handled errors
+        # show HTTP errors in a browser without a log
+        Main::RootController.action(:error, error)
+
+      else
+        # raise errors in developmet
+        raise error if Lux.dev?
+
+        key = Lux.error.log error
+        "#{error.class}: #{error.message} \n\nkey: #{key}"
+    end
+
+    # use default error formater
+    Lux.error message
+  end
+end
+
+if Lux.prod?
+  Lux.config.error_logger = proc do |error|
+    # log and show error page in a production
+    key = SimpleException.log error
+    Lux.cache.fetch('error-mail-%s' % key) { Mailer.error(error, key).deliver }
+    Lux.logger(:exceptions).error [key, User.current.try(:email).or('guest'), error.message].join(' - ')
+    key
+  end
+end
+```

data/lib/lux/cache/README.md

@@ -0,0 +1,47 @@
+## Lux::Cache - Mimics Rails.cache interface
+
+Alias - `Lux.cache`
+
+### Define
+
+use RAM cache in development, as default
+
+```
+Lux::Cache.server = :memcached
+```
+
+You can use memcached or redis in production
+
+```
+Lux::Cache.server  = Dalli::Client.new('localhost:11211', { :namespace=>Digest::MD5.hexdigest(__FILE__)[0,4], :compress => true,  :expires_in => 1.hour })
+```
+
+### Lux::Cache instance methods
+
+Mimics Rails cache methods
+
+```
+  Lux.cache.read(key)
+  Lux.cache.get(key)
+
+  Lux.cache.read_multi(*args)
+  Lux.cache.get_multi(*args)
+
+  Lux.cache.write(key, data, ttl=nil)
+  Lux.cache.set(key, data, ttl=nil)
+
+  Lux.cache.delete(key, data=nil)
+
+  Lux.cache.fetch(key, ttl=nil, &block)
+
+  Lux.cache.is_available?
+```
+
+Has method to generate cache key
+
+```
+  # generates unique cache key based on set of data
+  # Lux.cache.generate_key([User, Product.find(3), 'data', @product.updated_at])
+
+  Lux.cache.generate_key(*data)
+```

data/lib/lux/config/README.md

@@ -0,0 +1,63 @@
+# Lux::Config - Config loader helpers
+
+Methods for config and pluin loading.
+
+## Lux::Config::Plugins
+
+* loads plugins in selected namespace, default namespace :main
+* gets plugins in selected namespace
+
+```ruby
+Lux.plugin name_or_folder
+Lux.plugin name: :foo, folder: '/.../...', namespace: [:main, :admin]
+Lux.plugin name: :bar
+
+Luxp.lugin.folders :admin # => [:foo]
+Luxp.lugin.folders # => [:foo, :bar]
+```
+
+## Lux::Config::Secrets
+
+Similar to rails 5.1+, we can encode secrets for easy config.
+
+* using JWT HS512
+* create and write sectes in YAML format in `./tmp/secrets.yaml`
+* run `lux secrets` to compile secretes to `./config/secrets.txt`
+* use "shared" hash for shared secrets
+* sectets are available in app via `Lux.secrets`, as struct object
+
+### lux secrets
+
+* compiles unencoded sectes from `./tmp/secrets.yaml` to `./config/secrets.txt`
+* creates editable file `./tmp/secrets.yaml` from `./config/secrets.txt` if one exists
+* shows available secrets for current environment
+
+### Example
+
+Env development
+
+Secrets file `./tmp/secrets.yaml`
+
+```
+shared:
+  x: s
+  b:
+    c: nested
+
+production:
+  a: p
+
+development:
+  a: d
+```
+
+`lux secrets` - will compile secrets or create template if needed
+
+`lux c` - console
+
+```ruby
+Lux.secrets.a == "d"
+Lux.secrets.x == "s"
+Lux.secrets.b.c == "nested"
+```
+

data/lib/lux/controller/README.md

@@ -0,0 +1,49 @@
+## Lux::Controller - Simplified Rails like view controllers
+
+Controllers are Lux view models
+
+* all cells shoud inherit from Lux::Controller
+* `before`, `before_action` and `after` class methods supportd
+* instance_method `on_error` is supported
+* calls templates as default action, behaves as Rails controller.
+
+### Example code
+
+```ruby
+require 'lux-fw'
+
+class Main::RootController < Lux::Controller
+  # action to perform before
+  before do
+    @org = Org.find @org_id if @org_id
+    # ...
+  end
+  # action to perform before
+
+  before_action do |action_name|
+    next if action_name == :index
+    # ...
+  end
+
+  ###
+
+  mock :show # mock `show` action
+
+  def index
+    render text: 'Hello world'
+  end
+
+  def foo
+    # renders ./app/views/main/root/foo.(haml, erb)
+  end
+
+  def baz
+    send_file local_file, file_name: 'local.txt'
+  end
+
+  def bar
+    render json: { data: 'Bar text' }
+  end
+
+end
+```

data/lib/lux/current/README.md

@@ -0,0 +1,14 @@
+## Lux::Current - Main state object
+
+Current application state as single object. Defined in Thread.current, available everywhere.
+
+`Lux.current` - current response state
+
+* `session`         - session, encoded in cookie
+* `locale`          - locale, default nil
+* `request`         - Rack request
+* `response`        - Lux response object
+* `nav`             - lux nav object
+* `cookies`         - Rack cookies
+* `can_clear_cache` - set to true if user can force refresh cache
+

data/lib/lux/delayed_job/README.md

@@ -0,0 +1,3 @@
+## Delayed job
+
+to do

data/lib/lux/error/README.md

@@ -0,0 +1,41 @@
+## Lux::Errors - In case of error
+
+### module Lux::Error
+
+```ruby
+  # try to execute part of the code, log exeception if fails
+  def try(name, &block)
+
+  # HTML render style for default Lux error
+  def render(desc)
+
+  # show error page
+  def show(desc)
+
+  # show inline error
+  def inline(name=nil, o=nil)
+
+  # log exeption
+  def log(exp_object)
+```
+
+
+### defines standard Lux errors and erro generating helpers
+
+```ruby
+# 400: for bad parameter request or similar
+Lux::Error.forbidden foo
+
+# 401: for unauthorized access
+Lux::Error.forbidden foo
+
+# 403: for unalloed access
+Lux::Error.forbidden foo
+
+# 404: for not found pages
+Lux::Error.not_found foo
+
+# 503: for too many requests at the same time
+Lux::Error.forbidden foo
+
+```

data/lib/lux/event_bus/README.md

@@ -0,0 +1,36 @@
+# Super simple event pub/sub
+
+## to add events
+
+```ruby
+  Lux::EventBus.on('test') { |arg| puts 'foo: %s' % arg }
+  Lux.event.on('test', :foo) { |arg| puts 'bar: %s' % arg }
+  Lux.event.on('test', :foo) { |arg| puts 'baz: %s' % arg }
+  Lux.event.on('test') { |arg| raise 'abc' }
+
+  ###
+  # foo: xxx
+  # baz: xxx
+  # error logged
+```
+
+
+## to call
+
+```ruby
+  Lux.event.call 'test', 'xxx'
+```
+
+
+## Error handler
+
+Default event bus error handle.
+
+```ruby
+  Lux.config.on_event_bus_error = proc do |error, name|
+    Lux.logger(:event_bus).error '[%s] %s' % [name, error.message]
+  end
+```
+
+
+