underworld 1.0.0

data/lib/underworld/fake_assets.rb

@@ -0,0 +1,5 @@
+require 'rails-assets-sugar'
+require 'jquery-rails'
+require 'admin_lte-rails'
+require 'nprogress-rails'
+require 'formtastic-bootstrap'

data/lib/underworld/i18n.rb

@@ -0,0 +1,101 @@
+module ::ActionView
+  # = Action View Translation Helpers
+  module Helpers
+    module TranslationHelper
+
+      def t(key, options = {})
+        options = options.dup
+        has_default = options.has_key?(:default)
+        remaining_defaults = Array(options.delete(:default)).compact
+
+        if has_default && !remaining_defaults.first.kind_of?(Symbol)
+          options[:default] = remaining_defaults
+        end
+        # If the user has explicitly decided to NOT raise errors, pass that option to I18n.
+        # Otherwise, tell I18n to raise an exception, which we rescue further in this method.
+        # Note: `raise_error` refers to us re-raising the error in this method. I18n is forced to raise by default.
+        if options[:raise] == false
+          raise_error = false
+          i18n_raise = false
+        else
+          raise_error = options[:raise] || ActionView::Base.raise_on_missing_translations
+          i18n_raise = true
+        end
+
+        if html_safe_translation_key?(key)
+          html_safe_options = options.dup
+          options.except(*I18n::RESERVED_KEYS).each do |name, value|
+            unless name == :count && value.is_a?(Numeric)
+              html_safe_options[name] = ERB::Util.html_escape(value.to_s)
+            end
+          end
+          translation = I18n.translate(scope_key_by_partial(key), html_safe_options.merge(raise: i18n_raise))
+
+          translation.respond_to?(:html_safe) ? translation.html_safe : translation
+        else
+          I18n.translate(scope_key_by_partial(key), options.merge(raise: i18n_raise))
+        end
+      rescue I18n::MissingTranslationData => e
+        if remaining_defaults.present?
+          translate remaining_defaults.shift, options.merge(default: remaining_defaults)
+        else
+          raise e if raise_error
+
+          keys = I18n.normalize_keys(e.locale, e.key, e.options[:scope])
+          title = keys.last.to_s.humanize
+          title = "#{keys.join('.')}" if Underworld::Engine.i18n_debug
+
+          interpolations = options.except(:default, :scope)
+          if interpolations.any?
+            title << ", " << interpolations.map { |k, v| "#{k}: #{ERB::Util.html_escape(v)}" }.join(', ')
+          end
+
+          #content_tag('span', keys.last.to_s.titleize, class: 'translation_missing', title: title)
+          title
+        end
+      end
+    end
+  end
+end
+
+module Underworld
+  # I18n related utility functions
+  class I18n
+    RTL = [:fa, :ar]
+
+    def self.direction(locale)
+      if RTL.include? locale.to_sym
+        'rtl'
+      else
+        'ltr'
+      end
+    end
+
+    module Locale
+      def self.default_url_options
+        { :locale => I18n.locale }
+      end
+    end
+
+    class MissingKeyHandler < ::I18n::ExceptionHandler
+      require 'fileutils'
+
+      def create_key_cache(locale, key)
+        locale_dir = "#{Rails.root}/tmp/i18n/#{locale}"
+        key_file   = "#{locale_dir}/#{key}"
+
+        FileUtils.mkdir_p locale_dir
+        FileUtils.touch [key_file]
+      end
+
+      def call(exception, locale, key, options)
+        if exception.is_a?(::I18n::MissingTranslation)
+          create_key_cache(locale, key)
+          super
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/underworld/liquid.rb

@@ -0,0 +1,7 @@
+module Underworld
+  module Liquid
+    autoload :Tag,       'underworld/liquid/tag'
+    autoload :Block,     'underworld/liquid/block'
+    autoload :RenderTag, 'underworld/liquid/render_tag'
+  end
+end

data/lib/underworld/liquid/block.rb

@@ -0,0 +1,14 @@
+module Underworld
+  module Liquid
+    class Block < ::Liquid::Block
+
+      def self.block_name(name)
+        @@name = name
+      end
+
+      def self.name
+        @@name
+      end
+    end
+  end
+end

data/lib/underworld/liquid/render_tag.rb

@@ -0,0 +1,50 @@
+module Underworld
+  module Liquid
+    # In order to use this class make sure to override the `before_render`
+    # and implement you logic there, Don't bother to override the `render`
+    # method
+    class RenderTag < Tag
+
+      class << self
+        def view(value)
+          define_method(:_view) do
+            value
+          end
+        end
+      end
+
+      def before_render(context)
+      end
+
+      def render(context)
+        before_render(context)
+        render_template(context)
+      end
+
+      private
+
+      def render_template(context)
+
+        controller = context.registers[:controller]
+        view_paths = controller.view_paths
+        request    = context.registers[:view].request
+        controller = controller.class
+
+        controller.view_paths = view_paths
+
+        patched_request = assignments.merge(request.env)
+        renderer = controller.renderer.new(patched_request)
+
+        renderer.render _view, layout: nil
+      end
+
+      def assignments
+        tmp = instance_variable_names.map do |x|
+          [x[1..-1], instance_variable_get(x)]
+        end
+
+        { assigns: Hash[tmp] }
+      end
+    end
+  end
+end

data/lib/underworld/liquid/tag.rb

@@ -0,0 +1,51 @@
+module Underworld
+  module Liquid
+    class Tag < ::Liquid::Tag
+
+      attr_reader :arguments, :params
+
+      # This method produce the `tag_name` DSL which is mandatory for
+      # each tag and defines the tag name that the tag class should be
+      # registered with
+      def self.tag_name(name)
+        @@name = name
+      end
+
+      def self.name
+        @@name
+      end
+
+      def self.argument(options)
+        raise ArgumentError.new "'name' is mandatory for argument in '#{self.class.name}'" if options[:name].nil?
+
+        @arguments ||= []
+        @arguments << options
+      end
+
+      def initialize(name, args, options)
+        super
+
+        if !arguments.empty? && (args.nil? || args.empty?)
+            count = arguments.length
+            raise ArgumentError.new "'#{count}' argument(s) is/are needed for '#{self.class.name}' tag."
+        end
+
+        @direction   = ::Underworld::I18n.direction(::I18n.locale)
+
+        @args = args.split(',').map do |x|
+          x.strip.tr('""', '').tr("''", '')
+        end
+
+        @params = {}
+
+        arguments.each_with_index do |arg, index|
+          @params[arg[:name]] = @args.fetch(index, arg[:default])
+        end
+      end
+
+      def arguments
+        @arguments ||= []
+      end
+    end
+  end
+end

data/lib/underworld/middlewares.rb

@@ -0,0 +1 @@
+require 'underworld/middlewares/locale'

data/lib/underworld/middlewares/locale.rb

@@ -0,0 +1,29 @@
+module Underworld
+  module Middlewares
+
+    # Locale middleware for `Underworld`. This middleware try to set
+    # the locale from url.
+    class Locale
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        req = Rack::Request.new(env)
+
+        # Check whether locale is presence or not.
+        if locale = req.path_info.match(/^([a-z]{2})\/.*/)
+          # If its set the default locale to it.
+          locale = locale[1]
+        else
+          # Use pre-defined default if it isn't
+          locale = ::I18n.default_locale
+        end
+
+        req.params['locale'] ||= locale
+        ::I18n.locale = locale
+        @app.call env
+      end
+    end
+  end
+end

data/lib/underworld/omniauth.rb

@@ -0,0 +1,8 @@
+module Underworld
+  module Omniauth
+    # TODO: Autoload ? really ?
+    #       Change it ASAP. Remember that callback should
+    #       not included if host project does not have omniauth enabled
+    autoload :Callbacks, "underworld/omniauth/callbacks"
+  end
+end

data/lib/underworld/omniauth/callbacks.rb

@@ -0,0 +1,39 @@
+module Underworld
+  module Omniauth
+
+    module Callbacks
+
+
+      def default_service_callback
+
+        create_or_find_user
+
+        if @user.persisted?
+          # This will throw if @user is not activated
+          sign_in_and_redirect @user, :event => :authentication
+          set_flash_message(:notice, :success, :kind => __callee__.to_s) if is_navigational_format?
+        else
+          session["devise.omni_data"] = request.env["omniauth.auth"]
+          redirect_to new_user_registration_url
+        end
+      end
+
+
+      if Devise.omniauth_configs.any?
+        Devise.omniauth_configs.keys.each do |provider|
+          unless method_defined? provider
+            send(:define_method, provider.to_sym) {default_service_callback}
+          end
+        end
+      end
+
+      private
+
+      def create_or_find_user
+        # This method is implemented in User model
+        @user = User.find_from_oauth(request.env["omniauth.auth"], current_user)
+      end
+
+    end
+  end
+end

data/lib/underworld/orm.rb

@@ -0,0 +1,30 @@
+module Underworld
+  # A very simple class which provide functionalities to work with
+  # current orm
+  class ORM
+
+    def self.active_record?
+      current == 'active_record'
+    end
+
+    def self.mongoid?
+      current == 'mongoid'
+    end
+
+    # current orm
+    def self.current
+      ::Underworld::Engine.orm.to_s
+    end
+
+    # This class method returns the base class of current ORM
+    # It will be used in models to specify which class to inherit
+    # from, based on current ORM
+    def self.proper_base_class
+      #TODO: fix this for rails 5 which has a new parent for each model
+      return ::ActiveRecord::Base if active_record?
+      return ::Object if mongoid?
+      ::Underworld::Engine.orm = 'active_record'
+      ::ActiveRecord::Base
+    end
+  end
+end

data/lib/underworld/routes.rb

@@ -0,0 +1,117 @@
+module Underworld
+  module RouteHelpers
+
+    # routes to be added to dashboard
+    def in_dashboard
+      namespace Underworld::Engine.dashboard_namespace do
+        yield
+      end
+    end
+
+    # Allow localized scope
+    def localized_scope
+      langs = ::I18n.available_locales.join('|')
+      scope '(:locale)', locale: Regexp.new(langs) do
+        yield
+      end
+    end
+
+    # This method allow user to define his routes in api
+    # namespace
+    def api_routes(version: :v1)
+      # TODO: Add a dynamic solution for formats
+      namespace :api, defaults: { format: :json } do
+        namespace version do
+          # Call user given block to define user routes
+          # inside this namespace
+          yield if block_given?
+        end
+      end
+
+      scope 'module'.to_sym => 'underworld' do
+        #dashboard = Underworld::Engine.dashboard_namespace
+        #get "#{dashboard}/auth/groups/new", to: "#{dashboard}/groups#new"
+        get 'auth/profile/edit', to: "profile#edit"
+        post 'auth/profile/edit', to: "profile#update"
+      end
+
+      # TODO: Add a dynamic solution for formats
+      namespace :api, defaults: { format: :json } do
+        namespace version do
+          get 'permissions',      to: 'permissions#index'
+          get 'permissions/user', to: 'permissions#user_permissions'
+          resources :groups,      except: [:new]
+          resources :users,       except: [:new]
+          resource :profile,      except: [:new, :destroy]
+
+          get 'logs', to: 'logs#index'
+        end
+      end
+    end
+  end
+
+
+  class Routes
+
+    class << self
+
+      attr_accessor :engine
+
+      def underworld(&block)
+        Underworld::Engine.routes.draw(&block)
+      end
+
+      def plugin(&block)
+        self.engine.routes.draw(&block)
+      end
+
+      def draw(engine, &block)
+        self.engine = engine
+
+        raise ArgumentError.new 'block is needed' unless block_given?
+
+        self.class_eval(&block)
+      end
+
+      def localized_scop(router: Rails.application.routes)
+        puts '[Warning]: This method is depricated please just use "localized_scope" in your router.'
+        langs = ::I18n.available_locales.join('|')
+        router.scope '(:locale)', locale: Regexp.new(langs)
+      end
+
+      # This class method will add `Underworld` routes to host application
+      # Router
+      def define_api_routes(routes: Rails.application.routes,
+        version: :v1)
+        puts '[Warning]: This method is depricated. Please use "api_routes" directly in your router.'
+        routes.draw do
+          # TODO: Add a dynamic solution for formats
+          namespace :api, defaults: { format: :json } do
+            namespace version do
+              # Call user given block to define user routes
+              # inside this namespace
+              yield self if block_given?
+
+            end
+          end
+
+          scope 'module'.to_sym => 'underworld' do
+            # TODO: Add a dynamic solution for formats
+            namespace :api, defaults: { format: :json } do
+              namespace version do
+                get 'permissions',      to: 'permissions#index'
+                get 'permissions/user', to: 'permissions#user_permissions'
+                resources :groups,      except: [:new]
+                resources :users,       except: [:new]
+                resource :profile,      except: [:new, :destroy]
+
+                get 'logs', to: 'logs#index'
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end