lux-fw 0.5.36 → 0.6.2

data/lib/common/time_difference.rb

@@ -0,0 +1,75 @@
+class TimeDifference
+  TIMES ||= [
+    [:year,   60 * 60 * 24 * 365],
+    [:month,  60 * 60 * 24 * 30],
+    [:day,    60 * 60 * 24],
+    [:hour,   60 * 60],
+    [:minute, 60]
+  ]
+
+  LOCALE ||= {
+    today: {
+      en: 'today',
+      hr: 'danas'
+    },
+    in: {
+      en: 'in',
+      hr: 'za'
+    },
+    before: {
+      en: 'before',
+      hr: 'prije'
+    },
+    in_few_econds: {
+      en: 'in few seconds',
+      hr: 'za par sekundi'
+    },
+    just_happend: {
+      en: 'just happend',
+      hr: 'upravo sada'
+    }
+  }
+
+  def initialize start_date, end_date = nil, klass = nil
+    unless end_date
+      @end_date   = start_date
+      @start_date = Time.now
+    end
+
+    @klass = klass
+  end
+
+  def humanize
+    diff = (@start_date.to_i - @end_date.to_i).abs
+
+    if @klass == Date && diff < TIMES[2][1]
+      return locale(:today)
+      # @start_date < @end_date ? locale(:in_few_econds) : locale(:just_happend)
+    end
+
+    TIMES.each do |(key, ref)|
+      value = diff / ref
+      return part(key, value) if value > 0
+    end
+
+    @start_date < @end_date ? locale(:in_few_econds) : locale(:just_happend)
+  end
+
+  # def set_locale key, value
+  #   raise ArgumentError.new('Key not found') unless locale(key)
+
+  #   LOCALE[key] = value
+  # end
+
+  private
+
+  def part key, value
+    kind = @start_date < @end_date ? locale(:in) : locale(:before)
+    text = [value, value > 1 ? '%ss' % key : key].join(' ')
+    [kind, text].join(' ')
+  end
+
+  def locale name
+    LOCALE[name][:en]
+  end
+end

data/lib/loader.rb

@@ -0,0 +1,41 @@
+Encoding.default_internal = Encoding.default_external = 'utf-8'
+
+Sequel.extension     :inflector
+Sequel::Model.plugin :after_initialize
+Sequel::Model.plugin :def_dataset_method
+
+Sequel.database_timezone = :utc
+# Sequel.default_timezone  = +2
+
+# load basic lux libs
+require_relative './overload/dir'
+require_relative './lux/lux'
+
+Lux::Config.set_defaults
+
+# load all lux libs
+[:overload, :common, :lux].each do |f|
+  Dir.require_all Lux.fw_root.join('./lib/%s' % f)
+end
+
+String.inflections do |inflect|
+  # inflect.plural /^(ox)$/i, '\1\2en'
+  # inflect.singular /^(ox)en/i, '\1'
+  # inflect.irregular 'octopus', 'octopi'
+  inflect.plural   'bonus', 'bonuses'
+  inflect.plural   'clothing', 'clothes'
+  inflect.plural   'people', 'people'
+  inflect.singular /news$/, 'news'
+  inflect.singular /Data$/i, 'Data'
+end
+
+# load Tilt parsers
+Haml::Template.options[:escape_html] = false
+# Tilt.register Tilt::ERBTemplate, 'erb'
+# Tilt.register Haml::Template, 'haml'
+
+# ensure we are not loading lux in lux folder
+if Lux.root != Lux.fw_root
+  # create folders if needed
+  ['./log', './tmp'].each { |d| `mkdir #{d}` unless Dir.exist?(d) }
+end

data/lib/lux/application/README.md

@@ -1,57 +1,15 @@
-## Lux::Application - main application controller and router
+## Lux.app (Lux::Application)
 
-* 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
+Main application controller and router
 
-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.
+* can capture errors with `rescue_from` class method
+* calls `before`, `routes` and `after` class filters on every request
 
 ```ruby
 Lux.app do
 
   def api_router
-    error :forbiden, 'Only POST requests are allowed' if Lux.prod? && !post?
+    error :forbiden, 'Only POST requests are allowed' if Lux.env.prod? && !post?
     Lux::Api.call nav.path
   end
 
@@ -63,40 +21,48 @@ Lux.app do
     error 404
   end
 
+  rescue_from :all do |error|
+    case error
+    when PG::ConnectionBad
+      # ...
+    when Lux::Error
+      # ...
+    else
+  end
+
   ###
 
   routes do
     # we show on root method, that target can be multiple object types, 5 variants
+    # this target is valid target for any of the follwing methods: get, post, map, call, root
     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
+    root 'root#index'             # calls RootController#index
+    root 'root'                   # calls RootController#call
+
+    root 'main/root'
+
+    # simple route, only for GET
+    map.about 'static#about' if get?
+
+    # execute blok if request_type is POST
+    post? do
+      # map "/api" to "api_router" method
+      map.api :api_router
+      # or
+      map api: :api_router
     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 method "city_map", if it returns true, proceed
+    map :city do
       # call MainController#city if request.method == 'GET'
-      map 'main#city' if get?
+      map 'main#city'
     end
 
     # if we match '/foo' route
-    namespace 'foo' do
+    map 'foo' do
       # call MainController#foo with params[:bar] == '...'
       map '/baz/:bar' => 'main#foo'
     end
@@ -104,44 +70,40 @@ Lux.app do
 end
 ```
 
-### Router rescues example
+#### Instance methods
 
-```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
+* routes requests to controllers via `map`, `root` and `call` methods
+* taget can be 3 object variants, look at the `call` example
+* `map` maps requests to controller actions
+  * `map.about => 'main#about' if get?` -> map '/about' to `MainControler#about` if request is `GET`
+  * `map about: 'main#about'` -> map '/about' to `MainControler#about`
+* `root` will call only for root
+  * `map.about => 'main#about' if get?` -> map '/about' to `MainControler#about` if request is `GET`
+  * `map about: 'main#about'` -> map '/about' to `MainControler#about`
+* `call` calls specific controller action inside call - stops routing parsing
+  * `call 'main/links#index'` - call `Main::LinksController#index`
+  * `call [Main::LinksController, :index]` - call `Main::LinksController#index`
+  * `call -> { [200, {}, ['OK']]}` - return HTTP 200 - OK
+
+#### Class filters
+
+There are a few route filtes
+* `config`      # pre boot app config
+* `boot`        # after rack app boot (web only)
+* `info`        # called by "lux config" cli
+* `before`      # before any page load
+* `routes`      # routes resolve
+* `after`       # after any page load
+* `rescue_from` # on routing error
+
+
+#### Router example
 
-    # use default error formater
-    Lux.error message
-  end
-end
+For Lux routing you need to know only few things
+
+* `get?`, `post?`, `delete?`, ... will be true of false based HTTP_REQUEST type
+  * `get? { @exec_if_true }` works as well
+* `map"`method accepts block that wraps map calls.
+  * `map :city do ...` will call `city_map` method. it has to return falsey if no match
+  * `map 'city' do ...` will check if we are under `/city/*` nav namespace
 
-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
-```